What shipped, what's coming

Shipped means in the build you can install today. Roadmap means coming — never implied as shipped.

• Azure Bicep support — .bicep and .bicepparam as a peer language on the same canvas: params, vars, outputs and resources as nodes, references as wires, resolved values, and the same surgical write-back. A hand-rolled Bicep engine in the WebAssembly bundle — no Bicep CLI. Details.
• Bicep environments as multiple .bicepparam files on one canvas (simulated workspaces stay Terraform-only). Local Bicep modules load as boxes with ports; a registry br: module shows as a box with a note.
• MCP server for AI agents — a standalone Model Context Protocol server exposing the same deterministic engine to Claude Code, Cursor or any MCP client, for Terraform and Bicep. Read and propose only: it reads the graph, resolves values and returns validated diffs, and never writes a file. Set it up with Copy MCP Setup for AI Agents. Details.
• The display name is now SchematIaC — Terraform & Bicep Visual Editor; a canvas holds one language, chosen by the first file added.
• Free six-month licence — register with your email and the six-digit code we send back; the licence it issues unlocks everything for six months from the day you start.
• Analyze — one button asks the engine what the graph would rather be wired as, by rule: an output echoing what a module takes should read the module, and so on. Each finding draws its proposed wire on the canvas — solid green, arrowed, its source lit through the trace — and Apply stages it like any hand edit, then moves to the next.
• Show Diffs — colour the canvas by what changed against the git baseline, so a review reads on the drawing, not just in the files. Vendored modules resolve in the diff view too.
• Groups — gather nodes by hand, fold the groups you are not reading (same glyph a node has), move an open group by its title, carry a folded one anywhere. What lands inside a group is decided by where you drop it.
• Mappings panel — pick a row and see both directions at once: what feeds it, and what reads it.
• Structured values — a list or object shows as structure, and one value inside it can be edited without touching its neighbours.
• Overview panel — the project's folder structure at a glance, with a door from each folder into its canvas.
• Big canvases got fast — dragging, zooming and trace clicks repaint instead of rebuilding, at roughly half the paint cost per frame.
• Multi-select with a shift-drag marquee; walk a node's rows with the arrow keys; drop a wire on a row's dot, not just its body; expand or collapse one node or the whole canvas; rows with a staged, unsaved change are highlighted; a wire can re-point to a resource's own attribute.
• Modules read honestly: a module's defaults sit in their own band so a default cannot pass for an argument, an input is told apart from the output sharing its name (in the diff too), and an unvendored registry module is a warning on its own box — not an error that blocks the canvas.
• A legend explains every colour text is painted in, including what a red name means.
• Sturdier evaluation: try() and can() evaluate, an unsupported function names itself instead of failing silently, a comment is never read as a value, and a half-written file mid-save no longer takes the canvas down — for Terraform and Bicep both.
• Licensing quality of life: Email My Key re-sends a lost trial key, trial reminder emails carry a call to action, and teams can be issued licence keys in one batch.

• Canvas view over .tf, .tfvars and local modules — blocks as nodes, properties as rows, references as wires.
• Resolved values on every row, computed locally by the WebAssembly HCL engine; honest (known after apply) for values that depend on a real apply.
• Lineage tracing — click a row, its whole path lights up.
• Value marks on every row — literal, reference, interpolated or computed — with a legend, so a resolved value is never mistaken for a hard-coded one.
• Bidirectional write-back: re-point a reference, or edit a value in the properties panel. Both are HCL-validated, both show the exact diff for approval, and only that expression's bytes change.
• Type-aware re-pointing: while you drag, compatible targets light up and incompatible ones refuse the drop. Where several wires share a source, you pick the destination first so the edit can only mean one thing.
• Everything staged until Save, with a review of every pending Terraform change and per-file revert. Reload asks before discarding staged work.
• Simulated workspaces: named sets of variable values kept in the .canvas file, switched from the toolbar or compared all at once — for the values a real workspace injects at plan time.
• File panel and grouping: every file on the canvas with its resources, click to highlight; group the canvas by file, location or resource group, and collapse the groups you are not reading.
• Checked-in .canvas files: one definition, parameterized by workspaces, with overridden values marked.
• Offline licence verification; air-gapped operation after activation.

• Project-wide forest view — the whole configuration on one canvas. The headline item, and the reason the tool exists.
• moved-block refactoring — rename and restructure with state-safe moves.
• Registry and git module sources (local ./ and ../ today).
• Drilling into a module — today it is a box with input and output ports.
• Provider schemas — read from terraform providers schema after you have run init, on your explicit command, never automatically. Shows the attributes a resource could set, makes required/optional/computed exact, and flags a missing required attribute before validate does.
• Provider upgrade impact — pick a target provider version and see, on your own resources, every attribute that was removed, renamed, deprecated, changed type or became required — before you touch a version constraint. The breakage list for your config, not the release notes.
• A palette of provider attributes and resources, driven by those schemas — adding what you have not written yet.
• Adding and deleting resources from the canvas.
• Instance expansion for count and for_each — today a resource with three instances is one node.