Solarchsolarch

Architecture-first · AI proposes, rules verify

SolarchDiagrams thatcompile

Most AI tools generate code and hope the architecture catches up. Solarch flips that — it generates architecture first, grounded in canonical patterns, validated by a strict Rules Engine, refined through a self-correcting loop. The AI proposes; the rules verify; only correct graphs land on the canvas.

Omni-bar · two modes

Build it, or ask it.

One command bar, two minds — an autonomous builder and a conversational architect, without ever leaving the canvas.

press agent to generate

Create a project.

Split it into tabs.

Orders12 nodes · module
Payments8 nodes · module
Auth6 nodes · module
Catalog15 nodes · module
Users9 nodes · module
Billing7 nodes · module
Notifications5 nodes · module
Create what's on your mind…

Type a sentence or sketch a box. Solarch turns the intent in your head into a validated architecture — and that architecture into working code. No blank-canvas paralysis, no boilerplate; just the system you already had in mind.

Inside Solarch

One canvas. Every guarantee.

The whole backend on a single surface — grounded by an AI architect, kept honest by the rules, and type-safe end to end.

8 families · 16 edges

One canvas for the whole system

Controllers, services, repositories, tables, DTOs, queues — every part of your backend on one canvas, with the 16 semantic edges between them.

live · drag to explore

8 families

Eight families, one language

Data
Business
Access
Infra
Client
Security
Config
Structure

GraphRAG · LangGraph

An architect, not autocomplete

LangGraph grounds every plan in a vector-indexed library of canonical patterns.

1 home · N references

One node, every view

Each node lives in one tab; others import it as a ghost reference — not a copy.

tab · orders
users
tab · billing
users ·ref

Grounded context

It always knows the graph

<current_graph_state>
UsersController
UserService
users
</current_graph_state>
<prev_errors> none </prev_errors>

Schema → contract → UI

Type-safe from database to button

The schema becomes an API contract becomes a typed client — every layer checked at compile time. Change a column, and the frontend stops compiling until you fix it.

schema.sql api.ts client.ts
1
2
3
4
create table users (
id uuid primary key,
email text not null
);
one type, all the way down.

Rules engine · default-deny

You can't commit a violation — you can't even draw it.

7 anti-patterns · 3 conditional checks

ERR_002 · rejected

Controllers aren't data-access. A Controller can't reach a Table directly — route through a Service or Repository.

Default-deny — every connection that isn't whitelisted is forbidden.

Try to wire a Controller straight to its Table…

Rejected the moment you draw it — not three commits later.

So the agent inserts a Service and a Repository, and re-applies.

Rejections feed back until the graph is clean — or it never commits.

Hybrid code engine · stage 1 + stage 2

Diagrams compile themselves.

A deterministic compiler turns the graph into a skeleton with zero tokens — DTOs, entities, constructor injection straight from the edges. Then a surgical AI fills only the empty function bodies. Export it as code, a Mermaid diagram, or AI-readable memory.

Source graph

nodes · edges

Generated code

create-user.dto.tsusers.service.tsusers.controller.ts
1
2
3
4
5
6
export class CreateUserDto {
@IsString() @IsNotEmpty()
email: string;
@MinLength(8)
password: string;
}
Stage 1 · deterministic · 0 tokensStage 2 · surgical AI · ~300 tok/fn
Export toCursor & Claude ReadyMermaid diagramAPI contractVector memory

Pricing

Pick where you start.

From a $5 sketchpad to a self-correcting code engine — pay for as much of the pipeline as you need. Every plan starts with a 7-day trial.

free forever
Solarch

Free

$0/ forever

✓ 7-day trial

Start sketching for free — the Rules Engine validates every connection. Upgrade when you need more.

  • 2 projects
  • Live node/edge canvas
  • 22 node types · 16 edges
  • Default-deny rules validation
Solarch

Draw

$5/ mo

✓ 7-day trial

The drawing tool. Sketch backend architecture as a node/edge graph — the Rules Engine auto-validates every connection.

  • Unlimited projects
  • Live node/edge canvas
  • 22 node types · 16 edges
  • Default-deny rules validation
most popular
Solarch

Build

$20/ mo

✓ 7-day trial

Everything in Draw, plus AI that scaffolds your project — ~80% ships as boilerplate; the algorithmic logic stays yours.

  • Everything in Draw
  • AI diagram generation
  • Code Generation
  • 100 diagram generations · 100 edits
  • 200 questions
Solarch

Code

$100/ mo

✓ 7-day trial

Everything in Build, but Solarch writes the whole codebase — full generation, not just the skeleton. Extend any limit at discounted pricing.

  • Everything in Build
  • Solarch writes the whole codebase
  • 200 diagram generations · 200 edits
  • 300 questions
  • Extend limits at a discount
coming soon
Solarch

Team

$30 / seat

Build together — shared projects with single-home nodes and ghost references across the org.

✓ 7-day trial

Solarch

Enterprise

Contact us

Self-host, SSO, audit logs, a custom rules matrix, and dedicated support.

✓ 7-day trial

FAQ

Questions, answered.

What is Solarch?
Solarch is a backend-architecture tool. You draw your system as a node/edge graph — controllers, services, repositories, tables, DTOs, queues — and a strict Rules Engine validates every connection as you draw it. From the validated graph, Solarch generates code that matches the architecture exactly, so there is zero architectural drift between the diagram and the codebase.
How is Solarch different from AI coding tools like Copilot or Cursor?
Most AI tools generate code first and hope the architecture holds up. Solarch flips that: it generates the architecture first, grounded in canonical patterns and validated by a default-deny Rules Engine, then generates code from that verified graph. The AI proposes, the rules verify, and only correct graphs become code.
What is the Rules Engine?
The Rules Engine is a default-deny validator: every connection that is not explicitly whitelisted is forbidden. It enforces 7 anti-patterns and 3 conditional checks — for example, a Controller cannot reach a Table directly; it must route through a Service or Repository. Illegal edges are rejected the moment you draw them, not three commits later.
How does Solarch generate code?
Solarch uses a hybrid engine. A deterministic compiler turns the graph into a skeleton with zero tokens — DTOs, entities, and constructor injection straight from the edges. Then a surgical AI fills only the empty function bodies. You can export the result as code, a Mermaid diagram, or AI-readable memory.
How much does Solarch cost?
Solarch starts at $5/month for Draw (the drawing tool with rules validation). Build is $20/month (AI scaffolding), Code is $100/month (full codebase generation), Team is $30/seat, and Enterprise is custom. Every plan starts with a 7-day trial.
Is Solarch available yet?
Yes — Solarch is live. Start free at app.solarch.dev; paid plans (Draw, Build) include a 7-day trial.