Home Architect: Draw a House on Your Own Land, in a Browser Tab

Every house design starts with the same two facts, and neither of them lives in the drawing: the shape of the land, and where north is. Get those wrong and everything downstream is decoration — the bedroom that never sees the morning, the balcony that bakes at four o'clock, the wall you priced twice because you guessed its length.

Home Architect starts from those two facts. Give it a location, get the plot, draw the plan at real scale, and it will tell you the areas, the sun hours, the code problems and the likely bill — without sending your property anywhere.

Getting the land in

There are four ways in, and they all end at the same polygon.

| Input | What happens | |---|---| | A pasted Google Maps link | The coordinates are read straight out of the URL (`@lat,lng`, `!3d…!4d…`, `q=lat,lng`) | | An address | Geocoded through OpenStreetMap's Nominatim, with suggestions as you type | | A click on the map | Drops a draggable pin wherever you want it | | A KML or GeoJSON file | The first polygon in the file becomes your plot |

There is no Google Maps API key anywhere in this, because there is no server to keep one on. A public key in a page anyone can view is a key anyone can bill, so the tool takes the honest route: it parses the link you already have, and gets everything else from OpenStreetMap and Esri's open satellite imagery.

For the outline itself, Import OSM footprint queries the Overpass API for `way["building"]` and `relation["building"]` within 80 metres, and falls back to land-use and parcel boundaries within 250 metres when nothing is mapped. You get every candidate as a clickable polygon with its area on the tooltip. When OpenStreetMap has nothing — which is normal outside dense cities — switch to satellite and click the corners yourself. Corners stay draggable, right-click removes one, and the area and perimeter update as you drag.

Press Use as site and the polygon is projected onto a local tangent plane: metres east and metres south of the plot's own centre. Over a residential plot that is accurate to a few centimetres, which is an order of magnitude below anything that matters when you are drawing walls.

Rooms you don't have to declare

Most planners make you draw a "room" object. This one doesn't have the concept. You draw walls; the rooms are derived.

Every wall is split wherever another wall crosses it. Endpoints within three centimetres are welded onto shared nodes. The result is a planar graph, and the minimal cycles of that graph — traversed by always taking the tightest turn at each node — are its faces. Each connected group's largest face is the outside of the building and is thrown away. What is left are the enclosed spaces, with their polygons, areas, perimeters and bounding walls.

That has a consequence worth knowing: close a gap and a room appears instantly, complete with an area, a name, a floor finish and a line in the estimate. Leave a gap and you get nothing, because there genuinely is no room there yet. The checks panel says so in as many words rather than failing silently.

The same derivation powers a subtler measurement: the widest circle that fits inside a room. That is the honest answer to "how wide is this space", and it is what the 90 cm corridor rule is checked against.

Where the sun actually goes

The solar engine is the standard NOAA approximation. Day of year gives the declination and the equation of time; longitude and the clock give the hour angle; from those come altitude and azimuth. Shadows on the plan are each wall's footprint swept away from the sun by its height divided by the tangent of the sun's altitude — the same arithmetic a surveyor does with a stick.

Direct sunlight *inside* a room is a different question, and the tool answers it separately. For every half hour between sunrise and sunset it takes each window in the room's own walls, works out the direction that window faces (outward, away from the room's centroid), and checks whether it points at the sun at all. If it does, a ray is cast towards the sun and tested against every other wall — if something taller than the shadow line is in the way, that window is not lit. Add it up and you get the number that actually matters: *this bedroom gets 2.5 hours of direct sun on 21 December, from the south-east.*

Drag the time slider, or press Play the day and watch the shadows swing across the plan. Turn on the daylight heat map and every square metre is coloured by the share of the day it spends out of shadow — which is how you find out that the terrace you planned is in shade from two o'clock.

The checks are boring, which is the point

Real building codes are local and change. What does not change much is the set of things that are wrong in every jurisdiction: bedrooms under 9 m², corridors under 90 cm, doors under 80 cm clear, ceilings under 2.4 m, a bedroom with no openable escape window, a habitable room with less than a tenth of its floor area in glass, a door that opens into a kitchen counter, a bed with 30 cm to squeeze past.

Home Architect checks all of those as you draw, colour-codes them red, orange and yellow, and for each one tells you the current value, the required value, and where it is. Several offer a one-click fix — widen the door, flip the swing, raise the ceiling, add a window to an outside wall. The kitchen work triangle is measured. The site coverage against your plot is measured.

It is a sanity check, not a permit. Local code, ground conditions and what your municipality will actually approve are outside anything a web page can know, and the drawings still need a licensed architect or engineer. But going into that conversation with the obvious problems already fixed is worth a great deal.

The layout generator is not a language model

Type "3 bedrooms, 2 bathrooms, open-plan kitchen, office, south-facing balcony" and press Generate. What happens next is a constraint-satisfaction pass, and it is deterministic enough to explain in a paragraph.

The prompt is parsed into a room programme with target areas from a table of standard sizes. The buildable rectangle is found by insetting your plot by the setback and shrinking until it fits inside the boundary, then shrinking again to the area the programme actually needs. That rectangle is sliced recursively by area — public rooms first, so the zones stay contiguous. Then rooms are swapped between slices while the score improves: area fit dominates, so nothing lands in a slot three times its size, and orientation and adjacency choose between the sensible options that remain. Living rooms and bedrooms want south, bathrooms and utility rooms want north, kitchens want the east.

Walls are then built from the slice edges, with the outer ring load-bearing and the internal lines as partitions. Doors come from a maximum-overlap spanning tree rooted at the hall or living room — which guarantees that every room is actually reachable — plus a front door on the public side. Windows are sized on each external edge to clear the one-to-ten glazing rule. Furniture is placed per room type, because a bedroom that cannot hold a bed is not a bedroom.

Then drag it about. The generated plan is ordinary geometry, and everything recalculates as you move it.

Walking through it

The blueprint extrudes to a 3D model on demand: walls split around every opening so the reveals are real, glass in the windows, leaves in the doors, floors per room in the finish you chose, a pitched, flat or skillion roof, and the sun placed as a directional light from the same astronomy the plan uses — so the shadows in 3D are the shadows on the plan. Orbit it, turn the roof off to look inside, or switch to walk mode and move through it at eye height with WASD.

On a phone or headset that supports WebXR, Enter AR puts the model in front of you at 1:1. Standing on your own plot and walking through the front door of a house that does not exist yet is a strange and genuinely useful experience — you find out that the hall is too tight in about four seconds.

Export the model as OBJ, the plan as SVG or PNG, and the estimate as CSV.

What it will cost

Every wall you stretch and every room you close updates a bill of quantities: floor area, net wall area after openings, external versus internal wall length, counts of doors and windows, wet rooms, fixtures. Those quantities are multiplied by a rate table — foundation, structure, roof, external and internal finishes, floors, joinery, plumbing, electrical, HVAC, fixtures, then labour and permits as percentages — and scaled by a regional multiplier and a finish level.

You get a total, a cost per square metre, a category breakdown, a material list you could take shopping, and a short list of ways to spend less that responds to what you actually drew. It prints, and it exports to CSV.

Every rate is an average. Averages are wrong in detail and useful in aggregate: they will tell you whether you are designing a 150,000 house or a 400,000 one, which is the question that matters before an architect's first invoice.

Nothing leaves the browser

The map tiles you look at come from OpenStreetMap and Esri, and geocoding a typed address asks Nominatim — those are lookups anyone can make. Everything else is local. Your plot polygon, your plan, your costs and your saved projects live in your own browser's storage, exported to a `.json` file whenever you want a backup. There is no account, no upload, and no copy of your property on anyone's server, because there is no server.

Open Home Architect and put your own address in.