Your dev stack, supervised.

Multi-service dev environments that just work. Across worktrees, without Docker.

Website · Quick Start · Architecture Decisions

---

devme spawns, monitors, restarts, and tails logs from every service in your project. Backend, frontend, database, proxy, whatever you've got. Declare them in a single devme.toml and each git worktree gets its own coexisting stack with non-colliding ports.

Why devme?

Running a modern project means juggling 3-8 services. Open five terminals, remember the right startup order, hope nothing grabs the wrong port. Now multiply that by worktrees.

devme fixes this. One command, devme up, starts everything in dependency order with health checks. Each worktree gets its own port slot, so main and feature-branch run side by side without collisions. There's a TUI dashboard for real-time status and logs. Every command supports --json and semantic exit codes, so AI agents can drive it too. No Docker required.

Setup steps have trust levels (auto, prompt, manual) so dependencies get provisioned safely.

Quick Start

cd my-project
devme init          # generates devme.toml from your project
devme up            # starts everything

Configuration

# devme.toml
[services.backend]
command = "cargo watch -x run"
port = 8080
health = "http://localhost:{{port}}/health"

[services.frontend]
command = "npm run dev"
port = 5173
depends_on = ["backend"]

[services.db]
command = "docker compose up postgres"
port = 5432
health = { command = "pg_isready -p {{port}}" }

Ports automatically offset per worktree slot. Slot 0 keeps defaults, slot 1 gets +10, and so on.

How It Compares

	devme	docker-compose	process-compose	Procfile (foreman)
Worktree-aware ports	✅	❌	❌	❌
Dependency graph	✅	✅	✅	❌
Health checks	✅	✅	✅	❌
TUI dashboard	✅	❌	✅	❌
Agent/AI interface	✅	❌	❌	❌
Docker-free	✅	❌	✅	✅
Setup step provisioning	✅	❌	❌	❌

Architecture

crates/
  core/              Shared types
  config/            devme.toml parsing + validation
  slot-allocator/    Port offset allocation
  executor/          Process spawning and lifecycle
  ipc/               Unix socket protocol
  supervisor/        Per-worktree daemon
  shared-supervisor/ Per-repo shared-services daemon
  client/            IPC client library
  tui/               Ratatui terminal UI
  cli/               CLI surface (clap)

Two-tier daemon architecture. An instance daemon per worktree manages instance-scoped services, while a shared-services daemon per repo handles things like a cloud SQL proxy that multiple worktrees need.

Development

Requires Rust 1.89+ (for stdlib File::lock).

cargo build
cargo nextest run
cargo clippy --all-targets

Design documentation

• CONTEXT.md: Domain glossary and invariants
• docs/adr/: Architectural decisions (numbered, append-only)

Status

Early development, not yet published. Design is captured and implementation is progressing through the crate structure above. Contributions welcome once the core stabilizes.

License

MIT