v0.13.0 · 34 MCP tools · 1054 conformance tests
A DynamoDB-compatible engine backed by SQLite. Run it as a local server, in CI, embedded in your Rust or iOS app, or in the browser via WebAssembly. ~2ms startup, ~3 MB, no Docker or JVM.
brew install nubo-db/tap/dynoxide
Coming soon
on main, not yet released
BatchExecuteStatement accepts ReturnConsumedCapacity and reports capacity, which it previously had no way to do at all.
Why Dynoxide
~2ms
Cold startup
DynamoDB Local takes ~3,200ms on CI. Dynoxide is ready before your SDK has even connected.
~3 MB
Download size
No Docker image, no JVM. Just a native binary that uses ~8 MB of RAM at idle.
Tested
Against real DynamoDB
Parity Suite, a DynamoDB conformance suite, runs the same tests against Dynoxide and real AWS, scored the same way for every emulator. The full conformance results are public.
MCP
Agent-ready
Built-in MCP server with 34 tools. Your coding agent can create tables, query data, and manage snapshots.
One engine, many ways to run it
The same DynamoDB-compatible engine, whether you need a local server, an in-process library, a browser build, or an MCP server for your coding agent.
A native binary that serves the DynamoDB wire protocol on a port. A drop-in for DynamoDB Local: point any AWS SDK at the endpoint.
npx dynoxide
A GitHub Action (or the Docker image) that brings Dynoxide up in a pipeline. A ~3 MB download with no JVM warmup, so the database stops being the slow part of the job.
nubo-db/dynoxide/action@v0.13.0
A Rust crate that runs the engine in-process, with no server and no network. Single-digit microsecond operations, and it runs on platforms DynamoDB Local can't, including iOS.
cargo add dynoxide-rs
A built-in Model Context Protocol server, over stdio or HTTP. A coding agent can create tables, query data, and manage snapshots without leaving the conversation.
dynoxide mcp
Browser (WebAssembly) Preview
Run the engine in the tab via WebAssembly, persisted to OPFS. Drops onto ordinary static hosting, with no special server headers.
npm install @dynoxide/wasm-engine
Dual-licensed under MIT or Apache-2.0, so you can embed it in your own application and redistribute it.
Preview
Now it runs in
the browser
The same engine, compiled to WebAssembly and published on npm. No server, no install - just a DynamoDB-compatible database running on the page, on the official SQLite wasm build. It persists to OPFS, so a table you create survives a reload. Nothing leaves the page.
It runs in a Web Worker and needs no special server headers - no cross-origin isolation, no COOP/COEP - so the whole thing, around 915 KB gzipped, drops onto ordinary static hosting.
Create-table, put, get, delete, query, scan and PartiQL all work today, over base tables and both index types. It's a preview covering a subset of the native engine - streams, TTL, tags and write transactions aren't wired yet - and it reports the exact set it supports at boot.
Learn DynamoDB by operating it →
accesspatterns.dev runs this same engine in your browser - guided lessons, real access-pattern models, and a freeform playground, with the cost of every operation shown as you go.
Local DynamoDB emulator startup, visualised
Time from zero to accepting requests. Dynoxide's bar is so small you might miss it.
Dynoxide ~2ms
DynamoDB Local ~3,200ms
LocalStack ~8,600ms
Measured on GitHub Actions runners. Local development on Apple Silicon is even faster.
Built for CI,
not just your laptop
A fast emulator doesn't just save you time locally - it changes what's practical in your pipeline. When startup takes milliseconds instead of seconds, you can spin up a fresh database per test. No shared state. No cleanup. No flaky tests.
Pair that with dynoxide import and you're running integration tests against real data shapes - anonymised, compressed, loaded in seconds from a snapshot of production.
A ~3 MB download with no dependencies means no Docker layer caching, no JVM warmup eating into your build minutes, and no "works on my machine" divergence between local and CI.
Already built around amazon/dynamodb-local in a container? Swap the image. The official ghcr.io/nubo-db/dynoxide is a ~5 MB drop-in - same API, where you'd otherwise pull 225 MB. You don't need Docker, but if you want it, it's no longer the slow part.
Drop-in replacement for dynalite
If you're using dynalite for local DynamoDB during development, switching is one line. You don't need to know or care that it's Rust under the hood.
Before
$ npx dynalite
No transactions or streams
After
$ npx dynoxide
Transactions, streams · fastest local emulator
The npm package ships platform-specific binaries - the same approach used by esbuild, Biome, and Turbo. A thin wrapper pulls in the right binary for your OS at install time. No compilation, no native dependencies, no surprises.
Your existing dev setup stays the same. Same SDK calls, same endpoint, same table definitions. The only difference is the name in your package.json - and the fact that your local DynamoDB starts in milliseconds instead of seconds.
$ npm install --save-dev dynoxide
Tested against the real thing
1054 conformance tests, run against real DynamoDB on AWS to fix the expected answer, then against every emulator the same way. Each target comes out with two figures, and they are never added together: the share of the suite it answers differently, and the share it implements at all.
| Grade | Target | Divergence | Coverage |
|---|---|---|---|
| A | Dynoxide | 0.9% | 94.7% |
| B | extenddb sqlite coverage holds this at B | 1.8% | 87.8% |
| B | ExtendDB coverage holds this at B | 1.9% | 87.8% |
| B | Ministack | 11.9% | 96.0% |
| C | Dynalite coverage holds this at C | 12.8% | 77.0% |
| C | LocalStack coverage holds this at C | 14.8% | 95.3% |
| C | DynamoDB Local | 15.1% | 94.0% |
| C | Floci | 21.0% | 95.2% |
A skip and a fail are not the same problem. An operation an emulator declines is something you find in minutes and plan around; one it gets quietly wrong is something you find in production. Divergence sets the letter and coverage can only lower it. The suite also only tests what it tests, so a behaviour with no test is a blind spot rather than a pass. How the grading works.
Docker required
No
JVM required
No
Embeddable
Yes
MCP server
Yes
Conformance suite: paritysuite/dynamodb-conformance
Frequently asked questions
How fast does Dynoxide start?
Dynoxide starts in ~2ms on GitHub Actions CI runners (HTTP mode). That's over 1,600x faster than DynamoDB Local (~3,200ms) and 4,300x faster than LocalStack (~8,600ms). Numbers are medians across the last several CI runs to smooth out shared-runner variance.
Does Dynoxide require Docker?
No. Dynoxide is a single native binary - no Docker, no JVM, no dependencies. Just download and run. The entire binary is ~3 MB.
Is Dynoxide compatible with DynamoDB?
Parity Suite, a DynamoDB conformance suite maintained by Dynoxide's author, runs hundreds of behavioural tests against real DynamoDB on AWS, then against every emulator the same way. Every engine is scored identically against live AWS, and the results and test code are public, so you can compare Dynoxide against every other local emulator yourself.
Can I use Dynoxide as a local DynamoDB emulator?
Yes. Dynoxide is a drop-in replacement for DynamoDB Local. It works with any AWS SDK - just point your endpoint to localhost:8000.
How does Dynoxide compare to DynamoDB Local?
Dynoxide starts around 1,600x faster (~2ms vs ~3,200ms), is a ~3 MB download rather than a 225 MB Docker image, and needs no Docker or JVM. Both are measured by the same conformance suite, so you can compare how closely each matches real DynamoDB.
Try it in ten seconds
The fastest DynamoDB Local alternative. One install, one command, works with any DynamoDB SDK.
brew install nubo-db/tap/dynoxide