Hi, I'm Ibrahim. I've been solving cubes for a long time, and once I started competing, it stopped being just a hobby for me and became something far more serious. As my practice grew more serious, I found myself asking the same questions after every solve: Where did I lose time, which transition slowed me down, which algorithm have I still not quite nailed? The tools I was using were perfectly good at keeping time, but they didn't do much to help me find those answers. What I wanted was a tool where I could study my solves in depth, practise my algorithms in an organised way, and do all of it in one place. I tried different apps, but none of them was quite what I was looking for, so in the end I decided to build it myself.

At first my goal was quite modest: I just wanted a simple timer for my own use, one where I understood every detail. But every piece I added brought a new need along with it. First I wrote analysis tools to study my solves, then the trainer to practise algorithms, and after that I added smart cube connectivity and syncing across devices. None of it was as easy as it might sound; every cube brand's Bluetooth protocol was a puzzle of its own, a feature that worked flawlessly on one device could break on another in a place I never expected, and sometimes I spent hours, even days, chasing a single bug. Still, every problem I solved carried me one step further, and over time that little timer grew into an ecosystem of its own.

The project started in 2025, and since then it has come a long way from where it began. What started on the web gradually moved to iOS and Android; today the same codebase runs in the browser, on phones and on tablets. I walked most of this road on my own. From store reviews to payment systems, from native code to real-time matches, every step was its own learning process, and almost none of them fell into place on the first try. Throughout this time my work was never just about adding new features; the real struggle was revisiting systems again and again, redesigning some of them from scratch more than once, and making sure every piece worked in harmony with the rest.

A tool I first wrote only for myself has become a place where other cubers train every day, race each other and follow competitions. Seeing someone I've never met break a personal best on Zkt Timer tells me that all that effort wasn't for nothing. A good share of new features now comes from the feedback of the people who use it, too. I don't see Zkt Timer as a finished product; it's a project I still work on every day, one that keeps growing, and honestly, I feel I'm still only at the beginning of this road.

Zkt Timer — ibrhyyme
The person who designs and develops Zkt Timer.

Credits

Earlier I said I walked most of this road on my own, but the truth is I was never really alone. The speedcubing world has a remarkably generous open-source culture that has grown over the years, and while building Zkt Timer I drew on it constantly. I studied many projects at length; some I ran on my own computer to try them out, and others I read line by line just to truly understand how they worked.

I learned something different from each project. Some guided me on technical matters such as scramble generation or solver approaches; others helped me see what really works on the trainer and user experience side. Sometimes an algorithm idea, sometimes a data model, and sometimes a way of looking at a whole system was what cleared the way when I was stuck.

Rather than taking these pieces and using them as they were, I revisited each one so it would fit Zkt Timer's own structure. I rewrote most of the systems from scratch, simplified some, and extended others as the need arose. Bringing approaches from different sources together under a single architecture, working in harmony with one another, was both the hardest and the most rewarding part of this process.

That is why the structure that exists today doesn't rest on any single source; it took shape by bringing together and rebuilding what I learned from many different projects. But I should say this plainly: without the work of the developers named below, Zkt Timer would never have become what it is today in so short a time.

I believe that moving something forward is never only about adding something new; understanding the work that came before you, respecting it, and building an honest contribution on top of it matter just as much. That is why giving due credit to everyone who has touched this project, directly or indirectly, is for me less a matter of courtesy than a debt to be repaid.

Each of the projects and developers I name below played a different part in shaping Zkt Timer. Some were the starting point of an idea, some helped me solve a problem I had been stuck on for a long time, and some broadened my horizons and let me see a better approach. Most of this work was built by people who gave up their own free time and shared it with everyone without expecting anything in return; I understood how valuable that is far better once I took on the same load in my own project.

To everyone who shares their effort, time and knowledge with this community, I offer my deepest respect and heartfelt thanks. I'm so glad you're out there.

— ibrhyyme

What's New in Zkt Timer

This section covers the features designed and developed for Zkt Timer. Each one grew out of the platform's own needs and the feedback that came from its users.

Competition Notification & Countdown System
Zkt Timer generates automatic notifications for the competitions you follow. Registration opening, publication of groups and assignments, results being entered and records being broken are all delivered as notifications, and a countdown runs up to the competition date. The system runs as scheduled jobs on the server and produces both in-app and push notifications.
Record Radar
Calculates in advance which records could fall at a competition you are attending. The competitor list, the event schedule and the current national records are compared to determine which records are at risk, and the result is shown on the competition page.
Native Mobile App
Zkt Timer ships as a native app on iOS and Android. Smart cube connectivity runs through a native BLE layer, and accelerometer and haptic support are provided through native plugins. Edge gestures, safe areas and keyboard behaviour are handled separately for each platform.
Magnet Timer
A timer type, exclusive to the iOS and Android apps, that keeps time without touching the screen. The phone lies flat on the table and the cube rests at its rear camera end; the phone's compass sensor picks up the magnets inside the cube. Lifting the cube starts the timer, and putting it down on the table stops it. Because every phone's sensor behaves differently, calibration is done per cube and per phone model, with thresholds derived from the sensor's raw values. The native layer that reads the sensor was written separately for iOS and Android, and the detection logic was tested against recordings from real devices.
Full Offline Mode
Solves can be recorded, sessions can be opened and statistics can be viewed with no internet connection. When the connection returns, pending solves are queued and reconciled with the server, conflicts are resolved, and duplicate records are filtered out by fingerprint.
Offline Battle (1v1)
A mode where two people compete head to head on the same device. On phones and tablets the screen splits into two facing halves; on desktop the players sit side by side and use the A and L keys. Players start independently, and each can connect their own smart cube. Penalties and scores are tracked separately, and round history is stored in detail.
Online Battle
A 1v1 match played with a smart cube against another player who is searching at the same moment. Both players solve the same scramble, and the first to win three rounds takes the match. Time is measured by the cube's own clock rather than over the internet, so connection lag does not affect the result. Matchmaking widens its rating window the longer you wait; the server runs the match and verifies every solve against its move log and the cube's clock. Ratings are calculated with Glicko-2 and listed on the Rankings page.
Algorithm Sets
A way to collect the algorithms you want to practice in your own sets. Cases from different categories such as OLL, PLL and F2L can sit in the same set. A set can stay private, be shared by link only, or be made public, and a shared link opens with its own preview. Public sets are listed in Community Sets, where others can save them. Changes are saved instantly, and sets are also kept on the device for offline use.
Messages
A messaging system for one-to-one conversations between users. A first message from someone new does not land straight in the inbox; it waits for approval in the Requests tab. A solve can be attached to a conversation, and the other person sees the time and can open the solve's details. Sent messages can be edited or unsent. Who may write to you, read receipts, the typing indicator and the online dot all follow each user's own settings, and blocking and reporting are built in.
Personalization
Puzzle colors are chosen in separate groups, from 2x2 to 7x7 plus Square-1, Clock and FTO, and every drawing in the app follows them: the scramble image, the smart cube view and the rest. An image or an MP4 video of up to 40 MB can go behind the timer; the video pauses during a solve, and the setting is kept per device. On desktop, the modules on the timer screen can be dragged freely into the columns, the bottom strip or any empty spot, and resized by their edges.
Cuber Card
A shareable card that turns profile information into a single image. Avatar, name, competition count, medals and WCA records appear on the card. It hooks into the native share sheet on mobile and into a direct download on desktop.

References

The projects below served as references in different ways throughout Zkt Timer's development. Each entry states two things: what was taken from that project, and what was built on top of it.

cubedesk — kash
My strongest reference on the software architecture side of Zkt Timer. How React + SSR, Node.js + GraphQL, PostgreSQL + Prisma and Redis fit together inside a cubing platform was worked out by studying cubedesk by kash. It guided the service organisation and folder structure. Its influence was not limited to the server side: the interface language cubedesk established was also a reference for the timer screen layout, the solve list and the module arrangement. Where we part ways: cubedesk is a web app. I wanted the same codebase to ship to iOS and Android through Capacitor, so I rebuilt the SSR layer, the session handling and the cross-device sync to carry the native side as well.
csTimer + min2phase — cs0x7f
The foundation of scramble generation. The scramble algorithms and subset structure for the puzzle types, the min2phase Kociemba solver and the group theory library were built with reference to csTimer and min2phase by cs0x7f. While moving this code from JavaScript to TypeScript it was restructured around a registry-based generator architecture; every puzzle type now registers its own generator, and the client and the server can produce the same scramble. On top of that, more than 40 CFOP, Roux, Mehta and ZZ subsets, my own 2D renderers for Square-1 and Clock, and a Web Worker layer that runs the heavy solvers without freezing the interface were added.
cubedex — Pau Oliva Fora (poliva)
One of my main references for the user experience side of the Trainer module. How a smart cube connects into a drilling flow was worked out by studying Pau Oliva Fora's project. In Zkt Timer this structure was split into four separate modes (Standard, Smart Cube, Recognition, Efficiency); per-algorithm statistics were kept, the queue order was made to adapt to the cases a user is weak at, and 2D and 3D pattern visualisation plus PDF export for printing algorithm sheets were added.
cubingapp — spencerchubb
A large portion of the algorithm collection used in the Trainer came from the cubingapp dataset created by spencerchubb and was adapted to Zkt Timer's data model. The setup algorithms were regenerated with my own scripts, the pattern images were run through my own rendering pipeline, the collection was split into 31 categories and extended with algorithms of my own.
RubiksSolverDemo — or18
The starting point for the Cross, XCross, EOCross and F2L pair solver logic. The coordinate-based IDA* implementations developed by or18 were a fundamental reference in the design of Zkt Timer's solver system. The work in this module was porting and adaptation: the solvers were moved into a Web Worker architecture and wired into a step-by-step solution interface. The mathematics behind the algorithm belongs to or18.
LetsCube — coder13
The conceptual basis for 1v1 rooms and the friendly-race format comes from this project. How a synchronised, shared solve model is built was worked out by studying coder13's work. Zkt Timer's room system was written from scratch on top of that idea, and the following were added as things I considered missing in LetsCube: smart cube support inside rooms, live chat, spectator mode, room moderation and user banning, a 1v1 duel mode, and a Socket.IO layer that broadcasts across multiple servers through Redis.
competitor-groups — coder13
A project built so competitors can follow their own groups and assignments at WCA competitions, and it does that job very well. I did not want competitors to have to visit a separate site for this information, so the same experience was brought inside Zkt Timer. A competitor's own schedule, their judging and scrambling assignments, their per-event personal bests and their round results are now gathered on a single screen. The layout of the group screens took shape under the influence of this project.
wca-live — WCA Software Team
A platform built for following WCA competitions live, and one that solves round-by-round result flow genuinely well. The WCA Software Team's work was the direct source for the structural approach of the WCA Live integration in Zkt Timer. The ZKT competition platform itself was written from scratch for Zkt Timer: registration, scorecard entry, batch entry mode, round management, judge, scrambler and runner assignment, national record tracking, delegate management, A/B day-split competitions and WCIF generation. What was taken from wca-live is the logic of the delegate workflow.
Rubik-Cube — Dev-tanay
The interactive 3D cube on the landing page was ported one-to-one from this project by Dev-tanay. The source was written against Three.js r95; the changed APIs were adapted while moving it to r125 and the code was converted to TypeScript. The class structure and method names stayed the same as the source. My addition was wiring the cube into Zkt Timer's timer: scramble generation, solve detection and timing. In this entry the skeleton of the code belongs to Dev-tanay.
pll_recognition_trainer — Roman Strakhov
The direct basis for the PLL Recognition Trainer module. The keyboard-driven PLL recognition practice, the two-sided recognition guide and the adaptive repetition logic came from Roman Strakhov's project. The source was written in Vue; the module was rewritten in React and TypeScript. During the rewrite the recognition guide was completed to cover all 73 cases, and an on-device history layer, a glossary view and a 13-step guided quest were added. The module is roughly four times the size of the source today.

Libraries Used

Core cubing libraries used directly in Zkt Timer's infrastructure.

cubing.js — Lucas Garron & the cubing.js team
The core library used for smart cube state tracking, WCA notation, and KPattern matching. Developed by Lucas Garron and the cubing.js contributors.
gan-web-bluetooth — afedotov
The library that provides Bluetooth connection management and gyroscope/motion logic for GAN smart cubes. The Smart Cube module is built on top of this library.
smartcube-web-bluetooth — Pau Oliva Fora (poliva)
The maintained successor of gan-web-bluetooth. Many fixes in our GAN, QiYi, MoYu, Giiker and GoCube drivers (reading several GAN moves from one Bluetooth packet, packet validation, gyroscope support, MAC candidates) come from this library, and its real cube recordings are used in our tests.
cubejs
A core cube solver library used in various analysis and solve features.

Open Source

Zkt Timer is built on top of hundreds of open-source packages, including React, Apollo, Prisma, and Three.js. The full list of dependencies can be found in the package.json file. A heartfelt thanks to everyone who has built and maintained these libraries over the years.

To the Community

To the WCA and the global speedcubing community. A remarkable worldwide community has been built around a single puzzle. The real reason Zkt Timer means anything is that it gets to be a part of this community.

Copyright Notices

Portions of this software reference code or concepts from the projects mentioned above. Each project retains its own original copyright. Zkt Timer's own architecture, systems, and features are subject to the following copyright:

This project is released under the GNU General Public License v3.0.