The system architecture compiler
Rhodd is a deterministic system architecture compiler for declarative software systems. You declare the system in rhodd.yaml; Rhodd validates it, builds a model and graph, plans every write, emits deterministic artifacts, and writes lock, ownership and handoff state.
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: trueA different layer
Rhodd is not infrastructure-as-code, not a scaffold, and not an AI builder. It compiles the software-system architecture layer that sits above them.
A different layer
Terraform and Pulumi manage infrastructure resources — networks, clusters, cloud accounts. Rhodd compiles software-system architecture: services, modules, the dependency graph and the baseline they generate. Different layer. Rhodd does not emit, include or synthesize Terraform.
Stateful, not one-shot
A generator copies a starting point and forgets it. Rhodd is a stateful, inspectable compiler — it keeps the model, graph, plan, lock, ownership and handoff, so the system stays coherent as it changes.
Compiled, not prompted
AI builders generate from prompts and hope. Rhodd compiles from an explicit definition: same input, same output. AI is a bounded consumer of compiled state — never the generator, no live calls by default.
Definition in, baseline out
One deterministic pass of nine local stages. The four amber stages — model, quality, ownership, handoff — are where a compiler does what a template cannot. See how it works →
Architectural invariants
The properties that hold on every compile, by construction — not by convention.
Everything runs on your machine. No account and no cloud dependency to compile a baseline.
Same input → byte-identical output. The lock file's input and output hashes prove it.
Every artifact under .rhodd/ is plain text you can read, diff and commit. No hidden state.
No provider or cluster calls happen unless you opt in — AI providers included.
Generated paths and user-owned source are tracked apart, so regeneration never clobbers your code.
Applying a baseline is explicit and reversible; apply and rollback are opt-in, never automatic.
Compile your software system from a definition.
Local-first, deterministic, inspectable. Rhodd works without AI — AI becomes safer when Rhodd gives it explicit state.