CLI tool
pvolok/dekit avatar
pvolok/dekit

dekit: a YAML-driven process manager that keeps tasks alive after the terminal closes

Run multiple commands in parallel

2,818 stars120 forksRustMIT

At a glance

What is it?
dekit is a Rust process manager by Pavel Volok, the next version of mprocs, that starts a project's servers, databases and workers from a dekit.yaml file. This review covers its task model, its log-based readiness check, its background runner and the gaps that the short README leaves for you to fill from the docs.
Who is it for?
dekit suits developers who start several local processes by hand and want them declared in one YAML file with dependency order and a terminal UI. It is a thin bet for anyone who needs the production features spelled out, because the README gives one two-task example and sends everything else to dekit.run/docs.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 6 days ago.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • pvolok/dekit2,818 ★ · +82
Star history
Repository2026-10-022026-11-21
pvolok/dekit2.7k2.8k

82 Stars in the last 50 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Tasks live in one dekit.yaml, and the example is only two tasks long

dekit reads a file called dekit.yaml at the project root. Under a top-level tasks key, each task gets a name and a command given as an array of arguments, not as a shell string. The README's whole example is a Postgres database and a Rust API:

yaml
tasks:
  db:
    cmd: ["postgres", "-D", ".data/db"]
    ready: { log: "ready to accept connections" }
  api:
    cmd: ["cargo", "run", "-p", "api"]
    deps: [db]
    autostart: true

Three other keys carry the behaviour. ready says when a task counts as up. deps lists the tasks that must be up first, so api waits for db. autostart marks a task to be started when you bring the project up; the db task has no autostart line, and it is started because api depends on it. Because cmd is an array, there is no shell parsing of pipes or redirects unless you spell out a shell as the first element yourself. The README shows no other keys, so environment variables, working directories and restart limits are questions for the docs site.

Readiness is a log line match, which ties your config to another program's output text

The ready field in the example is a log matcher: the db task is considered ready once the string ready to accept connections appears in its output. That is the exact message Postgres prints when it can take connections, so the api task is not launched against a database that is still starting.

The design is simple and works for any program that prints something when it is up. The consequence is that the match depends on text you do not control. If a database upgrade rewords that message, or a task logs nothing at the moment it becomes ready, the dependent task has nothing to wait for. A mismatch is a configuration bug that shows up as a dependent that never starts, and the README does not describe a timeout or an error for it.

The README also does not list other ready forms, such as a port check, so assume the log matcher is the only one you can rely on until you have read the configuration reference at dekit.run/docs. The repository includes a schemas directory, which suggests the config has a formal schema, but its contents are not shown in the README.

The runner outlives your terminal, so up and down are the real lifecycle

dekit separates starting the project from looking at it. Four commands cover the daily loop:

sh
dekit up
dekit ls
dekit attach
dekit down

dekit up starts the runner and every task marked autostart. dekit ls shows what is running. dekit attach opens the terminal UI. dekit down stops everything for the day, and the README notes that dekit up brings everything back.

The README states that tasks keep running after you close the terminal. That is a different model from a tool that owns the foreground: closing the window does not stop your database, and the terminal UI is something you attach to and leave rather than the process that holds your tasks. The cost is that a forgotten runner keeps consuming memory and ports until you run dekit down, and a stale task from yesterday can collide with today's. The README does not say where the runner keeps its state or how it finds the right runner when you have several projects open, so check the docs before running two projects side by side.

Four install routes install the same tool under different package names

The README gives four ways to get dekit. On macOS and Linux it is a shell script piped into sh, on Windows a PowerShell script piped into iex, and there are two package registry options:

sh
curl -fsSL https://dekit.run/install.sh | sh
powershell
irm https://dekit.run/install.ps1 | iex
sh
npm install -g @dekit/cli
sh
pip install dekit-cli

Note that the npm package is @dekit/cli and the PyPI package is dekit-cli, while the command you type is dekit. Searching a registry for dekit alone will not find the right package.

The script routes run code fetched from dekit.run at install time, so read the script first if your environment forbids that. The npm and pip routes suit teams that already pin tooling through a package manager, though the README does not say whether those packages download a prebuilt binary or compile Rust locally. The repository has a packaging directory, which is where that answer would be recorded.

dekit mprocs keeps old configs running, but moving to dekit.yaml is a separate job

dekit describes itself as the next version of mprocs, and the old README survives in the repository as README-mprocs.md. The compatibility path is one command:

sh
dekit mprocs

According to the README, dekit mprocs runs your mprocs.yaml with the same flags and keys. That means a team with an existing mprocs setup can switch binaries without rewriting anything on day one.

The catch is that this is a compatibility mode and not the new model. Dependencies, readiness checks and the background runner shown in the dekit.yaml example belong to the new file format, so an mprocs.yaml run through dekit mprocs should be expected to behave like mprocs and not like dekit up. Converting means following the Coming from mprocs page at dekit.run/docs/start/from-mprocs, which the README links and does not summarise. If you depend on exact mprocs behaviour in scripts, test the compatibility mode on your own file before replacing the old binary in CI or in onboarding instructions.

The CLI for agents and the built-in JavaScript are promised, not demonstrated

The feature list in the README makes two claims that the rest of the page never illustrates. One is a full CLI for humans and agents. The other is built-in JavaScript for writing scripts. There is no example of a script, no list of CLI subcommands beyond up, ls, attach, down, help and mprocs, and no description of machine-readable output.

The pointer the README gives is dekit help, which shows the docs in your terminal, so documentation travels with the binary. The repository also contains DOCS.md at its top level, a demo directory with its own dekit.yaml, and a CHANGELOG.md.

The consequence for a reader is that you can evaluate the process-management core from the README, but not the scripting layer. If you plan to drive dekit from an agent or write JavaScript tasks, treat that as unverified until you have run dekit help and read the demo configuration. Do not build a workflow on the assumption that the CLI exposes everything the terminal UI does until the docs say so for the specific command you need.

The release binary is tuned for size, and the version line is still 0.x

Cargo.toml shows how the release build is made. The profile strips symbols, sets opt-level to z with the comment optimize for binary size, enables link time optimization and uses a single codegen unit. The workspace has two members, src and helpers/print-key, and src is the default.

Those settings favour a small download over compile speed, since single-unit link time optimized builds are slow to produce. The README does not publish a binary size or a runtime comparison, so the intent is clear but the result is not quantified here.

On recency, the latest release entry is a canary build named Latest master, dated 2026-10-29, which is also the date of the last push. The tagged releases are v0.10.3 on 2026-10-25 and v0.10.2 on 2026-10-11. Two tags two weeks apart show regular movement, and the repository is not archived. The 0.x numbering means the configuration format and CLI can still change between tags, so pin a version in your install script if a team depends on it. The license is MIT.

Editorial conclusion

dekit suits developers who start several local processes by hand and want them declared in one YAML file with dependency order and a terminal UI. It is a thin bet for anyone who needs the production features spelled out, because the README gives one two-task example and sends everything else to dekit.run/docs. Before adopting it, run the quick start on your own database and application and confirm that your readiness log line actually matches.

Frequently asked questions

What is dekit?

dekit is a process manager written in Rust that runs a project's tasks, such as servers, databases and workers, in development and in production. Tasks are defined in a dekit.yaml file.

How do I install dekit?

On macOS and Linux run curl -fsSL https://dekit.run/install.sh | sh. You can also use npm install -g @dekit/cli or pip install dekit-cli.

Can dekit run my existing mprocs.yaml?

Yes, dekit mprocs runs your mprocs.yaml with the same flags and keys. dekit is described as the next version of mprocs.

Official sources

  1. Issues
  2. License: MIT
  3. pvolok/dekit on GitHub
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/pvolok-dekit.svg)](https://hysenlabs.com/projects/pvolok-dekit)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/pvolok-dekit.svg)](https://hysenlabs.com/projects/pvolok-dekit)

Was this useful?