The same embeddings, indexed on macOS and Windows, would sometimes produce slightly different nearest-neighbor results. Nothing dramatic but enough to break tests and make snapshots non-reproducible.
At first I assumed it was my code. Then I realized the problem wasn’t my logic at all it was "floating-point math".
Different CPUs, different compilers, FMA instructions, and subtle differences in IEEE behavior meant that “the same” computation wasn’t actually the same everywhere.
That sent me down a rabbit hole.
The idea:
Instead of trying to fight floating-point nondeterminism, I asked a simpler question:
What if the core of a vector system never used floats at all?
So I built a small kernel in Rust that uses fixed-point arithmetic (Q16.16) for all vector math. No floats in the core. No randomness. No architecture-dependent behavior.
Same inputs → same state → same snapshot → same search results. Always.
What the kernel does
Fixed-point vectors (Q16.16)
Deterministic insert, search, and replay
Snapshot + restore with bit-identical output
No RNG anywhere
No dependency on CPU floating-point behavior
The kernel is no_std friendly and is meant to be embedded under different layers (node server, Python client, edge devices).
Indexes and embeddings live outside the kernel. The kernel is just a deterministic memory engine.
Why this matters
Most vector databases optimize for throughput and scale. That’s fine.
But there’s a whole class of problems where reproducibility, auditability, and replayability matter more:
Edge devices (robots, drones)
Offline or intermittently connected systems
Long-running agents that need stable memory
Systems where “almost the same” isn’t good enough
This project is my attempt to explore that design space.
The code is early and opinionated, but the determinism is real.
Happy to hear feedback, skepticism, or pointers to similar work I should study.
No comments yet.
