State management,
reconstructed.

ATOMiK replaces snapshots, event replay, and full-state replication with a 4-operation algebra that reduces bandwidth by 99% and reconstructs state in O(1). Formally proven. Hardware-accelerated.

Get Started View on GitHub
$ pip install atomik-core
99.9%
Bandwidth Reduction
92
Lean4 Formal Proofs
333,333x
Memory Savings (Rollback)
1,291x
Faster Change Detection

Why ATOMiK

Four operations. Zero dependencies. Formally proven correctness.

BANDWIDTH

95-99.9% Less Traffic

Send 8-byte deltas instead of full state copies. A 64KB state with 10,000 updates: ATOMiK sends 80KB total. Full replication sends 655MB.

CONVERGENCE

No Consensus Protocol

XOR commutativity means deltas can arrive in any order. No Raft, no Paxos, no leader election. All nodes converge to the same state.

MEMORY

O(1) State Tracking

24 bytes per context regardless of history length. 1 million checkpoints costs 24 bytes, not 8MB of snapshots.

CORRECTNESS

92 Lean4 Proofs

Every algebraic property is formally proven: commutativity, associativity, self-inverse, identity. Not tested — proven.

DETECTION

1,291x Faster Changes

Incremental fingerprinting detects changes in O(1) per field update. SHA-256 rescans the entire buffer every time.

UPGRADE PATH

Software → Hardware

Same API, same algebra. When you need more: C library (50-100x), FPGA (1,000x), ASIC (10,000x). No code changes.

4 operations. That's it.

LOAD sets the reference. ACCUM XORs a delta. READ reconstructs the state. SWAP starts a new epoch. Everything else — rollback, merge, fingerprinting — is built on these four.

Works on Python 3.9+, any CPU. Zero dependencies.
C header-only library also available.

from atomik_core import AtomikContext ctx = AtomikContext() ctx.load(0xDEADBEEF) ctx.accum(0x000000FF) # XOR delta state = ctx.read() # 0xDEADBE10 # Undo? Just re-apply the same delta. ctx.rollback(0x000000FF) assert ctx.read() == 0xDEADBEEF # Merge two independent accumulators. # Order doesn't matter (commutativity). a = AtomikContext() b = AtomikContext() a.load(0xCAFE); b.load(0xCAFE) a.accum(0x11); b.accum(0x22) a.merge(b) # a now has both deltas

Benchmarks

Measured on x86 (Python 3.12). C library is 50-100x faster. FPGA hardware is 1,000x faster.

Metric ATOMiK Conventional Advantage
Network bandwidth (1KB state, 10K updates) 80 KB 10.2 MB (full copies) 128x reduction
Network bandwidth (64KB state, 10K updates) 80 KB 655 MB (full copies) 8,192x reduction
Rollback memory (10K checkpoints) 24 bytes 80 KB (snapshot stack) 3,333x less memory
Rollback memory (1M checkpoints) 24 bytes 8 MB (snapshot stack) 333,333x less memory
Change detection (1MB buffer, incremental) 6 ms 7,864 ms (SHA-256) 1,291x faster
Multi-node convergence (8 nodes) No ordering needed Sort 8,000 events 1.7x + no consensus

Pricing

Start free. Scale when ready.

Community

Free
  • Full atomik-core library
  • Python + C implementations
  • 4-operation API
  • AtomikTable, DeltaStream, Fingerprint
  • Apache 2.0 (evaluation)
  • Community support
Get Started

Professional

$99/mo per seat
  • Everything in Community
  • Production license
  • Priority email support (48hr SLA)
  • Benchmarking suite
  • Integration guides
  • Rust + JavaScript libraries
Contact Sales

Enterprise

$499/mo per seat
  • Everything in Professional
  • 4-hour response SLA
  • Dedicated support channel
  • Custom integration consulting
  • Formal verification certificate
  • Hardware acceleration path
Contact Sales

For Investors

ATOMiK is a fundamentally new approach to state management — proven mathematically, validated in hardware, ready for market.

92
Lean4 Formal Proofs
417+
Tests (SW + HW)
3
FPGA Platforms Validated
69.7
Gops/s Peak (FPGA)
$50B
Serviceable Market

Patent pending. Software + hardware IP licensing model. ARM-comparable business model with 85-95% gross margins.

Contact Founder Technical Deep Dive