ARCHE
FamiliesDocsExamplesBlogGitHub ↗
Documentation

Start

  • Getting started
  • Philosophy

Guides

  • First hour
  • Agent context
  • Verification
  • Package managers
  • Scaffold lifecycle
  • Showcase & portfolio

Walkthroughs

  • TypeScript fullstack
  • Convex product
  • Rust API & fullstack
  • Solana family
  • Customize & experiments
  • Automation (JSON/MCP)

CLI

  • Overview
  • Flags
  • Subcommands
  • Generated output

Presets

  • Preset catalog

Stack

  • TypeScript architecture
  • Convex
  • Rust
  • Solana
  • Authentication
  • Prisma store
  • tRPC

Operations

  • Deployment
  • Environment variables
  • Workers & queues
  • CI & testing
  • Scaling
  • Security
  • Troubleshooting

Reference

  • Stack links
  • Capabilities
  • This source repo
  • Code examples
← Documentation

Getting started

Run the CLI from source, pick a preset, and verify a generated workspace.

1 min read

Arche is a scaffold CLI and this repository is its source of truth. The public npm package (@arche/create) is still on a guarded release track—until it ships, every command on this site assumes you are in the Arche monorepo (or a fork) and use bun run dev:cli.

PresetsCLIDeployExamplesFamilies

Three command contexts

Arche CLI — run from this repo to generate a project. Generated project — commands inside the folder you scaffolded. Source template — commands for developing Arche itself (this monorepo).

Quick loop

  1. Step 1
    Generate

    Use --dir to write outside this template repo.

    Command•••
    bun run dev:cli -- my-app --yes --preset=typescript-fullstack --dir=../projects
  2. Step 2
    Enter
    Command•••
    cd ../projects/my-app
  3. Step 3
    Verify

    CI is the preset verification harness—read AGENTS.md if a step fails.

    Command•••
    bun install bun run ci

Preset catalog

Every public preset, its support label, and what it generates:

PresetStatusShapeGood for
typescript-fullstack
TypeScript Fullstack
Requires validationNext.js web + Express API + tRPC + Better Auth + PrismaDefault production app foundation
rust-api
Rust API
Requires validationCargo workspace with service and worker slotsEngine services, background work, and future polyglot scale
rust-fullstack
Rust Fullstack
Requires validationNext.js web + Axum API + shared deployment docsTeams that want Rust on the API with a typed web client
convex-product
Convex + Next.js
Requires validationNext.js + Convex functions + Better Auth stubsRealtime apps, serverless backend, no Prisma/Neon ops
solana-program
Solana Program
Requires validationAnchor program + generated client boundariesOn-chain program work with explicit client contracts
solana-web
Solana Web dApp
Requires validationNext.js dApp + program + wallet adapter directionWeb3 apps with web wallet flows
solana-mobile
Solana Mobile dApp
Requires validationExpo mobile + program + mobile wallet boundaryMobile-first Solana products
solana-product
Solana Product
Requires validationWeb + mobile + program + shared Solana configFull product surface across web, mobile, and chain
customize
Customize
Requires validationCapability picker with validation gatesTeams that need a bespoke mix of bundles and backends
experiments
Experiments
ExperimentalExperimental routes onlyTrying unstable generators with clear expectations

Example: bun run dev:cli -- my-app --preset=typescript-fullstack --yes

CLI from source (today)

Develop from this repo

Use dev:cli until the published @arche/create release is explicitly trusted.

$bun run dev:cli -- my-app --preset=typescript-fullstack --yes
TypeScript monorepo (Next + Express + tRPC + Prisma).
$bun run dev:cli -- my-app --preset=rust-api --yes
Rust API workspace with Cargo and SQLx-ready layout.
$bun run dev:cli -- my-app --preset=convex-product --yes
Next.js + Convex (no Express/Prisma monorepo).
$bun run dev:cli -- my-app --preset=solana-web --yes
Solana web dApp with program and client boundaries.
$bun run dev:cli -- my-app --family=convex --yes
Legacy family flag (same template as convex-product).
$bun run dev:cli -- validate '{"projectName":"x",...}'
Validate a JSON config without writing files.
$bun run dev:cli -- create-json '{"projectName":"x",...}'
Non-interactive scaffold from JSON.
$bun run dev:cli -- mcp
stdio MCP server (plan, create, schema introspection).

After you scaffold

Generated project

Typical commands inside a scaffolded workspace after you cd into it.

$bun install
Install dependencies in the generated workspace.
$bun run dev
Start dev servers (shape depends on preset).
$bun run check-types
Typecheck when the preset advertises it.
$bunx convex dev
Convex routes: link deployment and run functions locally.

Architecture snapshot

Data Flow Diagram
┌─────────────────────────────────────┐
│ apps/web (Next.js)                  │
│  ↑ tRPC client                      │
├─────────────────────────────────────┤
│ packages/trpc (client contract)     │
│  ↑ types only                       │
├─────────────────────────────────────┤
│ apps/server (Express)               │
│  ├── modules/*/*.trpc.ts            │
│  ├── Better Auth (/api/auth/*)      │
│  └── tRPC endpoint (/api/trpc)      │
│  ↓                                  │
│ packages/store (Prisma client)      │
└─────────────────────────────────────┘

Where to go next

  • First hour — expanded walkthrough
  • Preset catalog — every --preset= id
  • CLI flags — non-interactive and CI-friendly options
  • Deployment — Vercel, Render, Railway, Neon, Upstash
  • Philosophy — why Arche exists and what it refuses to claim
  • Code examples — generated wiring snippets by stack

Next steps

  • TypeScript fullstack walkthroughPreset commands, verify loop, and common failures.
  • Preset catalogEvery id, support label, and scaffold shape.
  • CLI flagsNon-interactive and CI-friendly options.