Everything in the box

What metaforge
can do

From a single declarative language definition you get a complete authoring toolchain and a real, installable diagram editor. Here's the full picture — grouped by what you actually want to do.

A generated metaforge diagram editor running in VS Code
A generated editor — palette, live diagram, and property panel — running in plain VS Code.
Author a language

Four visual editors, zero code

A language is four pieces of declarative data — each with its own editor in VS Code. You design it; metaforge brings it to life.

The semantic model editor in metaforge

Semantic model

Draw your element types with typed properties (text, number, boolean, date, plus your own enums and datatypes), relationships with ownership/navigability, inheritance, and association classes — the concepts your diagrams are made of.

The node shape editor authoring a tagged SVG

Node shapes

Author each shape as a tagged SVG — draw it in Inkscape or import one. metaforge compiles it into an outline, a content box, and named anchor points for edges and content.

The edge style editor in metaforge

Edge styles

Lines, dashes, arrowheads, diamonds and triangles, routing, and edge labels — describe exactly how each relationship is drawn.

The view binding editor mapping concepts to appearance

View binding

The glue: map each concept to how it looks — element to shape, property to a label or a value-driven colour, relation to an edge style, containment to a content box. Reusable data, so one shape can serve many elements.

Generate an editor

One command, a shippable editor

⚡

Generate

Turn your language definition into a complete, self-contained VS Code extension — it bakes in everything it needs, with no runtime dependency on metaforge.

📦

Package a .vsix

Build an installable .vsix in one step. Hand it to a colleague and it just runs in any VS Code.

↺

Regenerate

Change the language, regenerate with your saved settings — no re-typing, no editor code to maintain.

Edit models

A full editor your users expect

The generated editor is a complete diagram tool — and every rule comes straight from your model, so it behaves correctly without a line of hand-written logic.

Create & connect

Drop nodes from a palette built out of your element types; draw relationships as edges where your model allows them.

Nest & contain

Drag a node into another where containment is legal; children render inside the parent's content box, empty containers show a compact drop band.

Edit properties

A property panel with the right control for each type — dropdowns for enums, toggles for booleans — plus move, delete, and re-parent, with layout preserved.

Interaction demo (GIF) — drag from palette, nest, edit a property
assets/screenshots/edit-demo.gif
Create, connect, nest and edit — all driven by your model, no hand-written logic.
Graphical or textual

Two views of one model

A model shown as a diagram, alongside its textual form

The same model, as text

Export any diagram to a readable text form, edit by hand, and load it straight back — lossless and id-stable.

shelf "Sci-Fi" {
  book "Dune"          author: "Herbert"  genre: SCIFI
  book "Neuromancer"   author: "Gibson"   genre: SCIFI
}
shelf "Reference" {
  book "SICP"          author: "Abelson"  genre: TECH
}

Readable text, round-trip

Export any model to a human-readable text form and edit it by hand — then load it straight back into the diagram, lossless and id-stable. The grammar is generated from your language, and it works even in a packaged editor.

Make the syntax your own

Seed an editable grammar from your language and change the keywords and structure freely. It's validated live against your model, and your edited grammar drives text-to-diagram.

One source, many outputs

Define it once, use it everywhere

Your language definition model · shapes · binding
▸ A live, interactive editor
▸ Clean SVG export (server-less)
▸ A readable, editable text form
▸ A typed API for code & artifact generation
Proven on real domains

One engine, many languages

Every example below runs on the same generic engine with zero language-specific code — the real proof that a language is just data.

Turn your notation into a tool.

metaforge is in active development. Explore the project, try the authoring editors, and generate your first language.