Nimbus is a single-binary backend for apps and AI agents, drop-in compatible with Convex, Firestore, MongoDB, and DynamoDB.
$ brew install nimbus/tap/nimbus$ nimbus init convex my-app && cd my-app$ nimbus devYOUR CODE
Your Convex, Firestore, MongoDB, or DynamoDB code does not change. Point it at one Rust binary on your machine.
import { ConvexHttpClient } from "convex/browser";import { api } from "./convex/_generated/api"; // http://localhost:3210/convex/democonst client = new ConvexHttpClient(process.env.NEXT_PUBLIC_CONVEX_URL); await client.action(api.messages.send, { body: "hello" });CLIENT PROTOCOLS
Each SDK keeps its own wire format and port. One process on one host answers all of them.
# written by nimbus devNIMBUS_DEPLOYMENT=http://localhost:3210/convex/demoNIMBUS_MONGODB_URL=mongodb://127.0.0.1:27017/…NIMBUS_DYNAMODB_ENDPOINT=http://127.0.0.1:8000# you set the variable your Convex client reads:NEXT_PUBLIC_CONVEX_URL=http://localhost:3210/convex/demoBACKEND ADAPTERS
Each adapter turns its protocol into engine operations and passes an authenticated identity, not a raw token. Every SDK meets the same rules and the same database.
export const send = action({ args: { body: v.string() }, handler: async (ctx, { body }) => { await ctx.runMutation(internal.messages.write, { body }); // chapter 05 await nimbus.sessions.open({ // chapter 13 target: { service: { name: "agent" } }, channels: ["stdio"], }); },});FUNCTIONS
The handler runs on V8 inside the binary. Queries and mutations reach the database with no network hop. Only actions reach the network.
import { Nimbus } from "@nimbus/nimbus"; // the SDK is one more HTTP client, so only an action may hold itconst nimbus = new Nimbus({ endpoint: process.env.NIMBUS_URL, tenantId: "demo", token: process.env.NIMBUS_TOKEN,});NODE
Add "use node" to an action to run it on Node 22, 24, or 26 with npm packages. Native addons and subprocesses need a sandbox.
"use node";import OpenAI from "openai";import { action } from "./_generated/server";import { v } from "convex/values"; const openai = new OpenAI(); // fetch, inside the tenant's egress policyWRITES
A mutation and a driver insertOne take the same path. One transaction writes the document, its indexes, and the commit log. Nimbus acknowledges only durable writes.
export const write = internalMutation({ args: { body: v.string() }, handler: async (ctx, args) => { await ctx.db.insert("messages", args); },});REALTIME
A MongoDB write updates a live Convex query the moment it commits. There is no polling and no pub/sub service to run.
const messages = useQuery(api.messages.list, {}); // re-renders the moment the commit landsreturn messages?.map((m) => <li key={m._id}>{m.body}</li>);DATABASE
SQLite runs inside the process with zero setup. Point one flag at Postgres, MySQL, or libSQL when you already run one. Every API works on every backend.
$ nimbus start # SQLite in ./data$ nimbus start --tenant-provider postgres \ --postgres-url postgresql://db:5432/nimbus$ nimbus kv # RESP on 127.0.0.1:6380FILES
Each tenant has one encrypted, content-addressed store. Uploads, the S3 endpoint, the function filesystem, and sandbox volumes read the same bytes.
services: agent: image: python:3.12 volumes: - scratch:/work # a named tenant volumevolumes: scratch: {} # no host bind mounts · S3 API on :9000SANDBOX
Compose gives each agent an OCI image, a microVM or container, and a volume at /work. No daemon runs. The sandbox has no path back to the engine.
services: agent: image: docker.io/library/python:3.12 # pulled and unpacked, no daemon command: ["python", "agent.py"] volumes: ["scratch:/work"] # the volume from chapter 08 deploy: { resources: { limits: { cpus: "1", memory: 512M } } } x-nimbus: { backend: krun, egress: { allow: [] } } # chapter 10EGRESS
The egress proxy denies every sandbox request by default. An allow rule names one protocol, one host, one port, and its paths, with no wildcards.
services: agent: x-nimbus: egress: allow: - { name: stripe-api, protocol: https, host: api.stripe.com, port: 443, methods: [POST], path_prefixes: [/v1/] }SERVICES
A service is a name that other code depends on. A sandbox runs it. Replace the sandbox and the name still resolves.
const agent = await nimbus.services.get({ name: "agent" }); // every write fences on the generation it readawait nimbus.services.restart({ name: "agent", sourceGeneration: agent.metadata.generation,});COMPOSE
A compose file names each service. Each one runs in its own microVM or container next to the engine. One service runs one sandbox today. Replicas are on the roadmap.
services: web: image: ghcr.io/acme/web:1.4 ports: ["127.0.0.1:3000:8080"] # host listener → guest port agent: image: ghcr.io/acme/agent:1.4 command: ["python", "agent.py"] # a microVM by default worker: image: ghcr.io/acme/worker:1.4 x-nimbus: { backend: crun } # a container insteadSESSIONS
Plain service use needs no session. Open one for stdio, file exchange, or browser control. Nimbus authorizes the lease at open, and it expires at its TTL.
const shell = await nimbus.sessions.open({ target: { service: { name: "agent" } }, channels: ["stdio"],});console.log(shell.spec.targetSnapshot.service);// { name: "agent", generation: 3, backend: "sandbox" }console.log(shell.spec.expiresAt); // 15 min outSINGLE PROCESS
Network, compute, storage, and agents ship in one Rust binary with one trust model. There is no sidecar and no queue to run.
$ lsnimbus # one file $ ./nimbus start # :8080 · network, compute, storageTENANTS
Each tenant has its own database, file store, key, and budget. Nimbus admits a request once. No API can express a cross-tenant read.
$ curl -s -X POST http://localhost:8080/api/tenants \ -H "Authorization: Bearer $NIMBUS_TOKEN" \ -d '{"id": "acme"}'{"id": "acme"} # own SQLite file · own blob store + key$ nimbus start --runtime-max-active-per-tenant 8DEPLOYMENT
Install on any Linux host and run it as a service. Deploy from a laptop with a dry run first.
$ curl -fsSL https://github.com/nimbus/nimbus/…/install.sh | sh# write /etc/systemd/system/nimbus.service, then$ sudo systemctl enable --now nimbus $ nimbus deploy https://nimbus.example.com --dry-runCLUSTERPlanned
Planned cluster mode joins hosts over a QUIC mesh. Each node is an Ed25519 key, not an IP address. A host joins with a token as a learner, and each tenant gets one owner node. None of this ships today.
# planned · not in any release yet$ nimbus cluster init # the first host$ nimbus cluster join-token create # on a member$ nimbus cluster join <token> # on the new host · a learner first$ nimbus cluster promote <id> # then a voter$ nimbus cluster members # nodes by key · role · tenant ownerOPERATORPlanned
The planned operator plane is the same mesh. The CLI dials any node by key, through NAT, with an operator key that has admin and port-forward scopes only. It is never a voter.
# planned · not in any release yet$ nimbus cluster members # from a laptop · by key$ nimbus cluster status$ nimbus forward … # a local TCP port to a port on one node# an agent takes the same path with a scoped keyLAPTOP
Install the binary and point the app at localhost:3210. Nimbus is in beta. APIs can break between releases. Do not use it in production yet.
$ brew install nimbus/tap/nimbus$ nimbus init convex my-app && cd my-app$ nimbus dev