Solarch

What is Solarch?

Solarch is a backend architecture design tool that turns a drawn node-and-edge graph into validated project structure and generated code. It is built around an architecture-first workflow: you sketch or describe the system, Solarch’s AI proposes a graph, and a rules engine checks the result before it is accepted.

The product centers on a single canvas where backend components such as controllers, services, repositories, tables, DTOs, queues, and other architecture elements can be represented as connected nodes. It is designed to help teams and individual builders keep the architecture, generated code, and type information aligned so the system can be compiled from a canonical graph rather than assembled from disconnected files.

Solarch also positions itself as a self-correcting workflow. If a proposed connection violates a rule, the graph is rejected and revised before it lands on the canvas. That makes it useful for people who want to design backend systems visually while keeping structural constraints explicit.

Key Features

• Architecture-first canvas: users draw backend systems as a node/edge graph, starting from the architecture instead of code files.
• Rules Engine validation: connections are checked against predefined rules, including default-deny behavior, so invalid relationships are rejected early.
• AI-assisted graph generation: the AI can propose a project structure from a prompt or sketch, then refine it through validation feedback.
• Semantic backend modeling: the canvas includes backend concepts such as controllers, services, repositories, tables, DTOs, queues, and related nodes and edges.
• Type-safe pipeline: schema, API contract, and client artifacts are connected so changes propagate through the stack and break the build when types no longer match.
• Hybrid code generation: Solarch can generate a deterministic skeleton first and then use AI to fill in function bodies.
• Multiple export formats: output can be exported as code, Mermaid diagrams, or AI-readable memory.
• Tabbed graph structure with ghost references: each node has a home tab, while other views can reference it without duplicating the source node.

How to Use Solarch

Start by creating a project on the canvas and either draw the backend structure directly or describe what you want in the command bar. Solarch will propose a graph, validate the connections, and prompt corrections when a rule is violated.

From there, refine the architecture by splitting nodes into tabs, wiring services and repositories, and checking that the graph follows the allowed patterns. Once the structure is clean, export it to code or use the generated diagram and memory output as a base for implementation.

Use Cases

• Backend system planning: map out controllers, services, repositories, and data tables before implementation so the architecture is explicit.
• Rule-constrained design review: catch invalid connections such as controller-to-table access before code is committed.
• Schema-driven development: keep database schema, API contract, and typed client aligned during iterative changes.
• Code scaffolding: generate a backend skeleton from the graph, then fill in the remaining implementation details.
• Team architecture collaboration: share a single graph across a team, with tabbed nodes and ghost references for consistent views.

FAQ

Does Solarch generate code automatically? Yes. The product describes a hybrid flow where it generates a deterministic code skeleton first and then uses AI to fill in function bodies.

Can Solarch validate architecture rules? Yes. Its Rules Engine checks connections and rejects unsupported relationships rather than letting them reach code generation.

What can be exported from Solarch? The source mentions code export, Mermaid diagram export, and AI-readable memory.

Is Solarch only for visual diagramming? No. It is positioned as both a diagramming surface and a code-generation workflow tied to the validated graph.

Does the source mention pricing or deployment details? It mentions plan pricing and a self-hosted enterprise option, but not detailed deployment or infrastructure specifications.

Alternatives

• Traditional diagramming tools: these are useful for visualizing architecture, but they do not appear to validate rules or generate code from the diagram.
• General AI coding assistants: these help with code generation and editing, but they typically do not enforce an explicit backend graph or architectural constraints.
• Manual backend scaffolding in an IDE: this gives full control over files and implementation, but it does not provide a shared graph-based architecture model.
• Other architecture modeling tools: these may help document systems, but Solarch is more focused on turning the model into generated code and enforcing relationship rules.