dozeGitHubGet doze
Free and open source · Apache-2.0

Local development
that just works.

Your whole stack from one file, the same on every laptop, started from the app, and asleep the moment you stop. No VM humming all evening.

Get doze
$ brew install --cask doze-dev/tap/doze

Apache-2.0 · no account · no telemetry · macOS on Apple silicon, and Linux

The doze app on a small demo stack: switch a database off and the services that need it follow it to sleep.

Your first stack, in the app

Drop a folder. Flip a switch.

doze is an app first. Three steps from a fresh install to a running stack, without opening a terminal.

  1. 1

    Open doze

    The Library is home for every stack on this Mac. On a fresh one it shows three steps and two ways in, and the Machine line offers the one-password setup that gives your services names.

    Drawn from the app's own screen · capture pending
  2. 2

    Drop your repo folder on it

    doze reads the folder’s go.mod and Go imports, package.json, compose files, a Makefile and the variables the code asks for, like DATABASE_URL, and lists what it found and where. Here, Larder’s gateway, before it had a doze.hcl. Nothing starts. Set it up from this repo writes doze.hcl, with the reason above each block.

    Drawn from the app's own screen · capture pending
  3. 3

    Flip Up

    One switch brings the stack up, each service after what it needs; what nobody calls goes to sleep. Next time Up starts what you had up last time. The menu beside it offers Start everything or Choose what starts…: tick the apps you’ll work on, and what they need comes too.

    Drawn from the app's own screen · capture pending

Prefer the terminal? doze init && doze up in the folder does the same, and the app shows the stack either way.

Sound familiar?

Nobody chose this. It grew.

01 / 07 npm run dev · uv run api · make worker · ./scripts/start-queue.sh

Which terminal was that?

Seven things, seven ways to start them, each in a tab you have to remember.

With dozeOne doze.hcl says how each one starts. One switch starts them all.

02 / 07 Error: port 5432 is already allocated

Last week’s project is still holding 5432.

And the ports you keep in your head: was the gateway 3000, 3001 or 8080?

With dozeEvery service gets a name, like gateway.larder.doze in Larder, our made-up example. Two projects on 5432, no clash.

03 / 07 a VM holding every database · used or not

The fan, all evening.

A virtual machine keeps every database awake from login to lid, whether you touched them or not.

With dozeNative processes that sleep when nothing calls them. Asleep means no process.

04 / 07 agent: “It looks like the database might not be running?”

Your AI read every file. It still can’t see your machine.

Quick, confident and guessing: which stack is up, what’s on which port, what you started yesterday.

With dozeYour agent asks doze instead. doze status --json is the same answer, for machines.

05 / 07 SETUP.md · Getting started (2023)

Back after three months. The setup doc rotted.

Two services you’ve never seen, one renamed, and a step that only worked on someone’s old laptop.

With dozeThe file that runs the stack is the setup doc, so it can’t drift. Clone, doze up.

06 / 07 23 containers · still up · nobody calling

Closing the lid with 23 containers still up.

Tomorrow they’ll still be there. So will the ones from the project before.

With dozeWhatever nobody calls falls asleep by itself, data kept. Close the lid: nothing’s still running.

07 / 07 #dev-env · “dev box is down, platform team looking into it, no ETA”

Local development didn’t get fixed. It got moved.

Onto remote dev boxes run by a platform team. Debuggers that won’t attach through the tunnel, port-forwards, logs in another tool. When the dev box is down, nobody writes code. You needed a platform team just to write code.

With dozeIt all runs on your laptop again, natively. A breakpoint just hits, and nobody’s pager is involved.

How it got moved, and back: the long way round

Your laptop is a beast

The most powerful computer you’ve ever owned is on your desk.

And somehow your dev environment runs in someone else’s cluster, behind a tunnel, a ticket and a platform team. You don’t need Kubernetes to run your own code. You need a stack that runs where you are, and goes to sleep when you stop.

  • Your machine. Every service a native process on the laptop you already own.
  • Your debugger. Attach to a local process. The breakpoint just hits.
  • Your schedule. Nobody else’s outage stops you working.
Take the long way round

Free and open source

All of it. Apache-2.0.

Not a free tier of something paid, and not an open core with the good parts kept back. The app, the CLI, doze AWS, doze Kafka, every module and the registry they install from are on GitHub under Apache-2.0. Read it, build it, fork it, keep it.

Repeatable, on every laptop. doze.hcl says what runs. doze.lock pins every module to a version and a sha256 for each platform, checked against the registry's signature. Commit both, and a teammate's first doze up runs the stack you run.

$ git clone https://github.com/doze-dev/doze && cd doze && make build

doze, the app

Your stack, where you can see it.

Every service with a switch, a name and its memory. What’s awake, what’s dozing, what’s asleep, and who woke whom. Quit the app and your stacks keep running.

One stack, three ways. Tiles to flip, a list to scan, a map that draws who needs whom.
A switch per service. Flip it: asleep, waking, awake.
⌘K. A verb and a name. Type “wake”, a name, return.
Needs you. What’s broken or worth doing, each with its fix one click away.

And everything is a command too.

The app and the CLI drive the same stack. Scripts, CI and your agent get the same answers you see.

Take the tour of the app 
$ doze add postgres     # writes the block into doze.hcl
$ doze up               # the whole stack, asleep until called
$ doze status --json    # the same answer, for machines

Your own domain

Your own domain, over https. One line.

Sign-in providers won’t send you back to localhost subdomains or .test. Cookies, CORS and HSTS care which host they’re on. So put your real dev domain in doze.hcl, run doze trust once, and https://dev.acme.com is your laptop, padlock and every tenant subdomain included. No proxy to configure, no hosts file, no port in the URL.

How your own domain works 
app "web" {
  run     = "pnpm dev"
  port    = 3000
  domains = ["dev.acme.com", "*.dev.acme.com"]
}

$ doze trust   # once: one password prompt
  • https://dev.acme.com
  • https://larder.dev.acme.com
  • https://corner.dev.acme.com

The doze family

Three products. One bedtime.

Each one wakes when called and sleeps when you stop. Use one, or all three together.

doze

Wakes your stack when you start. Sleeps it when you stop.

The doze app's map of a stack: which service needs which, and who is awake

Part of the doze family. Works alone.

Meet doze Docs

Numbers, with the method

Rest you can measure.

Every figure says where it came from. The ones we haven’t measured yet say that instead. Asleep means no process: pgrep finds nothing.

$ make bench

In a clone of doze-dev/doze. It boots real engines on a fixture stack and measures idle memory and wake time.

The doze daemon, at rest
27.1 MB
Measured on the maintainer’s Mac · test/bench TestLogStoreMemory
After a service prints 100,000 log lines
+1.3 MB
Same test: what a service prints doesn’t pile up in the daemon.
Idle daemon, every service asleep, macOS
≤34 MB
A budget, enforced in CI on every pull request · test/bench/budget.json
Median wake of a sleeping module
≤250 ms
Each module, median of 5 wakes. A budget, enforced in CI on macOS and Linux · test/bench/budget.json
Your stack asleep, next to the same engines in a VM
[to measure]
We’ll publish it with the machine, the versions, the date and the script. Until then, make bench on yours.

The registry

Everything your stack uses. One line each.

doze add writes the block. It sleeps until something calls it. No Dockerfile, no compose YAML, no setup doc.

PostgreSQLregistry
Postgres 14–18, roles and schemas declared.doze add postgres
MariaDBregistry
MariaDB 11, MySQL-compatible.doze add mariadb
FerretDBregistry
MongoDB-compatible, on Postgres.doze add ferret
MongoDBbring your own
The real mongod, from your install.doze add mongo
ClickHousebring your own
Columnar analytics.doze add clickhouse
Valkeyregistry
Redis-compatible cache, 8 and 9.doze add valkey
Kvrocksregistry
Redis API on disk: durable, low memory.doze add kvrocks
Memcachedbring your own
The classic cache.doze add memcached
doze Kafkaregistry
Kafka without the JVM, schema registry built in.doze add kafka
Temporalregistry
Durable workflows, the dev server.doze add temporal
NATSbring your own
Messaging and streams.doze add nats
RabbitMQbring your own
AMQP broker.doze add rabbitmq
Meilisearchbring your own
Instant search.doze add meilisearch
OpenSearchbring your own
Search and analytics.doze add opensearch
Mailpitbring your own
Catches every email your app sends.doze add mailpit
doze AWSregistry
17 AWS services and a console.doze add aws
MinIObring your own
S3-compatible object storage.doze add minio
pgvectorextension · coming
Vector search for embeddings.extensions = ["vector"]
PostGISextension · coming
Geographic types and indexes.extensions = ["postgis"]
TimescaleDBextension · coming
Hypertables and time_bucket.extensions = ["timescaledb"]
pg_cronextension · coming
Scheduled jobs, preloaded for you.extensions = ["pg_cron"]
pgmqextension · coming
Message queues in Postgres tables.extensions = ["pgmq"]
pg_searchextension · coming
BM25 full-text search (ParadeDB).extensions = ["pg_search"]
pg_duckdbextension · coming
DuckDB analytics inside Postgres.extensions = ["pg_duckdb"]

Registry modules are signed and pinned in doze.lock; anything else, doze add runs from your install, a container or a download. All of it sleeps and wakes.

Browse the registry

Close the lid

Your laptop deserves an evening too.

Read On rest, why doze is built this way
  • Open sourceApache-2.0, all of it. Read it, fork it, keep it.
  • No accountNothing to sign up for, nothing to sign in to.
  • No telemetrydoze sends nothing home. Neither does this website.
  • Your diskYour data stays on your machine, kept while it sleeps.

Put your stack to bed.

Everything wakes when called. Everything sleeps when you’re done.

Get doze
$ brew install --cask doze-dev/tap/doze