mojolearn

From the paper

Bitwise-Identical Machine Learning Across Metal, CUDA, and HIP

The same machine-learning workload can produce different bits on different GPUs, changing predictions, learned models and subsequent training updates. mojolearn is a GPU machine-learning library whose default identical mode produces bitwise-identical results across verified Apple, NVIDIA and AMD GPUs and x86-64 and Arm CPUs. Results agree bit for bit, not merely within a numerical tolerance. It supports training and inference for 57 machine-learning algorithms in 12 families, from decision trees to neural networks. Neural models trained in other frameworks can be served with identical outputs across vendors, and training workloads can be handed off between GPU vendors mid-run, or shared by GPUs of different vendors at once, while maintaining bitwise identity. Neural training and inference run in full FP32 floating-point arithmetic, without reducing the computation to integers. To my knowledge, I am the first to enable these capabilities.

One Mojo codebase implements these algorithms across Metal, CUDA and HIP under a shared numerical contract. Mojo compiles code for different GPUs, but maintaining that contract and implementing the algorithms is original work.

Where the compiler ends and the work begins

Mojo compiles one kernel source to each GPU's own machine code, Metal on Apple, PTX on NVIDIA, and AMDGPU on AMD. That solves portability. It does not make the results match. Each backend makes its own choices about rounding, instruction selection, and math libraries, and each GPU schedules threads in its own order. Floating point addition is not associative, so any of those choices can move a bit, and in a decision tree one moved bit can become a different split and a different model.

mojolearn sits in that seam. It implements the algorithms as GPU kernels, and it controls, kernel by kernel, everything the compiler and the hardware would otherwise decide differently per vendor. The project keeps a public ledger of 96 numbered pathways where a bit can move, each with what identical mode does about it. A few of them follow.

Handing training off between vendors

The strongest test of identity is to stop a training run on one vendor's GPU and finish it on another's. On September 6, 2026, a small byte level language model (two transformer blocks, 34,944 FP32 parameters, real text) was trained for 64 steps on NVIDIA, saved, and resumed on AMD, and the same in the other direction. Both continuations matched an uninterrupted run on the original device through step 128, checked across all parameters, gradients, optimizer moments, losses, and the checkpoint bytes. A day later the same 128 step run matched byte for byte on NVIDIA, AMD, and Apple.

Each step reached PyPI with a DOI that archives its evidence. The first release,0.1.0 on August 23, already trained tree and classical models to the same bits on every supported vendor, and0.3.0 on August 30 added a Linux wheel with NVIDIA and AMD GPU binaries. Neural network training (embedding, transformer forward and backward, cross entropy, and AdamW) was verified bitwise identical on Apple, NVIDIA, and AMD on September 3. Its code shipped in the 0.5.0 wheel on September 5, and0.6.0 on September 6 made training a public API, with that evidence in its archive. The handoff between vendors is archived in0.7.0 on September 9. Every version is listed under the project'sconcept DOI.

These are bounded results for the shapes and configurations recorded in the project's support matrix, and each claim is proven by stage level identity cards and sabotage tests rather than a final hash. Identity also has a cost. Identical mode gives up some speed to pin every order, which is why every family also ships a fast mode with no bit promise. This is a claim about where the code runs and what it returns, not about speed.