v0.10.0 · 34 MCP tools · 699 conformance tests

DynamoDB, without
the baggage

A local DynamoDB emulator backed by SQLite. Millisecond startup, a 3 MB download, no Docker and no JVM. Just run it.

Get started View on GitHub

$ brew install nubo-db/tap/dynoxide

What's new in v0.10.0 29 May 2026

A StorageBackend trait in the new dynoxide::storage_backend module, decoupling the data layer from a specific SQLite binding.
A BackendError enum returned by the trait surface, with an explicit rusqlite::Error -> BackendError mapping for the common failure modes (NotADatabase, locked / busy, constraint violations, I/O failures), plus an Unsupported { capability } variant for a capability a backend cannot serve (the wasm preview uses it for TTL).
A Clock capability on Storage so the trait surface does not assume std::time.

See full changelog →

~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

A conformance suite runs the same tests against Dynoxide and real AWS, scored the same way for every emulator. We publish the full results.

MCP

Agent-ready

Built-in MCP server with 34 tools. Your coding agent can create tables, query data, and manage snapshots.

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.

dynoxide in CI

Install curl + tar · ~1s

Load snapshot dynoxide import · ~3s

Run 50 tests isolated instances · ~0.8s

Total ~5s

DynamoDB Local in CI

Pull Docker image 225 MB (471 MB on disk) · ~30s

JVM cold start wait for ready · ~4s

Run 50 tests shared instance · ~3s

Total ~37s

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

@dynoxide on npm

Terminal

Preview · new in v0.10.0

Now it runs in
the browser

The same engine, compiled to WebAssembly. No server, no install - just a DynamoDB-compatible database running on the page, against wa-sqlite over a wasm-bindgen bridge. 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, about 1.2 MB, drops onto ordinary static hosting.

Create-table, put, get, delete, query and scan all work today, over base tables and both index types. TTL, streams and transactions don't yet. The wasm build isn't run against the conformance suite - this is a preview only.

Read the browser guide → See the harness on GitHub

your-app.example

// running in your browser, persisted to OPFS

await db.createTable("Users", { pk: "id" })

→ table created

await db.putItem("Users", { id: "1", name: "Ada" })

→ ok

await db.query("Users", "id = 1")

→ [{ id: "1", name: "Ada" }]

// reload the page - it's still there

Tested against the real thing

699 conformance tests, run against real DynamoDB on AWS. Every emulator gets the same suite, scored the same way.

See the live results at paritysuite.org →

Dynoxide

100.0%

ExtendDB

93.8%

Floci

92.6%

LocalStack

88.3%

DynamoDB Local

87.0%

Ministack

87.0%

Dynalite

83.1%

The score is correctness over the operations each emulator implements, checked against real DynamoDB. It only tests what it tests - a behaviour with no test is a blind spot, not a pass. How the scoring works.

Docker required

JVM required

Embeddable

Yes

MCP server

Yes

Conformance suite: nubo-db/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?

An independent conformance suite runs hundreds of behavioural tests against real DynamoDB on AWS, then against every emulator the same way. Dynoxide is built to match real DynamoDB as closely as possible, and the published results let you compare it 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 independent 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.