Open source · MIT

Infrastructure as code,
but the infrastructure is a house.

Describe walls, rooms, openings, assemblies and foundations as typed, declarative Python. Type:Haus resolves the topology, frames every wall with real studs, plates and headers, runs integrity, code and structural checks, and compiles the same source to an IFC4 model, DXF drawings and a permit-ready PDF set.

Open the editor in your browser Install the CLI

No install required — but if you want the full engine

curl -LsSf https://type-haus.com/install.sh | sh

Installs the haus CLI with pipx (Python 3.11+, no uv required). Windows PowerShell: irm https://type-haus.com/install.ps1 | iex. Read the scripts first if you'd rather — install.sh · install.ps1.

The Type:Haus editor: a dimensioned 2D floor plan with resolved stud framing, rooms and furniture on the left, and a shaded 3D model of the same house on its site on the right. — The browser editor, running the engine client-side on the bundled Catlin reference house — five storeys, real framing, live checks, no server.

One source of truth, from sketch to permit set

Floor-plan apps stop at rectangles. CAD makes you draw every stud yourself. Type:Haus keeps a single typed model: you author intent, the engine resolves the consequences — gap-free mitered corners, walls stacked across storeys, every wall framed, rooms and takeoffs derived, checks re-run — and every output is a view of that same model.

Plan source you can read

Nodes, walls, openings, rooms and assemblies are frozen typed objects declared with plain keyword arguments. Diffable, mergeable, reviewable — and safe to hand-edit or hand to a coding agent.

The actual framing, everywhere

Plan cuts and 3D show real studs, plates, headers and insulation hatch — never a generic gray box. That's what makes design-exact material takeoffs possible.

Assemblies are first-class

Layer stacks carry materials, control layers and R-values — for exterior envelope and interior partitions. One wall line can change assembly on every storey and the transitions still resolve.

Checks, not vibes

Integrity, code, structural and advisory checks run over the resolved model and come back as findings with severities. The same registry runs under haus check, in pytest, and live in the editor.

Stable identity

Every element keeps an immutable uid, so retagging, moving between storeys, or round-tripping through IFC never breaks downstream references.

Git is the collaboration layer

No accounts, no cloud project store, no lock-in. Your house is a folder of source files you own, version and branch like any other repository.

Two exit ramps, both first-class

A design is only useful if it leaves the tool. Type:Haus is built so you can either carry it all the way yourself, or hand a professional something they can genuinely build on instead of redraw.

1 · Refine in place

Keep iterating against the checks until the set is permit-ready. haus print composes the sheets; haus permit-check gates the declared submittal subset and refuses to print on unknowns or failures.

2 · Hand off, preserving the work

haus print --handoff emits the "give this to your architect" bundle: core-LOD IFC, every DXF, the permit PDF, your brief, and the diff baseline. Their revised IFC comes back through haus diff as a semantic, reviewable change list.

Deterministic exports

IFC4 with typed layered walls, real spaces, openings with schedules, georeferencing and standard psets, carrying stable GlobalIds. Builds are deterministic — CI diffs two consecutive builds of an unchanged plan on every run. DXFs follow the AIA CAD layer guidelines.

Building science, quantified

Assembly R-values, per-façade window-to-wall ratio, Glaser-method condensation risk plotted on the section card, and a transparent design-day block heating and cooling load via haus energy.

Runs in your browser

The engine is pure Python compiled onto Pyodide and shipped as an installable PWA. Resolve, check, edit, and 3D all happen client-side. Nothing is uploaded; after the first load it works offline.

Built for agentic editing

Edit the plan in your editor on one screen while the UI redraws on the other. The # haus: editable subset is a constrained declarative dialect with no executable surface, and a linter proves it.

Look at it, don't guess

Every edit ends in a picture. Plan, section, site and 3D snapshots render headlessly, so spatial judgment — yours or an agent's — joins the text findings.

Basement floor plan in the Type:Haus editor showing labelled rooms with square footages, a stair run, plumbing and mechanical fixtures, and the sunken garden retaining walls. — Derived rooms, areas, fixtures and life-safety symbols per storey.

Shaded 3D view of the same house sitting on its site, with the walkout basement, porch railing and roof planes visible. — The same model in 3D, on its real parcel. Deliberately not photoreal — that's a job for a render pass, not the source of truth.

What a permit set looks like

haus print builds the model, renders every sheet, and writes one permit_set.pdf plus per-sheet DXF at 11×17 — the size many Minnesota cities accept for a residential review set. The whole set is composed from the resolved model, so nothing is drawn twice and nothing drifts.

Sheet	Content
A-000	Cover, sheet index, code summary from the checks output
C-101	Site plan — parcel basemap, setbacks, project north
S-100	Foundation plan — foundation walls, footings, pads, posts
S-101…	Framing plan per storey, plus a framing schedule and bill of materials
A-101…	Dimensioned floor plan per storey, then the roof plan
A-201…204	North, south, east and west exterior elevations
A-301	Building section
A-401…	Wall sections and details — authored slices, then every derived transition
A-601	Door and window schedule
P/M/E-1xx	Plumbing, HVAC and electrical plans, per storey that has content
EN-1	Energy compliance summary — assembly R-values against code and preferences

Code coverage is a declared subset (Minnesota residential first), and unknowns report as unknowns rather than guesses. Type:Haus does not replace the architect or engineer of record.

Two ways in

Start in the browser with a real house already loaded. Drop to the CLI when you want IFC export, permit printing, and generative macros.

Open the app. type-haus.com/app boots the Catlin reference house in the in-browser engine — five storeys, framing, rooms and live checks — with no account, no upload and no folder pick. Install it from the browser menu and it works offline. View the Catlin house → is the stable link to that same read-only, in-browser build of the reference house.

Bring your own house. "Open house folder" points the same in-browser engine at a plan directory on your disk. Nothing leaves the machine.

Install the engine. curl -LsSf https://type-haus.com/install.sh | sh, then haus new my-house and haus serve my-house for the same editor backed by the full local engine.

The CLI, in full:

# scaffold, build, inspect
haus new my-house
haus build my-house              # -> out/model.json (+ IFC)
haus check my-house              # integrity / code / structural / advisory findings
haus ls my-house --summary       # compact plan digest
haus serve my-house              # 2D/3D editor at http://127.0.0.1:8000

# analyze
haus energy my-house             # design-day block heating/cooling load
haus takeoff my-house            # framing counts, radiant-wire lengths
haus explain HOUSE_WALL_2X6_WITH_ZIPR my-house --card

# ship
haus permit-check my-house       # gate the declared permit subset
haus print my-house --handoff    # permit PDF + DXFs + architect bundle
haus diff architect.ifc my-house # semantic diff of their revisions

What this is not

Type:Haus is openly scoped. Knowing the edges up front is more useful than finding them later.

Not a commercial-building tool. Residential, up to duplex scale. No multi-family, no commercial code paths.
Not general-purpose CAD. It compiles a house model; it will not draw you an arbitrary shape.
Not a cloud service. There is no account and no server-side project store. Git is the collaboration layer.
Not visually stunning by design. The 3D view is an honest, quality-surfaced model, not a marketing render. Pass an elevation to an image model if you want the glamour shot.
Not a substitute for a professional. Checks are advisory. A licensed architect or engineer still owns what gets stamped and built.

Questions

Does the browser app really run the whole engine client-side?

Yes. The Python engine is bundled as source, unpacked into a Pyodide web worker, and run there. Resolve, checks, model JSON, 3D and plan editing all happen on your machine. Two things still need the local install: generative macros, and IFC export (its geometry kernel has no browser build yet) — both report that plainly instead of failing silently.

Is my house design uploaded anywhere?

No. The app is static files plus a client-side engine; there is no backend to upload to. The bundled demo house ships with the app, and a folder you open stays on disk.

What does the install script actually do?

It finds a Python 3.11+ interpreter, makes sure pipx is available, and runs pipx install "typehaus[server]" — an isolated install, no changes to your global site-packages. It then offers to scaffold a starter house and open the editor. The source is right there at /install.sh; piping an unread script into a shell is always your call.

Building a downloaded house runs its Python — is that safe?

haus build imports the plan package, which is the same trust decision as pip install. The # haus: editable files are a constrained declarative subset with no executable surface, and haus build --inspect previews a plan without importing params/.

Which building code does it check against?

A declared subset, Minnesota residential first. Coverage is explicit: a rule that is not implemented reports as unknown rather than passing quietly, and haus permit-check refuses to print a set with unknowns or failures in the declared subset.

Infrastructure as code,but the infrastructure is a house.