Catalog of All Tools

The measured ground of any place — climate, terrain, water — macro ⇄ micro, Rhino-ready.

Moving dirt is the first real cost a scheme incurs, and it is invisible in almost every student project. Load a site's real terrain (the same USGS 3DEP grid Surveyor samples), then reshape it — a building pad or a stepped run of benches — with side slopes that daylight back to existing grade. Read cut, fill, net import/export, truckloads, and the balance elevation at which nothing leaves the site. Cut volume is not fill volume: soil swells in the truck and shrinks in the fill, so the tool reports bank, loose and compacted separately and tells you which one the trucks are paid for. A screening-resolution grid model, not a grading plan.

Upload an EPW weather file and read the whole climate on one page — monthly temperatures with ASHRAE-style design percentiles, sun-path arcs, a wind rose, measured monthly radiation, and all 8,760 hours scattered on a psychrometric chart with Givoni-style strategy shares. The same parity-tested parser Eco-Architect, Proving Ground and Daylighter use. Parsed in your browser — nothing is uploaded. Client-side.

Trace a site plan into a clean figure-ground: import a plan as a faint guide, paint the built mass with brush / rectangle / polygon, and read it as a figure-ground or a Nolli poché (with invert). Exports the diagram without the reference as vector SVG or PNG. Client-side.

Context for any image you find — related plans, drawings, photos + background, catalogued into a growing project library.

A research assistant that is checked before it is believed. Ask a question and FIND runs a grounded pass that returns findings — one checkable statement each, read on one page it opened, with the words on that page that say it. A link survives only if the run opened the page and the page still answers, and the server then looks for the quoted words on the page itself. VERIFY sends a second reader — a fresh pass that sees only the claims and their citations — to search on its own and confirm or contest each one; it cannot promote a finding without a page it opened to show. WRITE sets the findings out in the format you ask for — a research memo, an annotated bibliography, literature-review paragraphs, slide bullets, or a format you describe — citing only findings by number, with every number checked and every stray link stripped; reference lists in APA, Chicago or MLA, BibTeX and CSV are built from the citation fields for free. Every chip says what was checked, not what is true. Sign-in required.

The Landscape family fused into one live drawing tool, in three versions you switch between in-page. A real individual-based stand grows in continuous world coordinates — trees compete for light, die, and seed in — and its crowns ink themselves through Hatchling's mark grammar at whatever resolution the sheet asks, so the simulation and the drawing always line up (the reason to merge the two). v1 grows and draws itself (selection, not evolution); v2 adds an evolving ecosystem where seedlings inherit their parents' traits with mutation and lineages adapt over the decades; v3 makes it honest — an ensemble of futures drawn as an uncertainty band, per-stem kill odds, cited trait ranges, and hardiness-zone drift under warming, viewable top-down or as an oblique 2.5D stand. Author the ecology directly and scrub or loop the century. A stylized teaching model, not certified ecology. Its parents Wilding and Hatchling stay live as tabs alongside for comparison. Client-side.

A SETTLEMENT of eco-lounges, where Eco-Architect designs ONE building: a field of small gable lounges — every one a different proportion and a different relationship to the ground (bedded, grounded, lifted, perched) — linked into one walkable network by overlapping plinths and code-real stairs, growing in phases across a superfund site's measured terrain. Draw the remediation cap from the EPA record and the forces invert on it: bed into the earth where the ground is clean, touch it lightly where the cap IS the remedy. V6's walker negotiates every free lounge's proportions AND placement at once against measured field forces — mutual winter shading, borrowed summer shade, the cap, the links, variety — so the arrangement is an argument, never a scatter. Client-side, no account.

Grow a planting on ground you actually measured, with the base layer painted by the site's own water. Gardener asks you to brush the moisture on; here the landform hands it over — Surveyor's 3DEP surface comes across the site pipe, priority-flood and D8 flow routing find where the water collects and where it leaves, and a wetness index, a heat-load proxy read off the aspect and a deposition proxy sort the plot into eight habitat bands. Then an individual-based stand plays out over decades ON that painting: nobody places a plant, so willows end up in the swale and bur oak on the dry south shoulder because that is what the ground allows. Your Eco Lounges field loads in beside it — plinths mask the planting, and every lounge reads back the band it stands in, how much of its footprint is in the wet, how far it is from the nearest channel and how much canopy has closed over it. Draw it either way: a 2-D PLAN, north up, with shaded relief, contours at a stated interval and a scale bar — the drawing a studio actually works in — or the 3-D model, for the section through the stand a plan cannot show. Both are the same run and the same marks, literally: every habitat band carries a hatch drawn the way a landscape drawing chooses one — broken horizontals for marsh, a running diagonal for a channel, stipple for the dry shoulder, tight cross-hatch for a steep face — and because every hatch is specified in WORLD METRES rather than pixels, the sheet is composed once and the model WEARS it, so the marks run down the slopes they describe instead of floating in front of them. Every field says its own algorithm on hover. Landform hydrology, not a drainage study. Client-side, no account.

What your site used to be, from the federal record: scrub real 100-foot (30 m) Annual NLCD (USGS/MRLC, 1985–2025) backward on your own ground and watch the pixels flip class. With predict mode on (?predict=1) it first asks for your reconstruction of the ~1985 ground — the dominant cover, whether canopy and built surface were more or less than today, a confidence — and a confidence-weighted surprise score measures how wrong "normal" was. Honest limits: a 100-foot cell can't see a single tree or a narrow creek; the canopy comparison reads forest-class share, not a tree-canopy service; sites under ~1¼ acres (0.5 ha) abstain; conterminous US only; no pre-1985 aerials, no AI. Keyless — the loop runs for anyone; signing in saves the trace.

Design a planting the way the ground actually treats it — over decades, not on opening day. You can't place a plant: you set the site and seed mix, wager what the community assembles into (who dominates, when the canopy closes, who goes locally extinct), then an ensemble of possible futures reveals the gap between what you sowed and what the site grew. An in-browser individual-based succession model — honest ecological selection, not evolution. Client-side.

Draw the ground the way it actually changes — a plan that re-inks itself over decades. You don't ink the hatch: you author a grammar mapping ground condition to a mark family (stipple, flick, cross-hatch, shore ticks, a mycelium web), then soil, water, drought, roots and time redraw the sheet year over year. The drawing becomes a diagram of process — pioneer flush gives way to canopy cross-hatch, a drought thins the whole plate, the riparian band pulses — and you plot it out as clean SVG linework. Wilding's sibling in the represent register; the ground→mark map is a convention you author, not a truth. Client-side.

Design a landscape installation that carries water and birdsong to visitors who feel rather than hear — grown out of a Deaf student's thesis on tactile landscape sound. Skin reads vibration from about 1 Hz to 1 kHz (fingertips keenest near 250 Hz, whole body at 4–8 Hz), so a stream's low rumble can be felt at pitch while birdsong at 2–8 kHz must come down in whole octaves or arrive as rhythm. See the sources laid over the vibrotactile band, measure the real site with the mic, size a reed, plank, cable or membrane to the target frequency — then pluck-test the built element with an Arduino + accelerometer over Web Serial and read the frequency and damping it actually rings at. Client-side; nothing is uploaded.

Scrub a design from 2026 to 2126 and watch what a century actually costs it: the site's warming offset in Δ°F, and a carbon curve that climbs with every year of operations, bends as the grid decarbonizes, and steps each time the glazing or the roof is replaced — with the crossover year where the century overtakes the up-front spike. The assumptions driving all of it (conditioned hours, grid target, service lives) are yours to set and argue with. Each lane says out loud when its data runs out (solid = modeled, dashed = extrapolated). Reads the Work's saved Architect design, or runs the studio's default pavilion as a worked example. No AI calls.

Radical Accessibility Project — a non-visual / tactile CAD workflow that drives Rhino. The studio's research showcase.

Form-finding by site forces (sun, wind, terrain), with testable rules + a Rhino 8 round-trip, in six versions behind one door. V4 shapes the parametric gable; V5 tests any geometry (yours included) against the real site — fetched terrain, EPW sky-matrix radiation, the wind rose, occluded sun; V6 form-finds live, walking V4's own sliders uphill on weighted forces; V7 runs several named APPROACHES at once (sun-first, shelter-first, lean skin, bedded in…) against the same measurements, so you get the designs each one arrives at standing on one piece of ground, the trade-offs between them, every design re-scored under every approach, best-worst-case and least-compromise picks, and a written comparison you can pin up. V8 GROUND TRUTH stands the walker on REAL ground: the studio's five Superfund sites one click away (or a Surveyor survey consumed whole — landform, measured climate, flood zone, NPL identity), the terrain occluding the sun IN THE METRICS, today's climate beside the 2050 shift-only morph, the same design cross-read on all five grounds at once, and every adopted design a recorded step in a written trajectory you can export. Where Proving Ground V2 reads what a ground does to the design you brought, V8 searches for the gable this ground wants — and keeps the argument that got there. V9 PARALLAX turns the cross-read live: one brief, five walkers, five real landforms searching AT ONCE — the consensus panel says where every ground lands the same slider (the site family decided) and where they scatter (you decide), and the on-demand cross-read re-scores every ground's champion on every other ground to name the design you could defend anywhere and the one no ground resents. Every automated version searches inside buildability rules you set — roof clear of the ground, headroom, ridge height, roof covering the walls, walls landing on the plinth, a door that fits. The default face of the Architectural Designer group.

The vibecoded answer to Grasshopper, two ways on one page. v1 Code: describe a building form in plain language and Claude writes the parametric program that builds it — read the exact code it wrote. v2 Commands: key in Rhino-style commands — box 20 30 12, array column1 5 x 6 — that run instantly with no AI call, or let Claude turn plain English into the same commands. One in-page v1|v2 toggle, one engine underneath: sliders re-run live, an optimizer explores trade-offs, and you export a real Rhino .3dm. Sign-in required.

WHAT THIS IS. Proving Ground is a massing bench: a quick test rig for early design. Build a simple building out of a few boxes — a plinth, a room, a roof, some openings — or import one from Rhino, and it shows you, live, what the sun, the wind, the thermal mass, the view, the ground and the embodied carbon are doing to it. It is for choosing BETWEEN schemes: a taller ridge or a lower one, glass south or east, the plinth cut into the slope or sitting on it. WHAT IT IS NOT. Not an energy model, a climate-based daylight study, a CFD study or a permit drawing, and none of its numbers is certified. It treats the building as ONE room of air with one fixed wall build-up and no heating or cooling equipment, and its one daylight (light-level) metric is V7's Daylight box — the daylight factor on the floor under an overcast sky, a screen, not a study (Daylighter is the study). Most numbers are the hand methods an engineer would do on paper, run instantly on a simple model. WHAT'S REAL — data from outside, once you bring it. THE GROUND: in V6 and V7, USGS 3DEP elevation (the U.S. Geological Survey's 3D Elevation Program, measured by lidar and survey), one height about every 26 ft (8 m). V1, V2 and V5 use coarser terrain tiles (made from 3DEP in the US) unless a Surveyor survey is synced, and so does any site outside the US. THE WEATHER: a studio site, a searched place or a saved coordinate brings 2023 from ERA5, a weather model fitted to observations on a grid about 15 miles (25 km) wide — MODELLED, not measured at your site. An .epw you drop is usually a “typical year” built from one weather station's records. PUBLISHED TABLES: CIBSE Guide A for the materials, ICE v4.0 for the carbon factors. The aerial photo is a picture only. WHAT'S CALCULATED — every number, in your browser. Sun angles come from standard formulas, and rays fired at your model make it shade itself (and the loaded ground shade it). Ventilation uses BS 5925, the British Standard hand method; in V6 and V7 the Air layer adds EnergyPlus's airflow-network method and, when you ask, a coarse CFD (computational fluid dynamics) run of the wind. Mass and energy are stated hand methods; views are exact angles from your windows, and carbon is quantities × published factors. Each reading is tagged STANDARD METHOD (the calculation a professional tool runs, on your simplified model), SCREENING ESTIMATE (right physics, simplified: for comparing schemes) or CLASSROOM PROXY (trust the direction, not the number). Hover or tab to any figure for its method. WHAT'S ASSUMED — until you change it. Before you load a place there is NO REAL SITE: flat ground at 42° N, 71° W (southeastern Massachusetts), a 32 °F (0 °C) average winter day, an 82 °F (28 °C) average summer day, an 18 °F (10 °C) day–night swing and an 11 mph (5 m/s) west wind — all placeholders, and the verdicts say so. Always assumed: one wood-frame wall and roof with double glazing (unless the Detailer sends yours), a concrete slab, 0.3 air changes an hour of leakage, each opening open as far as its sash type allows (the whole pane until you pick one), the room 11 °F (6 °C) warmer than outside for the scores (a dial — in V7, switch the air drawn in the model to follow the date instead: the weather year's outside air at that day and hour, and the room held at ASHRAE 55's comfort temperature, heated to 68 °F (20 °C) when the month before averaged under 50 °F (10 °C)), 1.3 Btu/h·ft² (4 W/m²) of heat from people and equipment, and a cloudless sky for the seasonal sun numbers. TRUST THE COMPARISON, NOT THE ABSOLUTE. Scheme A against scheme B on the same site is what this answers. A number you must defend to an engineer, a client or a code official comes from a professional tool — EnergyPlus, Radiance, Ladybug/Honeybee, ClimateStudio, a CFD package, an LCA tool. The “Vs. pro tools” tab says which one, force by force, and when to switch. HOW TO START IN V7 (ARCH 273). You open on the 4 Rectangles jig: plinth, room and roof on three chained points, plus the fourth rectangle, the FOCUS (a table or a seating pit). Drag the sliders on the left. In V7 the Ridge governs switch is on, so the ridge heights have the last word: a low, steep roof can push its eave down into the walls, and a warning box on the model names what broke. Give it a site under The ground: a studio site, or Load coordinate (signed in) for a pin you saved in the Surveyor. Read the VERDICTS under the model: ▲ warning — working against your design, look here first · ● note — worth a look · ✓ good — working, on this tool's stated method. They rank moves; they do not certify performance. On the right, Site forces → “What each reading is good for” says how far to trust each number. Save this study, change one thing, save again, compare; export a Rhino .3dm, an STL or a scaled PNG. The “How to use” tab has the rest; if an assignment link sent you, ignore the other six versions.

ARRANGE NINE. Take one of your Proving Ground studies (or the V7 4 Rectangles default) and copy it nine times across the real ground of your site — any of the five studio Superfund sites (a chat pile at Tar Creek by default; the pit rim at Butte, the Solvay waste beds at Onondaga, the slag terrace in Pueblo, the cinder bank at Palmerton) or any coordinate you paste or saved in the Surveyor, then walk the box across it on the key map. Then cycle through the organizations: fifteen GENERATORS that re-solve for any count, module, study and ground — the nine on the assignment sheet (grid, staggered grid, linear, axial, centralized, radial, cluster, contour, chain) and six fields from the textures sheet (twigs, striated, field vectors, patchwork, collision, open field) — plus every organization on every “Nine ways to arrange” sheet, loaded as drawn — and the thirty that read the ground fitted to yours: drag the centre and they re-fit. Each is explained, the sheets themselves are in the How to use tab, and every organization can be seen at once on your ground in the All organizations view. Every organization opens turned and drifted out of symmetry; Drift and its seed are dials. Drag any lounge to place it by hand. Then switch on the ORDERING GRID — a grid or a staggered grid at any angle, with bays in feet — and pull every lounge toward its own node by as much or as little as you like, so intuition, the land and an ordered dimension meet in one plan. Turn each lounge by the organization, the grid, the contour, the fall line, or exactly as it was tested in Proving Ground; seat each plinth lifted, balanced or bedded, and read what the arrangement asks of the ground: the fall under every plinth, cut and fill, gaps and overlaps, how far each copy is turned from the orientation its sun and wind readings were taken at. Plan, 3D, a SECTION through the village (set the line's direction and position; the earth hatched, the lounges it cuts solid, what stands beyond in elevation) and the four ELEVATIONS, in one, three or four viewports as in Proving Ground, and WALK the village at eye level (5′-6″ over the ground, stopped by the lounges' walls) — the 3D drawn in Proving Ground's Shaded, Solar, Pen or Rendered look, on a ground of any colour — and Proving Ground's Water layer on the whole village: a design storm routed over the pile with every plinth in its way and every roof shedding at its eaves, the hollows that fill, where it leaves and the swale to carry it, in plan and 3D; Proving Ground's per-lounge sun, air and ground readings with every neighbour and the pile shading each; the Solar look and the daylight factor on every floor; the wind between the lounges — Proving Ground's Air layer on the sealed village, streamlines moving at the air's speed over a speed plane draped 5 ft over the ground — and the two-winds study, January's and July's wind at pedestrian height as a ratio to the empty site; every organization read side by side; and the hours each lounge sits downwind of the high ground (the pile); export the village on its ground to Rhino (surfaces or mesh), a watertight STL, the plan as SVG, the readings as CSV and a nine-plate sun study of the 3D view (the equinox and both solstices, morning, noon and afternoon). Save this study keeps an arrangement — with its view and look — in the Studies box, Proving Ground's own filmstrip, to step through and compare. Or WRITE YOUR OWN RULE: say your organizing principle in words and the AI writes it as a short program you can read and change, which then arranges the village like any organization. Everything but asking the AI is client-side and works without an account. TWO VERSIONS (the Version strip under the header, or /ensemble?v=2): V1 ARRANGE is all of the above; V2 LIVING GROUND grows a woody planting across the same village — many futures at once, every one planting the same trees, each with its own luck and drought years — on the village's own water (the landform's wetness, each roof shedding at its eave), sun (cast past the lounges and the pile) and wind (the Air layer between the lounges), and draws each planted tree's survival odds as how broken its ring is, volunteers as stipple and drought deaths as fading scars.

A hundred versions of your massing, all scored the same way. Hand Swarm a parametric model from Proving Ground or Conjure ("Explore in Swarm →"), pick which sliders are free, and it samples the space (or searches it with NSGA-II — the same engine Proving Ground runs), scoring every variant live against the same metric registry Scoreboard's columns use: same ids, same units, same stated blind spots. The parallel-coordinates plot draws the whole cloud with the non-dominated front picked out; brush an axis to filter, click any line to rebuild that variant in 3D, send a keeper to Scoreboard. The machine ranks; it never chooses. Client-side, no account.

Wrap a skeleton in skin: place point charges, draw polyline charges, or import a model (OBJ/STL/3DM) — each element radiates a metaball field with its own strength and radius, the fields sum, and marching cubes skins a mesh wherever the total crosses your iso value. Lower the iso to fuse charges into one body, carve voids with negative strength, mirror-sculpt both halves at once, array a charge along a line or around an axis — or import an SVG drawing and print the raised linework as a tactile drawing. Exports OBJ/STL/native .3dm and saves setups as JSON. Client-side.

V1 studies the proportions of a barn with every dimension on a slider — length, width, wall height, bays, joist + truss spacing, a 2nd floor, ridge height and its offset from centre, the two roof slopes, and overhangs on all four sides — with live drawings and an honest material readout (areas, volume, framing lineal feet, 4'×8' sheets with their waste). V2 runs the whole project: the same barn, with doors, on Proving Ground V7's bench (every force, the site, the year); a structural pre-check of every framing member (ASCE 7-16 loads, NDS 2018 lumber) shown as a 3D framing model with the undersized members in rust, sizes fixed one by one or all at once, and a report for the engineer; drawings — plan, section, elevations, an axonometric, the framing sheets — with your own notes, out as DXF, SVG and a PDF set; a takeoff priced line by line as a live spreadsheet; bid packages issued as frozen revisions and sent as RFQ documents; and the quotes that come back leveled against the estimate and each other; and a GREENHOUSE end (a new project opens half greenhouse, half barn) — glazed bays with ridge vents, a fan, a night curtain and a partition, simulated hour by hour through a weather year for the temperature inside and the heat (and fuel, and dollars) it takes to hold a setpoint all winter. Client-side — except the Foreman, an AI assistant that edits the barn in plain language: it proposes field edits, the browser shows the engine's before → after, and nothing changes until you apply it.

Learn how a truss carries load — 14 classic types (Pratt, Warren, Howe, K, lattice, Belfast, Fink, Bollman, Whipple, Baltimore, Vierendeel…), a custom truss you shape by dragging its chords, or a double-layer space frame solved in full 3D. Live pin-jointed forces: compression blue, tension red, a point load you slide along the deck, deflected shapes, reactions and a static-determinacy count. Export OBJ for Rhino or forces as CSV. Client-side.

Where Truss teaches with a dimensionless pin-jointed solve, Armature answers like the professional tool it imitates (Karamba3D): 16 parametric structures — beams, portal/gable/multi-storey/three-hinge frames, Warren/Pratt/Howe/bowstring trusses, timber king-post/Fink/scissor roofs, a Vierendeel, an arch, an underslung trussed beam — or a frame you draw yourself (or import: Rhino OBJ line models, Relax nets), with real materials and real catalog cross-sections, loaded in kN with self-weight from the sections themselves. Read utilization coloring with a Euler buckling check, moment/shear/axial diagrams, deflections in true millimetres — then let the optimizer size every group to the lightest adequate section, Karamba's signature move. When a model can't stand, the mechanism ADVISOR draws the zero-energy motion and suggests — with one-click fixes — the member, support or rigid joint that stands it up. Client-side.

A round barn is not a frame, it is a SOLID OF REVOLUTION, and two facts follow that a plane-frame tool gets wrong: a rafter's tributary wedge grows with radius (its load is triangular, never uniform), and the plates are RINGS — the eave plate works in tension, the curb at the peak in compression, and that hoop is the whole reason a round barn's mow has no post in it. Rotunda models one radial rib — the section Wilber Fraser drew for the Illinois experiment station in 1910 — and solves it with ARMATURE'S OWN engine, imported not copied, then adds the axisymmetry: wedge loading, ring stiffness as a real elastic restraint (hoop T = P/2sin(π/n), and the ring grows by T·r/EA), and a switch that lets the sprung roof boards work as a hoop so you can watch the load path turn from basket into shell. Set the barn on sliders — diameter, wall, gambrel / conical / gothic rib, ribs, silo, curb — lay out Fraser's rings from silo to litter alley and read the cows off the stanchion circle, load it with snow, roof dead and hay that tapers as the mow narrows, then size every stick to the lightest adequate lumber. Three drawings off one solve: section, plan, and the whole barn as ribs and rings. Built from the WHOLE bulletin, not just its section drawing: a 9-ft cow storey under 20-ft studs with the plate 29 ft up, 64 framed rafters doubled below the break, joists on a post ring at the stanchions, the silo running through the peak as a mast, studs hooped every 5 ft, and the bill priced in Fraser's own 1910 money against the $799.76 he charged. Client-side.

Build a mass out of boxes and cylinders booleaned together — two boxes, a silo through a block, a courtyard punched out — and Stick frames it the way an American crew would. Storeys fall out of the LUMBER rather than a round number: a storey is exactly its plates plus its stud plus the floor platform over it, so changing to a 9-foot wall really does change how many floors fit in the volume. Each storey's plan is a slice of the mass, so a cylinder grows a curved wall of straight studs and a solid that stops at twelve feet stops having walls there — and where two solids meet flush the shared wall is NOT framed twice. Then the ordinary rules, every one of them a parameter: plates single or doubled, studs on the 12/16/19.2/24 module, a corner post that belongs to one wall so a closed loop gets one per corner, rough openings with king studs, jacks, a header sized off the span, cripples and a doubled sill; floor joists clipped to the plan that GROW A GIRDER and posts under it the moment the span beats the table; rim joists, blocking, subfloor; and a gable, shed, flat or open roof with ridge, commons, ceiling joists, collar ties and gable studs. Read the takeoff beside it — pieces, board feet, sheets, pounds and dollars — and export the OBJ (inches, one box per stick), the cut list and takeoff as CSV, and a true-scale framing plan as SVG. And it takes PROVING GROUND’S OWN STUDIES: Sync → “Frame it in Stick” hands the massing across as the boxes, drums and extruded plans it was authored from — not a bounding box — so the scheme you just tested against sun, wind and carbon can be priced in sticks; anything unframable (a sphere, a tilt, an imported mesh with no primitives left) is refused out loud rather than guessed. And the framing is only the default TECTONIC SYSTEM of six: switch the same mass to balloon framing (continuous studs, a ribbon at every floor, fire blocking), a heavy timber frame (bents, girts, mitred knee braces, purlins on a ridge beam), cross-laminated timber panels, cast-in-place concrete with strip footings, or coursed CMU blocks counted one by one — each with its own parameters and its own takeoff (cubic yards and formwork, block and mortar counts, a panel schedule). Client-side, nothing uploaded.

A full Kangaroo-style form-finder: build your own force system from a deck of 24 composable goals — anchors, springs, bending, hinges, gravity, wind, pressure, soap film, planarization, on-geometry constraints, collisions, target volume — each with its own selection and strength, negotiated by weighted projection. Ten presets are saved goal stacks: hang a catenary and invert it for a compression vault (Gaudí), soap-film a boundary (Frei Otto), fair, inflate, tent, drape, pack, planarize, arch, pillow. Import a .3dm / .obj as the net or as a drape target, export OBJ. Client-side.

Rationalize a doubly-curved surface into panels you could actually pay for — TWO WAYS, both priced on every run. FORCE IT FLAT: planarize the quads by weighted projection on Relax's own kernel, classify every panel FLAT / COLD-BENDABLE / HOT-BENT against a tolerance you set, unroll developable strips with their closing error, and count UNIQUE PANEL TYPES by rigid congruence. Or LET IT CURVE: fit each panel's own mould surface, drop it onto the cheapest rung of the panel-type ladder that holds it — PLANAR, SINGLE-CURVED, SPHERICAL, DOUBLE-CURVED, FREEFORM — and count UNIQUE MOULDS instead, because a spherical mould of radius R serves every panel of radius R whatever its outline. The dome is the lesson: 108 unique panel types forced flat, ONE mould allowed to curve. Start from a built-in saddle/dome/torus/twisted-tower/roof/cone surface or import a quad mesh (Relax's OBJ, an OBJ, a Rhino .3dm mesh). A repetition slider trades panel types against how far the surface moved to buy them. Exports a panel schedule and a mould schedule as CSV, plus mm-true nested cut sheets for Fabricator. Client-side.

Give it a model — a Rhino .3dm, an OBJ, an STL — and it takes the building apart. Every discrete piece is FOUND (coincident vertices welded, connected components separated, so one joined layer of 240 rafters becomes 240 rafters), MEASURED, and matched against every other piece by rigid congruence rather than by name, so the schedule says how many pieces are genuinely DIFFERENT. Then one slider runs the whole drawing: ASSEMBLED → EXPLODED (outward in plan, outward in space, straight up, or a layer cake by assembly) → LAID FLAT, where every piece turns onto its thinnest face, spins until its footprint is the smallest rectangle that holds it, and nests onto one plate banded by part type. The demo is Barn Jig's round dairy barn — Fraser's 1910 Illinois 60-footer, solved by Barn Jig's own solver so the two tools can never hold two readings of Fig. 19, and piped straight across with “Take it apart →”. Parts frames what the jig proportions: a self-supporting spider-web roof (radial rafters, concentric ring purlins, X-braced bays, and the laminated CIRCULAR PURLIN PLATE that is the whole structural idea), a mow floor on a girder ring over the stable, siding and sheathing on every facet, and a stave silo standing as a mast through the peak. About 2,400 pieces, around sixty drawings — and dropping the stud lines per facet shows what faceting a round building costs in part types. Exports the part schedule and part list as CSV, the arrangement on screen as OBJ or Rhino .3dm (one layer per assembly), and the plate as mm-true SVG. Client-side — the model never leaves your browser.

Enter a floor-to-floor height and it sizes the risers and treads, builds the flight (straight / L / U / switchback with landings) in 3D, checks it against the rules (riser, going, 2R+G, headroom, ramp slope), and exports an OBJ plus a dimensioned SVG plan & section. Client-side.

Four measurements you can take with a tape, a phone and a stopwatch, in a building that was never designed to be climbed around. SQUEEZE: will a body pass that hole, in which of seven postures, with how much clearance — head-first, on its belly, turned sideways — read against the code's own minimum openings, and how long your group takes to get through it. CHUTE: a slide as a block on an inclined plane — exit speed, time down, the flat run-out it would take to stop, the sideways load in a curve — and the field exercise that matters, SOLVING the real coefficient of friction backwards from a timed ride. MEMBER: a found bar, pipe, tube or plank checked for bending and deflection off its measured section, with the load at which each check runs out, and a standing note that the member is never what fails. CLIMB: rise against going gives a pitch, a pitch gives a name — stair, ship's ladder, fixed ladder, free climb — and the body's own knee, hip and reach say who in your group can make the move. Every reading drops into a FIELD LOG that exports as CSV or a printable field sheet. Client-side: no account, no upload, works on a phone with no signal.

Build a wall, roof or floor the way it's actually made — layer by layer, exterior to interior finish — and let the drawing carry the data that guides iteration. The hatched section (drawn flat for roofs and floors) redraws live over aligned temperature and vapor-pressure charts: a dew-point (Glaser) pass names the plane where winter condensation would land, effective R/U uses the kind-correct ASHRAE films (heat flowing up, down and sideways differ) and includes what the studs really cost, and weight, installed cost and embodied carbon — pinned to the platform's shared ICE factors — read out beside them. Thirteen presets each teach a lesson (vented attic vs compact roof, the sweating slab); a thermal-bridge gallery covers what a 1-D stack can't see. Send the solved assembly to Proving Ground and the massing's energy balance and wall/roof carbon read YOUR construction instead of the fixed stand-in. Client-side.

The classic studio exercise made parametric: rule three edge-to-edge lines on a 3.5×2.5″ card, cut two end segments, dial every remaining segment to an exact mountain or valley angle — a paper simulator folds the module live, distorting the sheet near over-constrained intersections just like forced cardstock — then stack the same module into a standing N×M screen wall with rotate/mirror patterns, overlap and stagger. Prints a true-scale SVG cut sheet; saves/loads designs as JSON. Client-side.

Build a hanging mobile the way Alexander Calder did — a tree of arms, each balancing a plate against everything below it — and the physics answers back: an arm floats level only when its two loads have equal moments (load × distance from the pivot), otherwise the heavy end swings straight down. Drag masses, arm lengths and pivots, auto-balance any arm to its centre of mass, watch it sway, and export SVG/PNG. Client-side.

One model in, three fabrication strategies out. Load a parametric form or your own STL/OBJ/PLY/.3dm ONCE, then switch strategy: interlocking waffle ribs or stacked contour layers (both exporting millimetre-true SVG cut sheets — the exact engines from the legacy tabs), or Print prep — honest 3D-print sanity checks: bed fit + scale-to-fit, least-support orientation, overhang flags, and rough time/material estimates that say how they're made. Client-side, nothing uploaded.

Turn a surface or your own model into an interlocking egg-crate of ribs — notched half-depth where they cross so they slot together. Pick a parametric form or drop in an STL/OBJ/PLY (it's raycast into a heightfield and waffled), set rib counts, material thickness and kerf, then export a true-millimetre nested SVG cut sheet for the laser, with parts labelled for assembly. Client-side, nothing uploaded.

Slice a terrain or form into horizontal contour layers — a topographic model from stacked chipboard. Choose your sheet thickness and it traces each level (marching squares), nests the numbered layers onto a millimetre-true SVG cut sheet with the next layer scored on top for foolproof stacking, and gives you a flat contour map too. Pairs with the Topography Builder; drop in your own model to slice it. Client-side.

Cut a chunk of the Surveyor's measured 3-D ground and fabricate a physical site model of it at a stated scale — a 27″ × 27″ base at 1″ = 100′ covers 2,700 ft of real terrain, and comes apart into pieces sized to your printer's own square (a Bambu P1S prints 205 mm, so that model lands as sixteen 6.75″ chunks you can see, name and pull apart in the viewport before gluing). The place comes with it: OpenStreetMap roads, rivers, lakes and building footprints ride across on the Surveyor's hand-off and are cut into the ground — roads bumped out or pressed in, water grooved, buildings unioned in as massing — so the model reads as somewhere, not just a landform. Four fabrications from the one chunk: watertight thin-shell tiles sized to your printer bed (STL), an interlocking waffle grid — laser-cut to cover with fabric (DXF) or printed assembled (STL) — a stacked-slab contour model with the next layer scored on each for registration (DXF), and the top surface developed flat into fold-scored paper strips (DXF). The preview is a model you can read: shaded under a settable sun with cast shadows, mesh edges inked on, contours draped at your interval. Export the same ground FULL SIZE as a Rhino .3dm — the measured survey with no model conventions cut into it, the mapped buildings standing on it as editable solids (Extrusions or closed meshes, your pick) and the roads and water draped alongside as curves — to keep designing on. Runs on a demo landform without a survey. Client-side, nothing uploaded.

Turn a phone LiDAR scan of a real place into a printable site portrait — entirely in your browser, with every step spoken. Import a GLB / PLY / OBJ / STL / 3DM scan and hear the mesh report (spans, holes, ground plane, resolution — the blind maker's viewfinder); then condition it: level the floor, scale it by a measurement you taped on site — never the file's own claim, and the disagreement is spoken — crop to a typed window in feet or keep the largest connected piece (every crop reports the percentage removed), and place it with typed offsets and a rotation. Then the handoff: the conditioned scan rasterizes to a heightfield at an imperial model scale and rides Relief's fabrication machinery out as watertight printer-bed STL chunks named like map squares (A1 is the north-west corner), zipped with the scan's caveats and an assembly map, plus the same ground full size as a Rhino .3dm in feet with contours. The honest limit is stated and measured, never hidden: a heightfield keeps the top surface, so canopies flatten — and the tool says which regions lost how much undercut. Client-side; nothing uploads, no sign-in.

A 3D-printed jig for building wire models by touch: a flat plate with a hole for rebar tie wire every 1/8 or 1/4 in — on a square grid, a polar grid of rings and spokes, or both on one plate for a round barn on a square site, the two grids sharing the plate under one rule (no wall between holes thinner than you allow, rings near the centre thinned to the spokes that fit). Braille rulers run along the bottom and left edges — a raised tick at every hole, a longer tick and a UEB numeral at every inch — with a raised triangle in the origin corner so the plate can never be turned the wrong way; a disc plate carries Braille degrees around its rim instead. Raised inch lines cross the field, or half-round wire CHANNELS between the holes — a pipe of the hole's width cut half a wire deep — so a wire laid flat sits in a round bed and stays on its line. The polar zone's diameter and centre are yours: put a round barn on the corner of its site and the rings run off the edge while the square grid takes the rest. Every dimension is a control; every setting is spoken back — the grids, the hole count, the thinnest wall, the scale, what prints. Exports a watertight STL built and checked by the Manifold kernel (one piece, or cut between the holes to your printer's bed), a Rhino .3dm whose plate arrives with its holes already cut (one Extrusion with round inner profiles; with grooves on, the kernel-cut mesh plus a hidden NURBS set and a RhinoPython cut script) or the print mesh, a fit coupon to size the holes to your wire, and the read-back as a .brf. Client-side; nothing uploads, no sign-in.

Custom scale figures to 3D-print for your models. Pose one from a preset (standing, walking, sitting, waving, pointing, arms folded, on the phone, in a wheelchair), from a photo of yourself — a pose model runs in this browser, the photo never uploads and its face is never kept — or from a phone 3D scan (GLB, OBJ, PLY, STL, 3DM). Then pose it by hand: turn a joint's dials, or switch on Drag joints and drag a hand, elbow, foot, knee or the head right on the figure. Pick an age for a child's proportions (a bigger head and shorter legs, from growth charts), and seat a sitting figure on a block or in a wheelchair fitted to it. Or make a crowd: up to 24 different people, heights drawn from the CDC growth charts, laid out on one plate that fits a Bambu bed. Every figure is built for YOUR printer — any limb thinner than the nozzle can hold at that scale is thickened to it, and the read-back names which — and a mesh reducer takes it low-poly without cutting below printable. The Manifold kernel checks each figure is one closed solid; export the watertight STL at the model scale, or a Rhino .3dm full size as editable surfaces or the print mesh. Client-side; nothing uploads, no sign-in.

Gaffer × Vantage in one instrument: photograph Gaffer's path-traced studio through a real camera. Open the aperture and the picture brightens AS the depth of field collapses; pay for a small stop with a slower shutter or with ISO grain — the exposure triangle read against a live meter of the light your rig actually delivers. Plus everything Vantage teaches, on a lit set: sensor formats, the dolly-zoom subject lock, camera tilt vs lens shift for straight verticals with a draughtsman overlay, and a plan + section rig that shades the in-focus band around draggable lights. Client-side.

See how a camera makes an image. Change the lens and watch the field of view and perspective shift (with a dolly-zoom that proves perspective comes from distance, not focal length); open the aperture to throw the background out of focus; and use tilt vs. lens-shift to keep a building's verticals straight — with a live plan diagram, a draughtsman overlay (horizon + vanishing points) and the real numbers.

Light a studio the way a gaffer does: drag softboxes, strips, octas, bulbs and spots in a plan and a section — with bounce cards, flags, scrims and a seamless sweep — and a live path-traced render shows the photograph: true soft shadows, inverse-square falloff, bounce cards that really bounce. Five classic setups (three-point, Rembrandt, butterfly, high-key, low-key) with teaching captions, per-light stops-vs-key readouts, a solo button, gels and white balance. Vantage's sibling: that one is the camera, this one is the light. Client-side.

One model, every way of drawing it. Import a model (GLB/GLTF/STL/OBJ/PLY/3DM Rhino) and pick anywhere in the taxonomy of graphical projections: MULTIVIEW (plan, elevation, and true first- and third-angle sheets — four panes at one scale, mirrored cells), AXONOMETRIC (isometric, dimetric 1:1:½, trimetric, or free orbit), OBLIQUE (cavalier, cabinet, military — with the receding angle, depth ratio, direction and plan roll all live), or PERSPECTIVE (1-, 2-, 3-point and a real curvilinear fisheye, rendered through a cube map so straight edges genuinely bend). Every type carries a description and names the algorithm behind it, and a live read-out measures the view you are actually looking at — foreshortening as you orbit, vanishing points as you tilt. Draw it in a display mode off the Inker's shelf. Exports a PNG and a Rhino Python script that rebuilds the same projection in your own model. Client-side, nothing uploaded.

Quick board and page layout — the stand-in for the InDesign workflow while you wait on a license (or just want something faster). Pick a sheet size (ARCH / ANSI / ISO / custom) and export resolution, then lay out formatted text blocks, images and shapes across MULTIPLE artboards with margins, snapping and a grid. Export any board as a PNG at your chosen DPI, or every artboard as one multi-page PDF that prints true to size. Autosaves in your browser; documents travel as JSON. Client-side — nothing is uploaded.

The numbered cartoon strip, made honestly. Build a massing as an ordered list of MOVES — extrude, stack, carve, shift, split, terrace, taper, twist — and every move becomes a frame, drawn in one shared orthographic projection at one shared scale so nothing shifts between frames except the thing you did. Arrows are generated from the transform itself (a straight arrow from a translation, an arc from a rotation, a dashed ghost from a subtraction), captions are yours to write, and optional before/after ghosting shows what moved. Reorder the moves and the whole strip redraws — which is the lesson: if any order works, you have a list, not an argument. Exports a board-ready SVG strip. Client-side, no account.

Turn a model into a DRAWING, not a screenshot. Set a camera and Scribe works out what you can actually see — visible edges, hidden edges as real dashed geometry, silhouettes — and writes an SVG in named layers that opens clean in Illustrator, sized in true millimetres. Lineweight is graded by depth automatically: near edges heavy, far edges hair, which is the hours-in-Illustrator job this deletes. Section-perspective mode puts the camera on the cut plane for the drawing that is measurable and atmospheric at once. Visibility is ray-cast against the model, so an edge is hidden because something is genuinely in front of it. Client-side; the model never leaves your machine.

Lay out a big perspective sheet — 36″ × 36″ by default — from SEVERAL rigorous perspectives rather than one. Every view is a real construction with its own station point, picture surface and drawing scale, cut to its own frame and drawn from your model by Scribe's hidden-line engine. The picture surface can be a flat plane, a CYLINDER or a SPHERE — panoramas up to a full turn, unrolled at scale — and a frame can be a rectangle, an ellipse, an arch or a diamond, pasted over the views beneath as a collage (covered strokes are cut away, not painted over), beside a plan panel that draws every station and picture plane at scale. Two layout engines work independently: ARRANGE cuts the sheet into a grid, columns, rows, a hero with a band or a cascade, keeping each view's angle of view; PLACE STATIONS walks the eyes along a line, round an orbit, fanned from one point so the edge rays meet exactly, or over a grid — aimed down the path, at a target or at one bearing. The construction reads live off every view: horizon, vanishing and measuring points, the 60° cone, ground line, true-height ruler, a bearing scale on a panorama. Exports one true-size layered SVG and every station as a Rhino named view. Client-side; nothing uploaded.

A perspective grid to draw over, laid out on a real sheet — Letter to ARCH E, the 36″ square, an iPad screen — and built as a real construction rather than a decorative fan of lines. Pick the system: ONE-POINT (the room you face, its back wall on the picture plane), TWO-POINT (the corner you turn), THREE-POINT (the camera tilts), FOUR-POINT (a 360° cylinder unrolled, four points on the horizon) or FIVE-POINT (the hemisphere, every straight line a compass arc). Set the eye height, the viewing distance, the architect's scale that is true on the picture plane, the grid's turn and the pitch, and a measured room or corner is projected onto the sheet with its horizon, ground line, vanishing points, measuring points, distance points, the 60° cone of vision and the construction that proves them — the station point folded down on its semicircle, the swing to the measuring points, the true-height line. Drag any point and the camera is solved back from it (the CV is the orthocentre in three-point). Every point says how it was found on hover; a lesson beside the sheet says what the system is, what to check and where it breaks. Exports a true-size PDF to print under trace, a layered SVG for Illustrator, and a transparent PNG to drop into Morpholio Trace or Procreate as an underlay. Client-side; nothing uploaded.

Compose the view as a collage instead of faking a photoreal render. Import images and cut them out with polygon scissors (hard edges by design, or a torn edge), lay flat colour fields from a curated post-digital palette, set type in Archivo Black, and stack it all as layers with blend modes and honest print-shop filters — halftone, grain, posterize, tint. Then set a horizon and an eye height and the board starts doing the perspective for you: anything standing on the ground scales itself correctly with depth, and every shadow comes from one shared sun, so moving the sun swings all of them together. Runs entirely in your browser — images are never uploaded.

Solve the camera that took a site photograph. Drag two bundles of parallel edges onto the photo, mark one known height, and Photomatch recovers the focal length, the orientation and the eye height — so your model can be drawn through that photograph's exact camera instead of eyeballed into it. Rectify mode does the reverse: drag the four corners of a façade and get a flat, measurable elevation you can trace. When the geometry cannot support a solve it says which bundle is the problem and why, rather than returning a confident wrong answer.

Stop-motion animation the way Terry Gilliam made it for Monty Python: paper cutouts hinged with a movable pivot like a brass fastener, posed on a stage, captured one held frame at a time. Import scans or PNGs (or paste from the clipboard), scissor a jaw or an arm out of any piece with a torn edge, drag the hinge to where the joint really is, and pose-capture-nudge-capture with onion-skin ghosts of the frames before. Playback runs at a low, honest frame rate — no tweening anywhere, because the jump between held poses is the medium. Export a looping GIF, a numbered frame contact sheet, a still, or the whole document as JSON.

Build a palette and learn why it works, in the colour spaces vision science actually uses. Everything is computed in OKLCh — so "the same lightness" really is the same lightness — and the tool shows you what HSL was getting wrong by generating the same scheme both ways side by side. Orbit the sRGB gamut as a true 3D solid and morph it between OKLab, CIELAB, HSL and the raw RGB cube: HSL is a perfect cylinder, the real thing is a lopsided lump, and the lump is why there is no such colour as a pale vivid blue. Ask for the opposite of a colour and get all four honest answers — additive, afterimage, perceptually even, and Itten's artist's wheel — with the basis of each named, because that argument is really about which system you are standing in. Then audit the palette: WCAG 2.1 and APCA contrast side by side with the disagreements called out, colourblind simulation as the cone-loss projection it actually is, and a photocopy test for members that differ by hue alone. Every colour gets a plain-English ISCC-NBS name, which is how you find out that brown is dark orange and olive is dark yellow. Runs entirely in your browser.

Screen any image into a halftone, two-colour duotone, or full Risograph-style spot-colour separation — for plates, zines, posters and graphic poché. Adjustable dot shape, ruling and screen angle, real Riso inks, mis-registration and grain, over any paper colour. Export a finished PNG, per-ink plate masters for an actual Risograph, or vector SVG dots for print / plotter / laser. Client-side.

Trace a raster into crisp, editable vectors — two modes. Outline gives stroked line work (centreline down the middle of each stroke, for a Make2D dump or sketch, or a stroked contour); Fill gives solid shapes (one colour, or a posterised colour separation). Tune with pre-blur, global / adaptive threshold, morphological cleanup, simplify & smooth, then export SVG for Illustrator or DXF (real millimetres) for CAD and laser. Client-side.

Generate a parametric screen / facade / tiling: a grid of cells whose size and rotation are driven by an attractor you drag. Choose the cell shape and the grid (square / brick / hex), tune the field, then export SVG, PNG, or DXF with real millimetre coordinates — straight into Rhino / AutoCAD or a laser cutter. Client-side.

A library of real architectural hatch and poché patterns — concrete, brick, CMU, stone, earth, gravel, sand, wood, insulation, steel — as SVG fills you can scale true to your drawing scale, set the pen weight and rotation, then export as SVG (sized in mm), PNG, or copy the SVG <pattern> to reuse anywhere. Client-side.

Make a correct graphic scale bar and a north arrow for a sheet: pick a scale (metric ratio or imperial architect's scale), set length + divisions, choose a north-arrow style, and export an SVG sized in real millimetres (prints true at 100%) or a PNG.

Read a facade or plan against the classical proportioning systems: overlay the golden section + spiral, √2/√3/√5 root rectangles, rule of thirds, Fibonacci, Modulor bands, a tatami/ken grid, regulating lines and symmetry axes on an image or a draggable frame, with a live ratio readout. Export PNG or SVG. Client-side.

Drop scalable black silhouettes — people, trees (plan + elevation), cars, bikes, furniture and plan symbols — into a composition at true scale (with a 1.7 m reference figure), drag/resize/flip them, and export a transparent SVG or PNG to layer over a drawing or collage. Client-side.

Drop or paste a plan image, click two points on a known dimension to set the scale (or pick a named architect's/metric scale + DPI), then measure lengths, running paths, room areas, rectangles, angles and counts straight on the drawing — read out in feet-inches with metric alongside. Recalibrating re-scales every measurement at once. Exports CSV, JSON and an annotated PNG. Client-side; nothing is uploaded.

Where should I stand? Import your work-in-progress model, drop cameras in plan, and see the 60° cone of vision drawn where you put each one — so going fisheye is visible rather than theoretical. Eye height is the number nobody thinks about, so it is the first control. Keep a named shot list, check whether your verticals are falling over and by how much, and send the whole set back to Rhino as real named views in a .3dm — or as a RhinoPython snippet for a model you already have open. Isovist asks what you can see from here; Scout asks where you should be.

Read a cut, then draw one. A massing floats in an orthographic viewport with a cut plane through it — the exact analytic section is drawn on the plane as you slide it, and you can freehand your own poché and have it scored against the truth with named misses ("you filled the open courtyard"). Trains the cut profile on original MCT-style massings; an optional AI narration explains the engine's diagnosis. Sign-in required.

Design the way your viewport DRAWS, then take it home as a real Rhino display mode. One model, every graphics decision live: ink and pixel lineweights, silhouettes vs creases (and the dihedral test that finds them), isocurves, flat vs modeled shading via the ambient term, specular shine, shadow maps with their resolution, blur and bias artifacts, the paper behind it all — each control naming the exact .ini key it writes. A single WEIGHT BOOST scales every line family together, so the whole drawing can be made frankly heavy for a projector, a pin-up or low vision without losing its hierarchy — and it exports, reaching surfaces, meshes, SubDs and the section cut alike. Twenty-five studio presets, accessibility first (HIGH CONTRAST, NIGHT SHIFT, then Moebius ligne claire, graphite, noir, blueprint, clay, terracotta, riso, xray, Nolli, neon, chalk, black-poché sections and more) or dial your own, then export a .ini that imports straight into Options → View → Display Modes. Drive the massing to watch intersection curves appear and vanish — including a raking blade wall, because surface∩volume is the hard case. Client-side; the lesson is the settings panel you were always afraid of.

Drop a .3dm, OBJ, STL, PLY or GLB and read the pre-flight report every other tool wishes you'd run first: units and scale sanity, naked and non-manifold edges, open meshes, a layer/type/block inventory, and printer bed fit — each finding naming the tool it affects. Click a finding to highlight it in 3D. Plumb diagnoses; it never repairs or rescales your file. Client-side, nothing uploaded.

A program & adjacency instrument: every space carries a real area, so the bubble diagram is area-true and the 3D stack has true footprints. Opens with the ARCH 371 museum brief (37,000 ft² net · 40,000 gross · 75,000 exterior) on the Round Barn Centre site, its two existing buildings locked as context. Arrange adjacencies per floor in 2D, tilt into an orbitable 3D stacking massing, and read a live program table — department + floor subtotals, net→gross by efficiency, exterior and existing on their own ledger lines, and FAR. With an adjacency matrix, departments, SF/m², CSV in/out, and SVG/PNG export. Client-side.

Hear how a room will sound — reverberation, room modes & flutter echo from its dimensions and materials, with fixes you can hear.

Make an acoustic portrait of a place instead of a perspective drawing. Build a curved room — a cylinder, an ellipse with its two foci, a Serra torqued ellipse or torqued spiral in weathering steel, a dome on a drum with or without an oculus, a barrel vault, a tapered drum, or a shoebox for comparison — on gravel, grass, a plaza or a floor, open to the sky or roofed, with a slot entrance. Place sounds in it (a voice, a clap, footsteps, a choir, a struck steel plate, rain, your own microphone or a file) and a listener you walk with the arrow keys. A curvature-aware ray tracer (it reflects off the true curve, not the facets) renders a binaural impulse response per sound and paints a floor map of where the room gathers sound; closed-form findings say why — focal distances, the ellipse's constant path, the dome's centre, the whispering-gallery condition, the corridor's note — and Bessel-zero modes give the drum's low end. Mix it all on a full board you can drive without looking: numbered strips, faders that speak in dB, meters read back in words, mute/solo/EQ/room-send by key or by voice. Record the portrait as a stereo WAV, export the impulse response, the written portrait, the room, the Rhino mesh. Reach for Sounding to build a room and walk a listener through it with the sounds you choose; reach for Caustic (/caustic) to read a room's acoustics against theory, run its wave tank or bring in your own Rhino model. The Serra rooms are studies, not surveyed dimensions. Client-side; Claude can optionally rewrite the portrait as prose (sign-in for that button only).

Build an acoustic portrait of a curved place instead of a perspective drawing. Load a rotunda, dome, whispering ellipse or a torqued-steel ring in the manner of Serra — or import your own Rhino model — then stand in it: a 3-D ray tracer that reflects off the true curve of the rooms it builds (analytic normals, not facets) shows where sound gathers and what echoes it throws, a 2-D wave tank shows the diffraction and standing waves rays cannot, and a full binaural mixing board lets you place and mix a four-part choir in the room, by keyboard, by voice or by screen reader. Prose portrait, wave tank, impulse-response export. Reach for Caustic to read a room's acoustics against theory — where sound gathers, the echoes it throws, a wave tank, your own Rhino model — and to mix a choir in it; reach for Sounding (/sounding) to build a room from its ground to its roof and walk a listener through it. The Serra-manner rooms are studies, not surveyed dimensions. The engines run in your browser and need no sign-in; Voice mode uses your browser's own speech recognition, which in Chrome and Edge sends speech to the browser maker.

Annual daylight analysis for a room, read in 3D. The room itself is the primary surface — orbit it and the floor carries the answer, on Proving Ground's bench grammar: three view modes (Daylight year colours the floor by Daylight Autonomy, so the amber area IS the sDA number; Direct sun colours it by annual hours of sun, so the red area IS the ASE number; Pen is the plain line drawing), a key that lives in the picture, every wall tagged with the compass direction it faces, and north drawn on the ground. Turn on Sun at a moment and the sun drops onto its own arc for Jun 21 / Mar 21 / Dec 21 at any hour, throwing a real patch through your openings — computed by the same per-aperture visibility test the annual number integrates, so watching an overhang cut the June patch and spare the December one is watching the metric itself. Underneath: windows on any of the four walls (each with its own shading slab), flat skylights, and a climate-based simulation (real EPW weather, Perez sky, IES LM-83's sDA + ASE) re-running live on every move, with each headline number shown against LM-83's own published band. The demo is Eco-Architect's canonical gable, and Proving Ground's Daylight ↗ button pipes any massing straight in. Claude can optionally read the results; it never produces them. Sign-in required.

Put schemes A, B and C in three columns and fill one honest table. Pull sDA/ASE from Daylighter and assembly carbon from Footprinter by reading your own trace, take Proving Ground / Brise / FAR numbers by pipe or by typing — every cell links back to the tool that produced it and prints that metric's blind spot, and a metric you never measured stays MISSING, never scored as zero. It ships with NO default weights: the table shows no total until you say what matters, and the flip test names the single weight change that would flip the ranking. Client-side; sign in only to read your trace or log the board.

The first hour of every feasibility study, made teachable. Pick a parcel and a teaching zoning district — front/side/rear setbacks, a height cap, a sky-exposure plane — and watch the legal BULK ENVELOPE get carved, one rule at a time. Tag the street edges and the envelope carves one rule at a time, so you can see which rule removed which volume. Then fill it: floor-to-floor, plate shape, a core you place yourself. Stack reads back gross floor area, the FAR you actually used against the FAR you're allowed, net-to-gross efficiency, core-to-floorplate ratio and a schematic unit count, and tells you which rule is actually binding — height or FAR, and by how much. The rule sets are INVENTED for teaching, not any real municipality's code, and this is not a compliance check. Client-side, no account.

The plans examiner's first read of your scheme, as a calculator that cites the law instead of a chatbot about it. List the spaces on a story and it computes the occupant load from the IBC 2021 occupant-load factors, then the exits that load requires, whether a single exit is still allowed, the travel-distance and common-path limits against what you measured, the exit separation from your plan diagonal, stair and door widths by capacity, the plumbing fixture counts and the accessible parking. Give it a lot and a district — one of Stack's invented teaching districts, or your own transcription of a real ordinance, one clause citation per number — and it reads the envelope: footprint after setbacks vs. coverage, the FAR budget, and which rule actually binds. Every value is a rule record with its clause, a link, and an honest verification status — the shipped tables are TRANSCRIBED and unchecked, so they read ? until someone who has opened the code stamps them — or arithmetic with the method written out. The model never produces a number: sign in and it explains the sheet, answers a question by citing a rule id or abstaining, or plays objection tennis as the code official. NOT A LEGAL DETERMINATION. The sheet runs in your browser, no account.

The other light instruments ask how bright it is; this one asks what it pays. Take Surveyor's climate (or drop an EPW), pick a massing, and paint PV zones onto roofs and facades. Skin walks all 8,760 hours: beam plus a Hay–Davies diffuse decomposition transposed onto each panel's tilt and azimuth, the building shading itself, a temperature derate from the same weather file, and PVWatts-shaped system losses — out comes annual kWh, specific yield in kWh/kWp, and a monthly generation profile. An orientation dial sweeps every tilt and azimuth so the lesson lands: a vertical south facade is not a roof. A carbon line talks back to Footprinter. Client-side; sign in to ask the coach about your own re-orientation idea.

Conjure's reasoning sibling. Where Conjure draws a shape, Computer shows its WORK: it reasons one architectural decision at a time (start with a south-facing room and its shading overhang), and the closed-form solar geometry answers every lever you pull. Every number links to its math; every AI claim is pinned to a value the engine can flip RED if it's wrong. Your reasoning — not the massing — is the printable artifact. Sign-in required.

Carbon calibration you can feel: stack a wall, floor or roof from real cited materials (the same ICE factors Proving Ground charges whole buildings with) and the needle answers immediately in kgCO2e/m² — then swap materials and watch the meter move. Honest by design — product stage A1–A3 only, every value carries an uncertainty band, and biogenic carbon stored in timber is a separate line, never silently netted. The builder runs in your browser; sign in to ask the AI coach about your own swap idea (it never moves first).

A standing round barn, broken into the elements it is actually made of — foundation ring, cow-storey wall, mow floor and its post ring, studs, sill and plate hoops, roof frame, sheathing, covering, siding, silo, windows. Call each one KEEP, STRIP or DEMOLISH and watch the carbon move: keeping costs nothing, which is the entire argument for reuse; stripping buys a replacement; demolishing buys nothing back and loses whatever the element was doing, which the tool names out loud. Then the comparison the whole thing is for — reuse + retrofit against demolish + rebuild, cumulative over a century on a decarbonizing grid, with the crossover year called. Reuse usually wins. It does not ALWAYS win, and a tool that could not say so would be agreeing with you rather than measuring anything, so the numbers that decide it (how good the retrofit gets, how good the new build is, how fast the grid cleans up) are sliders on the front with their sources attached. Factors are the platform's shared ICE v4.0 set. v1 is sketch-only: the elements come from the barn's dimensions, because per-element triage needs to know a thing is a rafter and an imported mesh is only triangles. Client-side.

Air through a drawn plan — and site wind over the Eco-Architect massing (Site 3D tab: streamlines + a pedestrian-level speed slice). Potential flow, not CFD: channeling, blockage and shelter, honestly no wakes.

An interactive psychrometric chart with the comfort zone and Givoni-style passive-strategy regions (natural ventilation, thermal mass, evaporative cooling, humidification, heating). Plot a temperature/humidity point and read its humidity ratio, dew point, enthalpy and the strategy that gets it to comfort. Client-side.

Pick a place and a date + time and see where the sun is and how shadows fall on a massing — real solar geometry (NOAA), real cast shadows, a sun-path arc for the day, and a one-click sunrise→sunset animation. Switch massings, read altitude/azimuth/sunrise/sunset, export a PNG. Client-side.

Carve the largest volume you can build on a site without shadowing the neighbours — the 'solar envelope' (after Knowles). Set site size + latitude, pick the sun window to protect (e.g. winter 9–3), and height is capped everywhere so shadows stay on-site: tallest in the middle, sloping to the edges. Orbit it, export OBJ to Rhino. Client-side.

Design a sun-shading device — horizontal louvers, vertical fins, or an eggcrate — over one window at a chosen facade orientation and latitude. Sliders drive a live 3D preview whose glass shadow is drawn from the same closed forms as the numbers. A sun-path chart paints the shading mask over the day arcs; read winter-sun-kept and summer-sun-cut, scan a month×hour heatmap, and export a laser-ready mm-true cut sheet, a PNG of the mask, or JSON. Direct-beam screening, not a daylight sim. Client-side.

Answer the everyday framing question — 2x8 or 2x10, and at what spacing? — the way the code span tables are built. Set a span, species/grade and load; it sizes every standard joist (2x6–2x12 across 12/16/19.2/24" o.c.) against bending, shear and deflection, flags which combinations work and which check governs, and shows the math so you learn the method. NDS/IRC, validated within ~1–3 in. Client-side.

Drop a viewpoint in a plan and see exactly what's visible — the isovist polygon — with area, perimeter, compactness and drift. Draw walls and obstacles, move the viewpoint, and read the space the way a person standing in it does. SVG/PNG export. Client-side.

Author the project charter before any geometry exists — program, ambitions, and testable goals drawn from the site-forces deck. Goals export in Eco-Architect's own Save/Load-goals format, so the charter travels with the design. Client-side, no account.

Critique + portfolio narrative — build and tune your own critics, a defensible thesis, and review prep. Use with caution; consult humans too.

Find the story in your research — a story is a tension, not a theme. Pull your tagged claims from Surveyor and Librarian onto one board, drag the evidence into opposing pairs, and commit to a position in four slots. This tool can propose tensions; it can never take your side.

A research conversation partner for the theory seminar. Bring a position, a passage or a hunch and it engages the argument — situates it in the discourse, steelmans the opposition, opens adjacent debates — while a reading trail of real references accumulates beside the chat, each card tagged WEB-CONFIRMED (a search verified it exists as cited) or VERIFY (the model's memory — a lead, not a citation). Web sources it actually opened are link-checked before they render. Pick WHO argues with you: six tunable house voices (The Historian, The Materialist…) or build your own — the same tune-a-persona idea as the Critic's jury, one active voice at a time instead of a convened panel. Sign-in required.

Four one-shot passes over your OWN draft, plus a desk conversation about it — never a ghostwriter. Red pen marks wordiness, passive voice, jargon and hedges with a one-sentence tightening nudge each; Argument X-ray reads what every paragraph claims and whether it advances your thesis (or says honestly that it can't find one); Citation check web-verifies every attribution you made, tagged confirmed or verify-from-memory; Voice check flags passages whose register jumps against the rest. Chat talks the draft through — what a paragraph is doing, whether a cut breaks the argument — and still won't write a sentence for you. Build your own copyeditors the way you build critics: tune a house editor, describe your professor, or paste the feedback you were actually given and have that desk extracted. Nothing is generated for you — only marks on what you wrote. Sign-in required.

A tutor for Rhino · Grasshopper · AutoCAD · Revit · Adobe — with levels, doc links, and a concept panel.

The capstone of the authoring ladder: describe the parametric instrument you wish existed and Claude writes its build() program on Conjure's fenced rails — then use the sliders it chose, read its annotated code, edit and re-run it yourself, and keep it in a personal library (JSON + .3dm export), or publish it to the studio gallery. Its Forge forks the toolkit's own single-file tools — the Librarian, Surveyor and Proving Ground editions among them — to steer in plain language, every change a revision you can restore. Sign-in required.

A beginner→advanced trail map of 2D & 3D skills — with a tutorial video behind every step.

The complete map of 3D geometry skills on one screen: nine domains (Projection & Views, Curves, Surfaces, Solids & Topology, Form Operations, Transformations, Sections & Intersections, Development & Discretization, Measure & Proportion), each skill tiered Foundation / Working / Advanced and carrying a precise definition, its studio relevance, the Rhino vocabulary that operates on it, and cross-links to the toolkit tools that exercise it. Where a fact deserves a model there is a live demo — a projection box with an unfold control and a per-edge true-length table, a silhouette-reconstruction field that counts exactly how much three views underdetermine a solid, a single-view alignment that closes an open chain from one direction only. The taxonomy exports as a CSV checklist; demo geometry exports as .3dm in feet. Client-side, no account.

How people have built shelter from what their place gives — snow, turf, earth, stone, reed, bamboo, hide — taught the way Lloyd Kahn's Shelter taught it: with drawings. TRADITIONS: sixty-four buildings, from the iglu to the tulou, each drawn in section to scale beside a 6 ft figure, with its builders named, why it works in its climate, how it is built, the numbers (imperial first, each with its source), and links to go further. TECHNIQUES: the fifteen passive moves those buildings are made of — thermal mass, orientation and the overhang, cross and stack ventilation, evaporative cooling and more — each with a diagram, the physics, and its math set out with every term defined. LESSONS: eleven paths through both, each ending in a studio exercise. Two benches: MASS & LAG shows what a wall of any material and thickness does to a day's heat; A CLIMATE LIKE YOURS ranks the traditions and the techniques against any site's weather. Runs in your browser; no account.

How an architecture office and its projects are budgeted, taught as three linked ledgers. OFFICE: set a roster (sole practitioner to an 80-person departmental firm), each role's salary and utilization, the payroll burden, the overhead lines and a profit target, and read the chain the Handbook teaches — direct and indirect labor, overhead rate, break-even and net multipliers, the billing rate for every seat, revenue per FTE — then see how the same profit reaches an owner under a sole proprietorship, partnership, LLC, S corporation or C corporation. PROJECT: pick a building type and delivery method (design-bid-build, design-build, CM at risk, IPD), a compensation basis from AIA B101's menu (percentage of construction cost, stipulated sum, per square foot, hourly, hourly not-to-exceed, cost plus a multiplier, IPD profit-at-risk), budget the net fee top-down into hours per phase at the office's own multiplier, then add an overrun and watch every basis answer it differently — the comparison table names who paid. CASH FLOW: the same project month by month with a retainer and a payment lag, so the line of credit a profitable lump-sum job still needs is a number, not a warning. Every headline value says its method on hover and on keyboard focus, each table carries its sources under it, and the defaults say where they came from. Client-side, no account.

A searchable gallery of small, copy-paste RhinoPython / GhPython snippets for studio moves (panelise, attractor fields, contour, Make2D batch, layers, baking), each with a one-line explanation and an 'Edit with AI' console — paired with Coach for the why.

Say what you're working on in your own words, and Ask Prof names the one to three Good Tools tools that fit, with why each fits and its first step, or says plainly that no tool does that yet. Ask a follow-up ("how do I use that one?") and it gives that tool's own how-to steps. It only ever names tools that are live on this site, checked against the Catalog before an answer is shown. Up to ten questions per conversation; questions are saved so the toolkit can grow toward what students actually ask for. Sign-in required.

The whole toolkit as one design process. A phase spine from Brief to Critique deals each phase's tools as a deck — keystones prominent, instruments compact — with Learn ambient beside it. The default framing is the loop (design is a cycle); Guided mode lays the same phases out as a numbered first-year path. Signed-in students carry an active Work across every phase; browsing is public.

Studio memory + metadata. Upload work, tag it, keep the record. Its ASSIGNMENT BOARDS are the class walls — one row per student, one column per class day, comments in every cell — with a demo you can try without touching a class, and ARCH 273 and ARCH 371 on their own. Pick sheets off a wall and one black-and-white PDF comes back for the PIAF swell-paper printer, a whole pin-up day at a time. Its Tactile Library shelf holds reference images curated for the same printer, each with the RAP alt-text describer attached. The REFERENCES grid under every wall reads in four blocks: the instructor library (Librarian collections your teachers hang), the class library right below it, a SHARED POOL open to every classmate and TA — tagged for atlases, experimental drawings, architecture and architecture drawings, graphic novels or a tag you add, and scoped to no module at all so it carries through the whole term — and your own browser-only shelf. Every picture opens its card of information, and the grid draws all of them, not a first hundred.

The Archivist's classroom sibling — QR drops for a class session, no student accounts. A print drop auto-formats every photo students send to an 11×17 sheet at 300 DPI (print sheets + one-PDF wave export included); a slideshow drop collects candid photos + videos and plays them as the end-of-week show; a booklet drop runs the other way — you upload one PDF and the QR lets students download it. Share any drop with a co-teacher by email; only the two of you see what lands.

Your own trace — every tool run you've made, as a filterable timeline you can print for review or export. Only you can see it.

Collect recipes from anywhere — a link (read from the page's own structured data, free and exact), a photo of a handwritten card, or a paste — then plan a week for a real table. The planner is code, not AI: it fits each night's cooking time, keeps the proteins varied, chains a Sunday roast into Tuesday's tacos, schedules the leftovers, and introduces exactly one new food the way the feeding research says to (small portion, beside two safe foods, no pressure, 8-15 tastings). Out comes a merged shopping list — one line per ingredient, converted through real densities and piece weights, priced from a cited US reference basket with an honest band and scaled by the chain index of the store you picked from real OpenStreetMap listings. Portions scale by age, so a family of five with three kids under ten is 3.8 adult portions, not five. Every dish carries a yumminess score that says whether it's predicted or measured — and the moment you rate a dinner, the guess is replaced by your family's actual verdict. Runs in your browser; sign in only for the AI photo read and the week's cook notes.