v0.1.0-rc.1 · pre-release
Deterministic system architecture compiler

Compile your software system
from a definition.

Declare your services, dependencies and ownership once. Rhodd validates the graph, plans every write, runs quality gates, and emits a locked, reproducible baseline — with the ownership boundaries and handoff context humans and AI need to continue safely.

Join the betaView on GitHub
9compile stages
local-firstno live calls by default
100%reproducible

From two services to a dozen — same compiler, same .rhodd/ state.

rhodd.yaml
yaml
version: "0.1"
project:
  name: fullstack-saas
  description: Frontend, backend, a Go service, database, worker, adapters, Docker, and Kubernetes.
preset:
  kind: fullstack-saas
  quality: production-baseline
frontend:
  framework: react
  language: typescript
  bundler: vite
  validation: zod
  componentLibrary: radix
  state:
    client: zustand
    server: tanstack-query
backend:
  language: typescript
  framework: nest
  transport: rest
  orm: prisma
modules:
  - name: postgres
  - name: redis
services:
  - name: web
    kind: app
    runtime: react-ts-zod
    language: typescript
    port: 5173
    exposure: cluster
    dependencies: [api]
    consumes: [http]
    env: { VITE_API_BASE_URL: http://api:3000 }
  - name: api
    kind: app
    runtime: node-nest
    language: typescript
    port: 3000
    replicas: 2
    exposure: cluster
    provides: [http]
    dependencies: [postgres, redis]
    consumes: [postgres, redis]
    env: { DATABASE_HOST: postgres, CACHE_HOST: redis }
  - name: audit
    kind: app
    runtime: go-http
    port: 8081
    exposure: cluster
    provides: [http]
    dependencies: [api]
    consumes: [http]
    env: { API_BASE_URL: http://api:3000 }
  - name: jobs
    kind: app
    runtime: node-worker
    language: typescript
    port: 9100
    exposure: none
    dependencies: [api, postgres, redis]
    consumes: [http, postgres, redis]
    env: { QUEUE_NAME: billing-jobs }
database:
  provider: postgres
  orm: prisma
targets:
  - { name: frontend-react }
  - { name: backend-node-nest }
  - { name: backend-go-rest }
  - { name: prisma-db }
  - { name: workers-node }
  - { name: docker-compose }
  - { name: kubernetes }
  - { name: full-project }
infrastructure:
  compose: true
  kubernetes: true
  docs: true
  tests: true
Not a templatea baseline compiler

A compiler keeps what a copy throws away.

vs templates

A system, not a folder

A template copies a starting point and forgets it. Rhodd preserves the system around your code — model, graph, plan, lock, ownership and handoff — as machine-readable state.

vs AI builders

Compiled, not prompted

AI builders generate from prompts and hope. Rhodd compiles from an explicit definition: same input, same output. Rhodd works without AI — AI becomes safer when Rhodd gives it explicit state.

vs scaffolds

A lifecycle, not one-shot

A scaffold stops at the first copy. Rhodd keeps the graph, plan and lock so every later change is recalculated against the system — not pasted over it.

The compile

Definition in, baseline out

Nine stages run locally and deterministically. Four of them — model, quality, ownership, handoff — are where a compiler does what a template never could.

01
validate
Schema + rules check
02
model
Build the system model
03
graph
Resolve dependencies
04
plan
Compute write set
05
generate
Emit target artifacts
06
quality
Gates + checks
07
lock
Hash + freeze
08
ownership
Assign boundaries
09
handoff
Context for humans + AI
Differentiator — model, quality, ownership, handoffStandard compile stage
The shape

Your system, drawn

Rhodd reads your spec, resolves a typed acyclic graph, compiles it in stages, and holds the contracts between services — all as inspectable state.

4 services2 modules5 entities7 typed edges228 generated files
  • Root: rhodd.yaml — one spec.
  • Service group api (Nest · TypeScript) — generates: HTTP server · main.ts · app.module; security · api-key guard · auth; DB connector · Prisma service · repository; validation · filters · health; modules: users · auth · billing.
  • Service group audit (Go · http) — generates: main.go · handler; service · http_client adapter; config · handler_test.
  • Service group jobs (Node · worker) — generates: worker · queue (bullmq); processors: billing; http · prisma adapters · logger.
  • Service group web (React · Vite) — generates: App · routes · pages; api client · dtos · schemas; components · ui · features; store · hooks · providers.
  • Output group system (infra outputs) — generates: docker-compose.yml; k8s/ manifests · k8s-plan; prisma schema · .env.d · docs.
  • Output group .rhodd/ (state + handoff) — generates: graph · model · plan · manifest; ownership · quality · lock; ai/ handoff · context · prompts · tasks.
  • One spec generates four services with per-runtime layers, system infrastructure, and Rhodd's own state. 228 files, acyclic.
root specserviceinfra · stategeneratescontains

One spec compiles into real, per-runtime code — Nest, Go, a worker, React — plus system infra and Rhodd's own state. 228 files, acyclic.

{
  "schema_version": "rhodd.full_project.graph.v1",
  "system_name": "fullstack-saas",
  "nodes": [
    { "name": "web",      "kind": "app",   "runtime": "react-ts-zod", "provides": ["http"],   "consumes": ["http"] },
    { "name": "api",      "kind": "app",   "runtime": "node-nest",    "provides": ["http"],   "consumes": ["postgres", "redis"] },
    { "name": "audit",    "kind": "app",   "runtime": "go-http",      "provides": ["http"],   "consumes": ["http"] },
    { "name": "jobs",     "kind": "app",   "runtime": "node-worker",  "provides": ["worker"], "consumes": ["http", "postgres", "redis"] },
    { "name": "postgres", "kind": "infra", "runtime": "postgres",     "provides": ["postgres"] },
    { "name": "redis",    "kind": "infra", "runtime": "redis",        "provides": ["redis"] }
  ],
  "edges": [
    { "dependent": "api",   "dependency": "postgres" },
    { "dependent": "api",   "dependency": "redis" },
    { "dependent": "audit", "dependency": "api" },
    { "dependent": "jobs",  "dependency": "api" },
    { "dependent": "jobs",  "dependency": "postgres" },
    { "dependent": "jobs",  "dependency": "redis" },
    { "dependent": "web",   "dependency": "api" }
  ],
  "topological_order": ["postgres", "redis", "api", "audit", "jobs", "web"],
  "entities": [
    { "name": "User",           "owner": "services/api/src/modules/users" },
    { "name": "Session",        "owner": "services/api/src/modules/auth" },
    { "name": "BillingAccount", "owner": "services/api/src/modules/billing" },
    { "name": "AuditEvent",     "owner": "services/audit" },
    { "name": "JobRun",         "owner": "services/jobs" }
  ]
}
.rhodd/ · generated✓ acyclic — proven by topologicalOrder · identical hashes on re-run
Bounded AI.rhodd/ai handoff

Rhodd works without AI. AI becomes safer when Rhodd gives it explicit state. The handoff is a bounded consumer of compiled state — never the generator. It is lint-checked with secrets redacted, and providers never run by default (skipped unless you pass --include provider).

.rhodd/ai/context.md
md
# Rhodd handoff — for humans and AI

Read order: context → model → graph → generation-plan → ownership → target-matrix

This system was compiled deterministically. Treat the artifacts under `.rhodd/`
as ground truth. Rhodd works without AI; AI becomes safer when it reads this
explicit state instead of guessing.

  .rhodd/ai/
    context.md            system shape + read order (this file)
    prompts/              task-scoped prompts, ready to paste
    tasks/                bounded, checkable units of work
    graph.json            services, modules, edges (acyclic)
    model.json            the resolved system
    generation-plan.json  the write set (dry-run clean)
    ownership.md          generated vs user-owned paths
    target-matrix.md      targets → emitted files

Safety (code-enforced): the handoff is lint-checked and secrets are redacted —
the linter errors on api_key / token / secret / password patterns and never
prints the value. Providers (openai, anthropic, gemini) never run by default;
they are skipped unless you pass `--include provider`, and the run records
"no provider call was made". A deterministic local `fake` provider is available
for offline validation.
In practicethe compiler, end to end
Video
Fig 01 · rhodd compiling a systemloads YouTube only on play
InstallGo binary · no npm
install
bash
# install the rhodd compiler (Go binary — no npm)
sh install.sh --version v0.1.0-rc.1
# or
go install github.com/rhodd-fdn/rhodd-core/cmd/rhodd@v0.1.0-rc.1

Define the system once.
Compile the baseline.

A deterministic system architecture compiler for declarative software systems. Local-first, reproducible, and inspectable — install the CLI and compile your first baseline.

Join the betaView on GitHub