Stop moving data. Start evolving it.

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

Get Started Try the Demo AI Inference Demo

$ pip install atomik-core

Redundancy Detection

Lean4 Formal Proofs

0 Gops/s

Gops/s Peak (FPGA)

0M+

M ops/s (Python)

How It Works

Four operations. Everything else is built on top.

LOAD

Set reference state, clear accumulator

O(1)

ACCUM

XOR delta into accumulator

O(1)

READ

Reconstruct state: ref ⊕ acc

O(1)

SWAP

Atomic snapshot + new epoch

O(1)

Why ATOMiK

Four operations. Zero dependencies. Formally proven correctness.

LATENCY

Deterministic Latency

Every operation is constant-time. No data-dependent branching, no variable-length scans. Timing side channels eliminated by design.

HARDWARE

Hardware Acceleration

Same API from Python to FPGA. 5M ops/s in Python, 500M in C, 69.7B on Xilinx Zynq with 512 parallel banks. No code changes.

SCALING

Parallel Scaling

Sub-linear LUT growth: 3.7x area for 16x throughput. XOR commutativity means lock-free parallel accumulation across banks.

BANDWIDTH

Delta-Driven Updates

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

SECURITY

Timing-Safe

No speculative execution, no cache coherency attacks, no data-dependent timing. Security is architectural, not bolted on.

CORRECTNESS

Formally Verified

92 Lean4 theorems prove commutativity, associativity, self-inverse, and identity. Not tested -- proven. Every property holds for all inputs.

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.

✓ Zero dependencies✓ Python 3.9+✓ Fully typed✓ C99 header available

Python

from atomik_core import AtomikContext

ctx = AtomikContext()
ctx.load(1000)           # Set initial value
ctx.accum(50)            # Apply delta (+50)
print(ctx.read())        # 1018 (1000 XOR 50)

ctx.accum(50)            # Apply same delta again
print(ctx.read())        # 1000 (self-inverse: undone!)

# Merge two independent accumulators.
# Order doesn't matter (commutativity).
a = AtomikContext()
b = AtomikContext()
a.load(1000); b.load(1000)
a.accum(50); b.accum(100)
a.merge(b)  # a now has both deltas