How Radish Works

Describe what you want to build. AI generates the blueprint. The compiler generates the code.

AI Assistance, Deterministic Output

Describe the app you want to build in plain English. The Radish Wizard generates a YAML blueprint from your description — validated against a strict schema that guarantees consistent, performant datalayers.

The AI helps you design your data model. The compiler generates your code. That boundary is the key: you get the speed of AI-assisted authoring with the reliability of deterministic, schema-validated generation. Same blueprint in, same code out. Every time.

Write it yourself — full control over every field, type, and relationship
Generate from a prompt — describe "a project tracker with tasks, users, and comments" and get valid YAML
Mix both — generate a starting point, then hand-tune fields and relationships

You describe

"I need a CRM with contacts, deals, and notes. Contacts have a status field. Deals reference contacts and have a pipeline stage."

Radish generates schema-validated YAML

Structured blueprint with typed fields, enums, refs, defaults, and constraints — validated before a single line of code is compiled.

Deterministic code generation

Models, validation, services, endpoints. Same blueprint, same output. No randomness, no hallucinated code.

The Blueprint

Under the hood, everything compiles from a YAML blueprint — a structured description of your entities, fields, types, relationships, and constraints. AI generates it, you can hand-tune it, and the compiler validates it against a strict schema before producing any code.

Field types: string, number, boolean, text, enum, ref
Format constraints like email become Zod validators
Refs define relationships between entities (populated automatically)
Every blueprint is validated against a strict schema before compilation

# Blueprint anatomy
name: my-app
version: 1.0.0

entities:
  - name: Contact          # Entity name
    fields:
      - name: email        # Field name
        type: string       # Type: string, number, boolean, text, enum, ref
        format: email      # Optional format constraint
        required: true     # Validation flag
      - name: status
        type: enum
        values: [lead, active, inactive]
        default: lead      # Default value
      - name: company
        type: ref          # Relationship to another entity
        entity: Company    # Referenced entity name

What Gets Generated

One blueprint compiles into six distinct layers. Each is generated, typed, and wired together.

Contracts & Validation

Every entity gets a Zod schema. Input validation, output shaping, and type inference all generated from your blueprint. No hand-writing validators.

Zod schemas are generated per-entity with field types, required flags, enums, and ref relationships. Contracts enforce boundaries between layers so your service code never touches raw input.

Repositories & Persistence

Mongoose models with proper indexes, typed refs, and access patterns — generated from the same blueprint that drives your contracts.

Each entity maps to a Mongoose model with schema definitions, ref population, default values, and enum constraints. Repositories wrap models with a consistent data access API.

Service Layer

Business logic scaffolding with full CRUD operations per entity. Services sit between your API routes and repositories — ready for custom logic.

Services are generated with create, read, update, delete, and list operations. They call repositories through contracts, so you can extend them without breaking the generated foundation.

API Endpoints & Metadata

REST endpoints wired to services with typed request/response contracts. Metadata APIs expose your blueprint structure at runtime.

Routes are generated per-entity with standard REST conventions. Metadata endpoints let frontends and tools introspect your data model without hardcoding field lists.

Access Control

Role-aware structure baked into the generated architecture. Define who can access what at the blueprint level.

Access control is woven into the service and route layers. Roles and permissions defined in the blueprint translate into middleware and guards — not bolted on after the fact.

Auto-Generated Docs

Documentation that stays in sync with your blueprint. Every entity, field, relationship, and endpoint is documented automatically.

Generated docs reflect the current blueprint version. When your schema changes, docs update on the next compile — no manual sync required.

The CLI

Three commands. That's the workflow.

npx radish create my-app

Scaffold a new project with a starter blueprint

radish compile

Generate all layers from your blueprint

radish dev

Start dev server with hot reload on blueprint changes

Design Principles

The decisions behind the tool.

Deterministic Generation

Same blueprint, same output. Every time. No randomness, no drift between environments.

Inspectable Code

Generated code is readable, idiomatic TypeScript. You can step through it, debug it, and understand it.

Blueprint Versioning

Blueprints are plain YAML files in version control. Track schema evolution the same way you track code.

Own Your Code

Generated code is yours. Add custom logic, swap databases, or eject entirely. No framework lock-in.

The Platform

Radish is more than a CLI. Here's what's coming.

Radish CLI

Available

Blueprint compiler and project scaffolder. The core engine that turns YAML into architecture.

Radish Wizard

Beta

AI-powered blueprint generator. Describe your app in plain English, get a structured YAML blueprint.

Radish Hub

Planned

Application management, blueprint registry, and deployment coordination.

Radish Cloud

Planned

Hosted infrastructure for hubs, multi-tenancy, and managed environments.

See it in action

Try the CLI yourself. Define a blueprint, compile, and run.

Join the Beta