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, Assayer 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.

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.

Eco-Architect at COMMUNITY scale: 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.

Guess what your site used to be, then let the federal record prove you wrong. Commit a reconstruction of the ground's ~1985 land cover — paint the dominant cover, bet whether canopy and built surface were more or less than today, set a confidence — then lock it and scrub real 30 m Annual NLCD (USGS/MRLC, 1985–2025) backward as the pixels flip class. A confidence-weighted surprise score measures how wrong "normal" was. Honest limits: 30 m can't see a single tree or a narrow creek; the canopy bet reads forest-class share, not a tree-canopy service; sites under ~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 the active Work from 2026 to 2126 — the climate warming offset and the embodied-vs-operational carbon curve, each lane an adapter over an engine that already exists, each saying out loud when its data runs out (solid = modeled, dashed = extrapolated). Reads the Work's saved Architect design; renders honest empty states without one. 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 four 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. 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.

Conjure × Eco-Architect, fused. Opens with the canonical GABLE demo — drag its sliders and the environmental analysis (sun, wind, ventilation, views, earth) answers live. Then Clear and author your own massing in Conjure's engine (any geometry, even a courtyard the gable typology can't make), or import a Rhino .3dm — the analyses that can run on your mesh do, and the method notes say honestly which can't. Draft testable goals from the forces deck (or brainstorm them with Claude) and let the in-tool NSGA-II optimizer push the form toward them. Detail a wall, roof or floor in Detailer and send it over — the energy balance and carbon then read your solved assembly, not the fixed stand-in construction. Client-side, no account.

A hundred versions of your massing, all scored the same way. Hand Swarm a parametric model from Assayer or Conjure ("Explore in Swarm →"), pick which sliders are free, and it samples the space (or searches it with NSGA-II — the same engine Assayer 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.

Study 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. The drawings (axon, gable section, plan) redraw live, and a material readout answers alongside: areas and volume, framing lineal feet, and honest 4'×8' sheet counts with the waste each surface leaves. Two roof modes make it a real jig: drive the ridge and read the slopes, or drive the slopes and read the ridge. Client-side.

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.

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.

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 Assayer 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.

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 viewer, three ways of drawing (Obliquify + Model Viewer, merged). Import a model (GLB/GLTF/STL/OBJ/PLY/3DM Rhino) and toggle the projection: Perspective (a camera with a lens), Axonometric (parallel, orbitable, flat elevations), or a true Oblique — cabinet / cavalier presets with adjustable angle, depth ratio and direction. PNG export. 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.

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.

Turn a phone photo or scan of a pen/pencil drawing into clean black-on-white. Auto levels with a live histogram, gamma, sharpen, denoise and adaptive lighting, plus straighten/crop, a curves editor with presets, a before/after split, and a full-resolution (resizable) PNG export.

Point your phone or webcam at anything and watch it become a live dithered / halftone image — 10 algorithms (Floyd-Steinberg, Atkinson, Bayer, angled halftone, variable dots, lines, crosshatch…), CMYK colour screening, a Sobel edge overlay, posterise, gamma / invert. Built for PIAF tactile printing and zines: freeze a frame and save a high-contrast PNG. Front / back camera, all in the 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.

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. Arrange adjacencies per floor in 2D, tilt into an orbitable 3D stacking massing of every floor, and read a live program table — department + floor subtotals, net→gross by efficiency, 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.

Annual daylight analysis for a room: windows on any of the four walls (each with its own shading slab), flat skylights, fine-grained sliders — and a climate-based simulation (real EPW weather, Perez sky, IES LM-83's sDA + ASE) re-runs live on every move. The demo is Eco-Architect's canonical gable, and Assayer'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 Assayer / 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 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 Assayer 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 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). Personal-only for now. Sign-in required.

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

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.

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.

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.