Your Terraform, as a drawing. Edit the drawing — it edits the files.
Terraform tools show you a picture. SchematIaC gives you a drawing you can edit — and writes your changes back into the files, surgically.
SchematIaC = schematic + IaC. Say it like “schematic” with an ack: skee‑MAT‑ee‑ack.
“Every file is a tree; there's no way to see the forest — or to act on it.”
You cannot see the shape of the project
Which module feeds which? What consumes this variable? Answering it means grepping and holding a graph in your head.
You cannot see what a resource actually gets
The file says "${var.env}-acme". What lands on the resource is "dev-acme" — and the only way to know is to mentally execute the config, or run a plan.
Existing tools are read-only, or they take your code
Visualizers draw a picture you cannot edit. SaaS design tools generate Terraform but own the source of truth.
Blocks become nodes. References become wires.
A tfvars entry flows into a variable declaration, which flows into a resource attribute — visible as one connected path. Click any row and its whole lineage lights up while everything else dims.
The computed value, not the expression
The canvas evaluates your HCL locally and shows what each attribute becomes. And it is honest about what genuinely cannot be known before terraform apply — no guessing.
| Written in the file | Shown on the canvas |
|---|---|
| "${var.env}-acme" | "dev-acme" |
| merge(local.common_tags, {...}) | { Environment = "dev", Name = "dev-acme-web", … } |
| var.bucket_name | "acme-dev-artifacts" |
| aws_vpc.main.id | (known after apply) |
One line changes. Nothing else moves.
Drag a wire to a new source, or edit a value in the properties panel. Either way you see the exact diff and approve it before anything is staged, and nothing reaches disk until you press Save.
Only that expression's bytes change. The trailing comment and its spacing survive — that is what “surgical” means, and it is why the tool is trustworthy enough to point at real infrastructure.
@@ -14,7 +14,7 @@ resource "aws_instance" "web" {- instance_type = var.instance_type # standard workload+ instance_type = var.machine_class # standard workload
One definition. Workspaces parameterize it.
A canvas is a checked-in file over one definition of your infrastructure — the same model as Terraform itself. Environments are simulated workspaces inside it: named sets of variable values, saved in the .canvas file, switched from the toolbar or compared all at once. Open the canvas twice, pick a different workspace in each, and “which subnet is prod actually using?” is a glance rather than an investigation.
| variable | workspace: prod | workspace: dev |
|---|---|---|
| region | "us-west-2" override | "us-east-1" default |
| instance_type | "m5.large" override | "t3.micro" default |
No telemetry
No analytics, no usage tracking, no licence check-in.
Nothing is uploaded, ever
The HCL engine is compiled to WebAssembly and runs inside your editor.
Works air-gapped
Once activated — licence keys are cryptographically signed and verified offline.
Nothing is written without you saving
Every change is staged until you press Save.
The one exception, stated plainly: starting a trial sends an email address, an anonymous installation digest, and the six-digit code we email back. Never any Terraform, at any point. How we handle your code →
Local module sources only (./, ../). Registry and git modules are roadmap.
You cannot drill into a module yet — it is a box with input and output ports.
A few Terraform-only functions — templatefile, cidrsubnet, try — are not evaluated yet; those rows read unresolved rather than guess.
It re-points references and edits values; adding and deleting resources is roadmap.
count and for_each are not expanded — a resource with three instances is one node, and each.* references draw no wire.
The project-wide forest view and moved-block refactoring are the headline roadmap items — coming, not shipped.
Personal
- Everything — no feature gates
- One engineer, any number of machines and projects
- Offline activation included
Team
- Everything in Personal
- Assign and reassign seats yourself
- Cheaper per seat as the team grows
- Priority support
The 14-day trial unlocks everything — no card, just an email and the six-digit code we send to it; start it in VS Code. After the trial, a licence is required — canvases will not open without one; your files are untouched. Personal and Team are billed through Stripe. Enterprise — contact us.
- Does my Terraform leave my machine?
- No. Ever.
- Does it need terraform installed?
- No.
- Does it work with OpenTofu?
- The same HCL, yes.
- What happens when the trial ends?
- Canvases stop opening; your files are untouched and your .canvas files remain valid.
- Will it reformat my files?
- No — only the expression you changed.
- Does it support remote modules?
- Local module sources today; registry and git modules are roadmap.
- Can I use it on an air-gapped machine?
- Yes. Keys verify offline; only starting a trial needs the network.