Methods

The options at a glance

Mode · Place

Survey any point: a geocoded search, a map click or the browser's location.

• What it adds: The point you pick becomes the centre of the study box and the point every point layer reads. Search uses OpenStreetMap Nominatim (8 results). A map click reverse-geocodes the pin and falls back to a coordinate label. No EPA record, boundary or contamination pass runs. You can trace your own boundary (see Traced parcel) and switch on "show all Superfund sites" dots for the current view.
• Method: The payload is {lat, lon, label, category, spanM}. The server builds bboxForSpan, a box square on the ground (the longitude half-width is scaled by 1/cos lat), then fires the eleven fetches in parallel. The AI synthesis in this mode is told that no contamination data was gathered and that a Phase I ESA or records check would be needed.
• Fidelity: Same engine. The mode adds no computation of its own; every number comes from the per-layer engines below.
• Professional equivalent: A GIS desk study in ArcGIS Pro or QGIS, the first chapter of a site-analysis report.
• Trust it for / don't use it for: Trust it for a fast, registered first read of any US point. Don't use it to conclude a site has no contamination history. Place mode never looks.
• The gap:
  • No environmental records search. A Phase I database report searches NPL, RCRA, brownfields, UST/LUST and state lists at ASTM search distances (NPL: 1 mi). Place mode searches nothing unless you switch on the NPL dots, and those show NPL only.
  • A geocoder hit is a point, often a road centroid or a building entrance. All point layers read there, not over your parcel.
• Code: src/app/(app)/site-analysis/site-analysis-tool.tsx (selectCandidate, pickPoint), src/app/api/site-analysis/analyze/route.ts, src/lib/site-analysis/datasources.ts (geocodeSearch, bboxForSpan)

Mode · Superfund

Survey a listed NPL site by EPA ID, with its record, boundary and an AI contamination brief.

• What it adds:
  • The record. Search by name, city, county or state against EPA's NPL FeatureServer, or click an orange dot. The server re-fetches the site record by EPA ID: status, dates, and links to the listing narrative, progress profile and Federal Register notices.
  • The boundary. It pulls the EPA boundary layer and merges all operable units into one MultiPolygon. Acreage comes from GIS_AREA only when its unit is areal. Boundaries over 15,000 vertices are decimated.
  • The anchor. The five studio sites send a hand-vetted anchor coordinate. It is accepted only inside the boundary bbox padded 0.02° (1.2 mi), or within ~9 mi of the EPA point. The anchor replaces EPA's administrative reference point as the survey centre.
  • The brief. The AI adds a contamination brief before the synthesis.
• Method: The study box is still bboxForSpan around the centroid. The span wins over the boundary, so a site the size of Tar Creek (about 40 sq mi, per EPA) is surveyed only inside the span you pick, while the whole (decimated) boundary is drawn. Point layers read at the anchor or EPA point. If the EPA service fails for a studio site, the page falls back to a coordinate survey and says so.
• Fidelity: Same engine for the record and boundary (EPA's own layers). AI reading for the contamination brief (see AI passes).
• Professional equivalent: An ASTM E1527-21 Phase I ESA. That means a commercial database report (EDR/ERIS), a site reconnaissance, interviews, and historical sources (Sanborn maps, aerials, city directories). Then a Phase II with sampling. For a listed site: EPA SEMS documents, the Record of Decision and five-year reviews.
• Trust it for / don't use it for: Trust it to locate the site, read EPA's own status, open the source documents and frame questions. Don't use it for contaminant lists, plume extents or institutional controls without checking the ROD and the deed.
• The gap:
  • The EPA boundary is an administrative footprint. Every ring is drawn as its own polygon, so interior holes draw filled.
  • The five studio sites ship a prebaked AI reading. It was written in advance, during the site's build, not live by the route: the live route's web search and link probe did not produce it, and its cited links were not probed.
  • Only NPL sites. Non-NPL contaminated ground (brownfields, RCRA, state sites) is invisible here.
• Code: src/lib/site-analysis/datasources.ts (getSite, getBoundary, mergeBoundaryFeatures), src/lib/site-analysis/boundary.ts, src/lib/site-analysis/superfund-search.ts, src/app/(app)/site-analysis/studio-sites-data.ts, src/app/(app)/site-analysis/studio-ai-cache.ts

Span · 1,000 ft, ¼ mi, ½ mi, 1 mi

The building- and parcel-scale spans: the terrain grid holds its ~26 ft target.

• What it adds: The span sets the terrain box and everything downstream: slope, contours, drainage, sun hours, flood vectors, the OSM clip and every Rhino export. Grid size is n = round(span ÷ 8 m) + 1, clamped to 32–240.

  Span	Box area	Grid (n × n)	Spacing	Smallest feature (~2 cells)	Channel starts at (1% of grid)
  1,000 ft (305 m)	23 acres	39 × 39	26.3 ft (8.0 m)	~53 ft	~0.24 acre
  ¼ mi (402 m)	40 acres	51 × 51	26.4 ft (8.0 m)	~53 ft	~0.42 acre
  ½ mi (805 m)	160 acres	102 × 102	26.1 ft (8.0 m)	~52 ft	~1.6 acres
  1 mi (1,609 m)	640 acres	202 × 202	26.3 ft (8.0 m)	~53 ft	~6.5 acres

• Method: 3DEP exportImage, bilinear, is resampled to n × n. Spacing stays at ~26 ft up to ~1.19 mi (1,912 m), where n reaches the 240 cap.

• Fidelity: Same engine. It is the same 3DEP mosaic a GIS analyst would download, at 8 m posts.

• Professional equivalent: The 3DEP 1 m DEM used at native resolution in ArcGIS or QGIS; for design, a topographic survey (typically 1 ft contours with spot elevations and breaklines).

• Trust it for / don't use it for: Trust it for landform, general slope classes and drainage direction on a parcel. Don't use it for curb, swale, retaining-wall or pad-level decisions.

• The gap:

  • Where 1 m lidar exists, 8 m posts throw away ~98% of the samples. Anything under ~53 ft disappears, and bilinear resampling rounds off breaks in slope.
  • The drainage channel threshold scales with the box. A 1,000 ft box draws channels from ~0.24 acre; a 1 mi box needs ~6.5 acres. The "same" swale can appear at one span and vanish at another.

• Code: src/lib/site-analysis/datasources.ts (rasterSizeFor, bboxForSpan, elevationRaster), src/app/(app)/site-analysis/site-analysis-tool.tsx (STUDY_SPANS, StudyAreaBand)

Span · 2 mi (the page default)

The studio's default: landform and neighbourhood context, at coarser ground.

• What it adds: A 4 sq mi box. The 240-post cap is hit, so spacing grows to 44.2 ft (13.5 m). The picker marks it ⚠ and says so ("coarser ground and stretched drape images, not a bigger file"). The terrain card prints the actual n and cell size.
• Method: As above; n = 240. Channels need ~26 acres of upstream area. Features under ~88 ft vanish.
• Fidelity: Screening estimate. Same data and method, but at a resolution where derived slope and drainage are for comparing, not for sizing.
• Professional equivalent: The 1 m or 10 m DEM at native resolution; a USGS topo quad for context.
• Trust it for / don't use it for: Trust it for which way the neighbourhood drains, where ridges and valleys are, and context massing. Don't use it for the slope of a building pad or the buildable percentage of a parcel.
• The gap:
  • Mean and maximum slope bias low as spacing grows. The steepest cells are averaged with flatter neighbours.
  • Sun-hours rays and section cuts run at 44 ft steps.
  • The default (DEFAULT_SPAN_M) sits above the 1 mi span the tool recommends for building- or parcel-scale work.
• Code: as above

Span · 3 mi

Regional landform; buildings only in the middle.

• What it adds: A 9 sq mi box at 66.3 ft (20.2 m) spacing. Channels need ~58 acres. Features under ~133 ft vanish. OpenStreetMap surroundings are capped at 2.8 mi (4.5 km), so only the central sub-box gets buildings and roads, flagged "partial".
• Fidelity: Screening estimate.
• Professional equivalent: Watershed-scale GIS; USGS StreamStats for catchment questions.
• Trust it for / don't use it for: Trust it for landform and major drainage. Don't use sun hours or sections in the outer band: no buildings means no building shadows there.
• The gap: Sun hours over-light the outer band. The Rhino kit's context stops short of the terrain edge.
• Code: src/lib/site-analysis/layers.ts (overpassSafeBox), plus the above

Span · 5 mi

The widest box: context only.

• What it adds: A 25 sq mi box at 110.5 ft (33.7 m) spacing, coarser than 3DEP's own 1/3 arc-second (~33 ft / 10 m) floor. Channels need ~161 acres. Features under ~221 ft vanish. OSM is partial, as at 3 mi.
• Fidelity: Screening estimate, bordering Classroom proxy for any building-scale reading. At this spacing the "site" read stops meaning anything at building scale.
• Professional equivalent: A regional GIS basemap or a USGS quad.
• Trust it for / don't use it for: Trust it for orientation and the big landform. Don't use it for slope, buildable area, sun hours or site drainage.
• The gap: Every terrain-derived value is smoothed. The drape images are stretched. The point layers still describe a single point in a 25 sq mi box.
• Code: as above

Terrain grid (USGS 3DEP)

The measured ground everything else is computed on.

• What it adds: One n × n elevation raster over the study box, in metres (displayed in feet).
• Method: elevationRaster requests one F32 GeoTIFF from the 3DEP ImageServer exportImage, with bilinear resampling and adjustAspectRatio=false so pixels stay on the requested bbox. The source mosaic is best-available 3DEP: 1 m lidar where flown, 1/3 arc-second (~33 ft / 10 m) elsewhere. topoFromRaster rejects values outside −1,640 to 29,500 ft (−500 to 9,000 m) and NoData, and rounds to the centimetre. Gaps are back-filled with the grid mean and recorded in missingMask. If the raster fails, a 12 × 12 getSamples grid is the fallback. At 2 mi that is ~960 ft (293 m) spacing; the terrain card prints the real n, so it is visible.
• Fidelity: Same engine. It is the same USGS mosaic, resampled.
• Professional equivalent: A licensed topographic survey, or an ALTA/NSPS survey with topography. For GIS: the 3DEP 1 m DEM or point cloud processed in ArcGIS Pro or Civil 3D.
• Trust it for / don't use it for: Trust it for bare-earth landform at the span's spacing. Don't use it for spot elevations, finished-floor datums or earthwork quantities (Grade inherits the same grid).
• The gap:
  • Resampling to the span grid, with no breaklines, curbs or walls.
  • A mixed-vintage mosaic: the lidar collection year varies by county and is not reported.
  • Vertical accuracy is USGS's, not a surveyor's.
  • Mean back-fill at coverage edges (coast, border) is flagged, and the drainage routing runs over those cells (see Drainage).
• Code: src/lib/site-analysis/datasources.ts (elevationRaster, topoFromRaster, finishTopo, elevationTopo)

Slope & aspect

Which ground is buildable and which way it faces.

• What it adds: Mean and maximum slope, four slope bands, buildable percentage, an 8-bin aspect distribution with the dominant facing, high and low points, and a suggested grading datum (the low point). The map drapes classed slope and aspect.
• Method: Per interior cell, dz/dx = (z[c+1] − z[c−1]) / 2Δx and dz/dy likewise; slope = √(gx² + gy²) × 100%. This 4-neighbour second-order difference is the Zevenbergen–Thorne slope (GDAL's -alg ZevenbergenThorne), not Horn's weighted 3 × 3.
  • Slope bands: <5, 5–10, 10–20 and >20%. Buildable means under 15%.
  • Aspect = atan2(−gx, −gy), ignored under 1% slope.
  • Cells touching a fabricated cell are skipped in the card statistics.
  • The map drape instead clamps at the edges and colours every cell, leaving only fabricated cells transparent.
• Fidelity: Same engine. It is a standard GIS slope algorithm, one GDAL ships, on the survey grid.
• Professional equivalent: ArcGIS Pro Slope/Aspect (Horn by default) on a 1 m DEM; Civil 3D surface slope-band analysis on a surveyed TIN.
• Trust it for / don't use it for: Trust it for slope classes and aspect at landform scale. Don't use it for accessible-route grades, retaining-wall locations or a precise buildable percentage.
• The gap:
  • Grid spacing dominates the error. At 26 ft, a 10 ft bank reads as a moderate slope. At 110 ft it may vanish.
  • Maximum slope is understated, increasingly with span.
  • Zevenbergen–Thorne is somewhat noisier than Horn on rough ground. At these spacings that difference is small next to resolution.
  • The 15% buildable cutoff is a rule of thumb, not a zoning or code limit.
• Code: src/lib/site-analysis/terrain.ts, src/lib/site-analysis/ground-core.ts (slopeAspectGrid, SLOPE_CLASSES)

Contours & hillshade

Linework and relief shading: one source for the map, another for the exports.

• What it adds: Map contours in feet at USGS quad intervals by zoom, plus hillshade and 3-D terrain. Exported contour curves at true elevation (.dxf, .3dm) and a hillshade drape.
• Method:
  • Map. maplibre-contour cuts isolines in a worker from AWS terrarium DEM tiles (3DEP-derived, max zoom 15), converted to feet first, at intervals of 5–200 ft by zoom.
  • Export. contourLines3D runs masked marching squares on the surveyed grid at round-foot levels. The default interval is a "nice" step giving about ten contours over the relief. Segments are chained on a 0.4 in (1 cm) key, and cells touching fabricated samples are skipped.
  • Hillshade drape. 315° azimuth, 45° altitude, using the same 4-neighbour (Zevenbergen–Thorne) derivatives as slope, not Horn's.
• Fidelity: Same engine. Marching squares is what GIS contouring runs.
• Professional equivalent: Civil 3D surface contours from a surveyed TIN (with breaklines); GDAL gdal_contour; the surveyor's own contour drawing.
• Trust it for / don't use it for: Trust it for massing and site-model bases. Don't use it for grading plans.
• The gap:
  • Map contours and exported contours come from different DEMs and can disagree slightly.
  • Grid contours cannot show features smaller than the spacing.
  • No breaklines, so contours cross curbs and walls smoothly.
• Code: src/lib/site-analysis/ground-core.ts, src/lib/site-analysis/contour-core.ts, src/app/(app)/site-analysis/SiteMapGL.tsx

Drainage & flow

Where the water goes on this ground.

• What it adds: A flow-accumulation drape in five log classes, thalweg polylines exported as real curves, the outlet (the edge cell carrying the most water), the percentage of the box that is channelised, and the percentage the fill had to raise.
• Method:
  • Priority-Flood depression filling (Barnes, Lehman & Mulla) from the box edges on a heap, with ε = 1e-5 m (0.0004 in) per cell.
  • D8 steepest descent, slope divided by true diagonal distance.
  • Accumulation in one high-to-low pass.
  • Channels are cells with accumulation ≥ max(8, 1% of n²), walked from channel heads.
• Fidelity: Same engine. It is the textbook GIS pipeline (ArcGIS Fill → Flow Direction → Flow Accumulation, with Priority-Flood as in WhiteboxTools and RichDEM).
• Professional equivalent: The ArcGIS Pro Hydrology toolset or WhiteboxTools (often breaching rather than filling, or D-infinity/MFD routing). USGS StreamStats to delineate the contributing area and get regression peak flows. HEC-HMS or EPA SWMM, with pipes and inlets, for a civil engineer's stormwater report.
• Trust it for / don't use it for: Trust it for flow direction, where water collects, which edge it leaves by, and what a flow path crosses (important on a contaminated site). Don't use it for flow rates, pipe or detention sizing, or floodplain limits.
• The gap:
  • Terrain only: no storm sewers, culverts, curbs, infiltration or rainfall.
  • The box edge is both outlet and watershed limit. A creek entering from uphill carries only the area inside the box, so accumulation is understated for through-flowing streams.
  • The channel threshold is 1% of the box, so channel density changes with span (0.24 acre at 1,000 ft, 161 acres at 5 mi).
  • Filling (rather than breaching) floods road embankments into false lakes.
  • Fabricated (mean-filled) cells take part in fill and routing; they are only hidden in the drape.
• Code: src/lib/site-analysis/drainage.ts

Sun hours

Hours of direct sun per cell on a solstice or equinox, with hills and neighbours in the way.

• What it adds: A classed drape (2/4/6/8 h breaks), the share of ground with 6 h or more and with under 2 h, and the mean. It is also exported as a Rhino drape.
• Method:
  • Height field. The height field is the 3DEP grid raised under OSM building footprints. Height is the height tag, else building:levels × 10.5 ft (3.2 m), else 14.8 ft (4.5 m).
  • Timesteps. The dates are June 21, March 21 and December 21, in 30-minute steps; steps with the sun below 0.5° are skipped. Sun position is NOAA/Meeus.
  • Ray march. Per cell, a ray marches toward the sun one cell per step, climbing tan(altitude) per step against a bilinear height field. It stops when it leaves the grid (counted lit) or clears the tallest point.
• Fidelity: Screening estimate. The physics is right for direct beam; the obstructions are simplified.
• Professional equivalent: Ladybug Direct Sun Hours or ClimateStudio on the actual 3-D model; ArcGIS Area Solar Radiation (direct plus diffuse over a viewshed).
• Trust it for / don't use it for: Trust it for comparing spots on the site and for the shading effect of big terrain and mapped buildings. Don't use it for solar access compliance, PV yield or courtyard daylight hours.
• The gap:
  • Direct beam only: no diffuse sky, no cloud (every hour is treated as clear), no trees.
  • Buildings are rasterised to the grid, so a 40 ft street at 26 ft spacing is one or two cells; at 2–5 mi, narrower still.
  • Untagged heights are guesses, and OSM coverage is uneven.
  • Distant horizons outside the box are ignored. A ridge a mile away never casts, which over-states winter sun in valleys.
  • At 3 and 5 mi the outer band has no buildings.
• Code: src/lib/site-analysis/sun-hours.ts, src/lib/site-analysis/geo.ts (solarPosition)

Climate year

One hourly year at the site: temperatures, humidity, degree-days, design conditions, comfort, precipitation.

• What it adds: Monthly temperature and RH. HDD/CDD on base 65°F (18.33°C). Mean diurnal swing. Heating 99.6/99% and cooling 0.4/1/2% dry-bulb, plus extremes. ASHRAE-55 adaptive comfort hours by month. A Givoni strategy mix. Daylight hours. Precipitation and snow.
• Method:
  • Data. Open-Meteo archive API for 2023 only (CLIMATE_YEAR): twelve hourly variables, timezone=auto. The request names no model, so Open-Meteo's default "Best Match" blend applies, which Open-Meteo documents as combining ECMWF IFS HRES (~5.6 mi / 9 km, from 2017), ERA5 (0.25°, ~15 mi / 25 km) and ERA5-Land. A 2023 year is therefore probably served largely by the IFS; the per-variable mix is not documented.
  • Design days. Percentiles of the sorted 8,760 hours.
  • Adaptive comfort. Tcomf = 0.31 × Trm + 17.8°C, where Trm is an exponentially weighted (α = 0.8) mean of prior days, clamped to 50–92°F (10–33.5°C). The band is ±6.3°F (±3.5°C), with air temperature standing in for operative temperature.
  • Givoni. Mutually exclusive dry-bulb and humidity-ratio boxes, labelled "clearly an approximation" in code.
• Fidelity: Screening estimate for the year and its percentiles and comfort. Classroom proxy for the Givoni mix.
• Professional equivalent: The ASHRAE Handbook, Fundamentals, climatic design conditions: station-based, multi-decade percentiles. TMY3/TMYx station files in Climate Consultant or Ladybug. For comfort, CBE Comfort Tool with operative temperature.
• Trust it for / don't use it for: Trust it for the shape of the seasons, whether heating or cooling dominates, and rough comfort share. Don't use it for HVAC sizing or code design temperatures.
• The gap:
  • One year (2023) carries that year's anomalies. ASHRAE's percentiles span decades.
  • Reanalysis smooths extremes, so the 99.6% and 0.4% values are likely less extreme than the station values.
  • A 6–15 mi model cell misses urban heat island, coastal and valley effects; diurnal swing can be off by several °F.
  • Adaptive comfort without mean radiant temperature overstates comfort in sunny hours.
• Code: src/lib/site-analysis/climate.ts, src/app/api/site-analysis/analyze/route.ts (summarizeClimate, climateExtras)

Wind

Prevailing wind by year and season.

• What it adds: A 16-sector rose with speed bands at 4.5, 8.9, 13.4 and 17.9 mph (2, 4, 6, 8 m/s); calm is under 1.1 mph (0.5 m/s). Also the prevailing direction by meteorological season. It is also drawn in the .3dm.
• Method: It bins the same hourly 10 m (33 ft) wind speed and direction from the climate year.
• Fidelity: Screening estimate. It is regional prevailing wind from a model cell.
• Professional equivalent: A wind rose from the nearest airport ASOS station (multi-year). For site-level flow: CFD (Eddy3D, Butterfly/OpenFOAM, Autodesk CFD) or a wind-tunnel study for tall buildings.
• Trust it for / don't use it for: Trust it for which quarter winter and summer winds come from, for siting outdoor rooms and ventilation openings. Don't use it for pedestrian comfort, gust or downdraft questions.
• The gap: No channelling by valleys, streets or buildings. A single year. Speeds are for open terrain at 10 m and overstate wind at ground level in built-up areas.
• Code: src/lib/site-analysis/geo.ts (windRose), src/lib/site-analysis/climate.ts (seasonalWind)

Façade solar & sun path

Where the sun goes, and how much reaches each façade orientation.

• What it adds: Sun-path arcs (every 30 minutes) and annual incident solar in kWh/m²·yr on eight vertical orientations plus the roof.
• Method: NOAA/Meeus solar position is computed per hour. Per hour and orientation: DNI × cos(incidence) + DHI × 0.5 (isotropic sky share for a vertical plane) + GHI × 0.2 albedo × 0.5 ground share. Irradiance comes from the same modelled year.
• Fidelity: Standard method. It is the isotropic-sky (Liu–Jordan) hand method on modelled irradiance.
• Professional equivalent: Ladybug Incident Radiation or ClimateStudio (Radiance with a cumulative sky), and EnergyPlus's Perez anisotropic sky on the real geometry with context shading.
• Trust it for / don't use it for: Trust it for ranking orientations and the south-versus-west trade. Don't use it for PV yield or glazing heat-gain loads.
• The gap:
  • The isotropic sky spreads circumsolar diffuse evenly, so it understates sun-facing façades and overstates north ones relative to Perez.
  • No shading from terrain, neighbours or the building itself.
  • Sun position is computed at each hour's timestamp, while Open-Meteo documents its radiation variables as the mean of the preceding hour. Incidence is therefore evaluated about 30 minutes after the middle of the hour it describes, and an hour whose end-stamp falls after sunset is left out even though it carried sun. This matters most on east and west façades.
• Code: src/lib/site-analysis/climate.ts (facadeSolar), src/lib/site-analysis/geo.ts (solarPosition, sunPaths)

.epw export

The climate year as an EnergyPlus weather file, and the pipe to Eco-Architect and Skin.

• What it adds: A downloadable .epw and the same file handed to other tools through localStorage.
• Method: Eight header lines and 8,760 rows, with the leap day dropped.
  • Written: dry bulb, dew point, RH, pressure, GHI, DNI, DHI, wind, and sky cover (cloud ÷ 10, written to both total and opaque).
  • Left as EPW missing codes: illuminance, IR, visibility, precipitation and the rest. DESIGN CONDITIONS and GROUND TEMPERATURES are 0.
  • Header: says "NOT a measured TMY".
  • Refusal: it refuses to write if the year is not 8,760 hours.
  • Hour labels: each row's hour is Open-Meteo hour + 1.
• Fidelity: Screening estimate.
• Professional equivalent: TMYx files (climate.onebuilding.org), NREL NSRDB TMY (satellite-derived irradiance), Meteonorm.
• Trust it for / don't use it for: Trust it for early Ladybug and Honeybee comparisons at a site with no nearby station file. Don't use it for energy-code compliance, LEED or equipment sizing.
• The gap:
  • One actual year, not a typical year.
  • Modelled irradiance.
  • Illuminance fields are missing, so daylight-illuminance workflows that read them fail.
  • Opaque sky cover is copied from total cover.
  • Each row is one hour later than the hour it describes. Open-Meteo stamps temperature, humidity, wind and pressure as instants at the timestamp and radiation as the mean of the preceding hour, which is already EPW's convention for hour N (radiation over the hour ending at N, instants at N). With the +1 mapping, Open-Meteo's 13:00 values are written to EPW hour 14, so allow for the one-hour offset when hourly timing matters.
• Code: src/lib/site-analysis/exporters.ts (climateEPW), src/app/(app)/site-analysis/site-pipe.ts

Flood (FEMA NFHL)

The flood zone at the point, and the zones and BFE lines across the box.

• What it adds: The zone, subtype, SFHA yes/no and static BFE at the survey point. It separates a mapped Zone X from an unmapped area by testing FIRM panel coverage. Zone polygons (up to 200 records) and BFE lines (feet, NAVD88) are clipped to the box and exported as curves.
• Method: NFHL layer 28 point query, then layer 3 (panels) if no zone is found. Vectors come from layers 28 and 14 via an envelope query, generalised to 1/2000 of the box, and are clipped with Sutherland–Hodgman / Liang–Barsky.
• Fidelity: Same engine. The same effective NFHL data a FIRMette is printed from, where the NFHL is digitised.
• Professional equivalent: A FIRMette from the FEMA Map Service Center. An elevation certificate by a surveyor (structure elevations against BFE). A LOMA or LOMR. The local floodplain administrator. For risk beyond the regulatory map: First Street-type models or HEC-RAS.
• Trust it for / don't use it for: Trust it for whether the point or any part of the box is in an SFHA, and where BFE lines run. Don't use it for insurance ratings, lender determinations or finished-floor elevations.
• The gap:
  • The zone card is the centre point only. The polygons show the rest, but no per-structure read.
  • Preliminary or pending maps and paper-only FIRMs are not in the NFHL. The code treats "no panel" as unmapped.
  • No ground elevations relative to BFE unless you compare against the coarse grid yourself.
  • The regulatory map excludes pluvial flooding and future conditions.
• Code: src/lib/site-analysis/datasources.ts (floodAt, floodVectorsAt)

Soils (USDA SSURGO)

The mapped soil at the survey point.

• What it adds: Map unit name, drainage class, hydrologic group (A–D), minimum annual water-table depth, depth to bedrock, available water storage (0–100 cm), flood frequency, hydric percentage, representative slope, and the SSURGO ratings for dwellings without basements and small commercial buildings.
• Method: One T-SQL POST to Soil Data Access joining mapunit to muaggatt (dominant condition) for the map unit intersecting the point. NOTCOM or empty units count as no coverage.
• Fidelity: Same engine. It is the same database Web Soil Survey reads.
• Professional equivalent: Web Soil Survey over a drawn area of interest (area-weighted ratings across all units). A geotechnical investigation: borings with SPT, lab tests, a bearing-capacity and settlement recommendation. Percolation or infiltration tests for stormwater.
• Trust it for / don't use it for: Trust it for early flags: hydric soils, D-group runoff, shallow water table or bedrock, "very limited" for dwellings. Don't use it for foundation design or infiltration sizing.
• The gap:
  • One map unit at one point, even in a 5 mi box.
  • Map units are drawn at county survey scale and include dissimilar components; "dominant condition" hides them.
  • Urban and fill soils are poorly characterised.
  • Nothing below about 6.6 ft (2 m).
  • Water-table and bedrock depths are delivered in cm (converted for display).
• Code: src/lib/site-analysis/layers.ts (soilsAt)

Bedrock geology (Macrostrat)

The mapped geologic unit under the point.

• What it adds: Unit name, age and lithology from the point query, plus a Macrostrat tile overlay and drape.
• Method: Macrostrat geologic_units/map at the point. It is a harmonised compilation of state and national geologic maps.
• Fidelity: Same engine for the map. It says nothing about depth.
• Professional equivalent: The state geological survey's quadrangle map. Boring logs to refusal. Seismic refraction for depth to rock.
• Trust it for / don't use it for: Trust it for the regional story (karst, glacial till over limestone). Don't use it for depth to rock or excavation difficulty.
• The gap: Map scale varies widely by area. Surficial deposits may be what matters, not bedrock. There is no depth.
• Code: src/lib/site-analysis/layers.ts (geologyAt)

Groundwater (USGS NWIS well)

The nearest real depth-to-water reading.

• What it adds: Well name, distance, latest depth to water in feet (parameter 72019) and date. The well is drawn on the map.
• Method: NWIS gwlevels in a ±0.15° box (~10 mi north–south, somewhat less east–west), over the last 1,095 days. It takes the nearest well's most recent non-negative reading.
• Fidelity: Classroom proxy as a reading of this site's water table. The number itself is a real measurement, somewhere else.
• Professional equivalent: Groundwater levels logged in geotechnical borings. Piezometers or monitoring wells on site. On a contaminated site, the monitoring-well network in the remedial investigation.
• Trust it for / don't use it for: Trust it for whether groundwater is plausibly shallow in the area. Don't use it for basement or dewatering decisions.
• The gap: The well can be miles away, in a different aquifer (confined or deep) and at a different ground elevation. It is one reading, not a seasonal high. SSURGO's water-table field is often the better local proxy.
• Code: src/lib/site-analysis/layers.ts (groundwaterAt)

Wetlands (USFWS NWI)

Whether the point sits in a mapped wetland.

• What it adds: The Cowardin code, wetland type and polygon acreage at the point (null on dry ground, not counted as a coverage failure), plus a map overlay and drape.
• Method: NWI MapServer point query.
• Fidelity: Same engine. It is the same NWI data.
• Professional equivalent: A wetland delineation by a qualified delineator to the 1987 USACE manual and regional supplement. A USACE jurisdictional determination.
• Trust it for / don't use it for: Trust it as a red flag that triggers a delineation. Don't use it to conclude there are no wetlands.
• The gap:
  • NWI is photo-interpreted, often decades old, and not jurisdictional. It misses small and forested wetlands.
  • The point query checks one point; the overlay shows the rest visually only.
  • The AI synthesis does not see this result.
• Code: src/lib/site-analysis/layers.ts (wetlandAt)

Land cover (NLCD 2021)

What covers the ground: class, impervious share, tree canopy.

• What it adds: NLCD class, % developed impervious and % tree canopy at the point, plus three overlays and drapes.
• Method: Three MRLC WMS GetFeatureInfo reads of the centre pixel of a 101-pixel render. The layers are NLCD_2021_Land_Cover_L48, NLCD_2021_Impervious_L48 and nlcd_tcc_conus_2021_v2021-4 (lower 48 only).
• Fidelity: Same engine. It is the NLCD product at its 98 ft (30 m) cells.
• Professional equivalent: A tree survey by an arborist. A planimetric survey of impervious area (what stormwater fees are billed on). High-resolution (~3 ft / 1 m) land cover from aerial imagery. i-Tree for canopy benefits.
• Trust it for / don't use it for: Trust it for neighbourhood character and the rough impervious share. Don't use it for stormwater credit calculations or tree-preservation plans.
• The gap:
  • A 30 m pixel read at one point.
  • 2021 vintage.
  • Alaska and Hawaii are not covered by these layers.
• Code: src/lib/site-analysis/layers.ts (landCoverAt), src/lib/site-analysis/map-layer-urls.ts

Watershed & surface water

Which watershed the site is in, and the streams around it.

• What it adds:
  • HUC12 and HUC8 names and codes, HUC12 area, and the HUC12 boundary.
  • Map overlays: USGS NHD surface water, and a bold "rivers and streams" layer drawn from the OSM surroundings.
• Method: WBD MapServer layers 6 and 4 point queries. The boundary is generalised to about 130 ft (40 m).
• Fidelity: Same engine.
• Professional equivalent: USGS StreamStats, which delineates the catchment to your own outlet and gives regression peak flows. An engineer's drainage-area map.
• Trust it for / don't use it for: Trust it for the receiving waters and the watershed plan that may govern. Don't use it for the area draining onto your parcel.
• The gap: A HUC12 is typically tens of square miles. The site-scale catchment is what Drainage approximates, truncated at the box.
• Code: src/lib/site-analysis/layers.ts (watershedAt)

Seismic (USGS, ASCE 7-16)

Seismic design parameters for an early Seismic Design Category.

• What it adds: Ss, S1, SDS, SD1 and SDC.
• Method: USGS building-codes/asce7-16/calculate with siteClass=D, riskCategory=II.
• Fidelity: Same engine for ASCE 7-16 at the assumed inputs.
• Professional equivalent: The ASCE Hazard Tool or the USGS web service for ASCE 7-22, which IBC 2024 references, with site class from a geotechnical report (measured shear-wave velocity or SPT). ASCE 7-22 adds intermediate site classes (BC, CD, DE) and multi-period spectra. Its default for unknown soil (§11.4.3) is the most critical of Site Classes C, CD and D at each period, not simply D, unless the authority having jurisdiction finds DE, E or F soils.
• Trust it for / don't use it for: Trust it for whether seismic design will shape the structure (SDC A/B versus D+). Don't use it for design values.
• The gap:
  • Superseded edition. It may still match a local code if the jurisdiction is on IBC 2018 or 2021; check.
  • Site Class D is assumed; soft soils (E/F) or rock change the values materially.
  • Risk Category II is assumed; schools and essential facilities differ.
  • One point.
• Code: src/lib/site-analysis/layers.ts (seismicAt)

EPA NPL record & boundary

EPA's own record of a listed site (Superfund mode) and the NPL dots layer (either mode).

• What it adds: Covered under Mode · Superfund. Separately, "show all Superfund sites" scatters every NPL site in the current view (refused past 30° across). Clicking a dot runs a full Superfund survey.
• Method: ArcGIS FeatureServer queries on EPA's NPL and boundary layers.
• Fidelity: Same engine.
• Professional equivalent: EPA SEMS / Cleanups in My Community. The NPL section of a Phase I database report.
• Trust it for / don't use it for: Trust it for the listing status and the documents. Don't use it as a proximity search for other contamination.
• The gap: NPL only. The boundary is administrative, and holes are drawn filled.
• Code: src/lib/site-analysis/datasources.ts, src/app/api/site-analysis/search/route.ts

OSM surroundings

Buildings, roads, rail, water and green space around the site.

• What it adds: Footprints extruded as solids, linework by class, water and green. They are used by sun hours, sections, the rivers layer and every export.
• Method: Overpass API (two mirrors). Results are fetched for the terrain bbox and clipped to it. Above 2.8 mi (4.5 km) only the central sub-box is fetched and flagged partial. Heights come from tags, else 10.5 ft (3.2 m) per level, else a default.
• Fidelity: Screening estimate. Community-mapped geometry of uneven completeness, with guessed heights.
• Professional equivalent: City or county planimetric GIS. The surveyed topo (buildings, curbs, utilities). Lidar-derived building heights or a city 3-D model.
• Trust it for / don't use it for: Trust it for context massing and street pattern. Don't use it for setbacks, adjacency distances or exact heights.
• The gap:
  • Completeness varies by town.
  • Untagged heights are guessed.
  • No trees, fences or topography of roofs.
  • Partial at 3 and 5 mi.
• Code: src/lib/site-analysis/layers.ts (contextInBBox, overpassSafeBox), src/app/api/site-analysis/context/route.ts

Traced parcel

Your own boundary, drawn on the map (Place mode).

• What it adds:
  • An orange boundary with acreage.
  • Terrain statistics recomputed over the parcel only.
  • Exports on the boundary layers.
  • Saved with the site and carried in share links.
• Method: Validation rejects degenerate or self-intersecting rings. Acreage is the shoelace area in the local projection. clipTopoToParcel masks cells outside the ring (parcel.ts).
• Fidelity: Authoring.
• Professional equivalent: County parcel GIS or Regrid for the assessor's line. An ALTA/NSPS or boundary survey for the legal one.
• Trust it for / don't use it for: Trust it for studying the ground you intend to design on. Don't use it for area-based zoning math on a real lot.
• The gap:
  • It is as accurate as your clicks on a web basemap.
  • The AI synthesis does not see the traced parcel; it reads the whole-box result.
• Code: src/lib/site-analysis/parcel.ts, src/app/(app)/site-analysis/site-analysis-tool.tsx

Section cut

A site section between two points you drop.

• What it adds: A ground profile with OSM buildings (at tagged or estimated heights) and water crossings. Fabricated ground is drawn dashed. Output is SVG and DXF.
• Method: 400 evenly spaced samples of the bilinear grid along the line. Crossings are found by sampling footprints along the line.
• Fidelity: Authoring on Same engine ground.
• Professional equivalent: A Civil 3D section view from a surveyed surface, or a Rhino section through a surveyed model.
• Trust it for / don't use it for: Trust it for studio site sections and a vertical-exaggeration read of landform. Don't use it for grading sections.
• The gap: Ground detail is limited to the span's grid spacing. Building heights are OSM's. There are no trees or below-grade structures.
• Code: src/lib/site-analysis/section.ts, src/app/(app)/site-analysis/section-card.tsx

AI reading passes

Five optional model passes: sign-in, metered, and none of them overwrite a measured number.

• What it adds:

  • Sources. Automatic when a place lands: authoritative links.
  • Chat. "Ask about this place".
  • Contamination brief. Superfund mode only.
  • Design synthesis.
  • Blind vs grounded. The hallucination lesson.

• Method:

  • Tiers. Fast = Claude Haiku 4.5 (default). Deep = Claude Sonnet 5. Open = an env-gated open-weight MiniMax model; the sources and blind-vs-grounded passes refuse Open. A stalled attempt retries on the fast model with a smaller search budget.
  • Sources get the place plus the bundle (≤24,000 characters), with web search capped at 4 uses behind a deny-list.
  • Chat gets the dossier (≤60,000 characters, 16 turns), with 4 searches.
  • Contamination gets the EPA record re-fetched server-side, with 5 searches.
  • Synthesis gets the compacted client bundle (≤200 KB) with no search. The bundle holds climate, flood point, terrain statistics, soils, land cover, watershed, seismic, geology, groundwater and the contamination brief. It does not include wetlands, drainage, sun hours, OSM surroundings (buildings) or the traced parcel.
  • Blind vs grounded runs the same profile prompt with no tools and with 5 searches.

• What is checked: Link probing is uneven across the passes:

  Pass	Links probed (HEAD, then GET) before render?
  Sources	Yes, unless the soft timeout fired
  Chat	Yes, unless the soft timeout fired
  Contamination	Yes: sources and every claim link are probed; dead links are dropped or blanked
  Synthesis	No: deny-list and scheme check only (the pass is asked to return no links)
  Blind vs grounded	No, deliberately

  Claims are tagged verified / plausible-unverified / likely-hallucination. The rule that an ungrounded pass may tag nothing "verified" describes what the prompt asks for; it is not a check enforced in code. The synthesis prompt forbids new figures and demands cross-layer intersections.

• Fidelity: AI reading.

• Professional equivalent: A human researcher or environmental professional doing an ASTM E1527 records review and interviews. A landscape architect's site-analysis narrative.

• Trust it for / don't use it for: Trust it for a reading list, questions to ask, and a synthesis that cross-references measured layers. Don't use it for contaminant lists, institutional controls or anything quoted as fact without opening the source.

• The gap:

  • "Verified" is the model's self-report against pages it found. Links are checked for being reachable, not for supporting the claim.
  • The contamination card's "(EPA-grounded)" title describes what the prompt asks for, not a code-enforced check; it appears on every run, including an Open-tier run without web grounding.
  • The studio sites' cached readings were not produced by this pipeline (see Superfund).

• Code: src/app/api/site-analysis/{sources,chat,contamination,synthesis,blind-vs-grounded}/route.ts, src/lib/anthropic/site-analysis-prompts.ts, src/lib/anthropic/link-check.ts, src/lib/anthropic/source-quality.ts

Shared across all options

• Fetching. Every fetch is keyless, runs in parallel, and degrades to null. A coverage strip names what failed. Terrain, flood, soils, land cover, watershed, wetlands, wells and seismic are US-only. Climate and OSM are global.
• Projection. One equirectangular local projection about the box's south-west corner registers terrain, contours, boundary, context and every export.
• Units. Units display imperial by default (with a metric toggle). The data stays SI.
• Exports. Exports are client-side and ungated:
  • .3dm kit as surfaces and as mesh
  • .obj kit
  • .dxf contours, surroundings and boundary
  • .geojson
  • .epw
  • metrics CSV
  • Dossier JSON/MD
  • atlas PNG/SVG
• Hand-offs. Grade, Eco-Architect, Proving Ground, Skin and Relief receive the grid, identity and .epw through one localStorage key. All exports inherit the span's grid spacing (Authoring).
• Share links. A share link or saved site stores the request (mode, span, point or EPA ID, parcel), not the result, so it re-runs against live sources.

• Our method:
  • Existing ground. /api/grade lays a fixed 48 × 48 lattice over ±0.008° (about 1.1 × 0.85 mi at Illinois latitudes). Each node is one point sampled from the 3DEP getSamples service, in chunks of 500. Node spacing is about 95 × 125 ft (29 × 38 m), and the UI always asks for 48 × 48. SSURGO bedrock and water-table depths come from one point query.
  • Proposed surface. Pads and benches are rasterised onto the nodes by point-in-polygon. Outside each footprint, side-slope cones daylight to existing ground; the defaults are cut 2H:1V (50%) and fill 3H:1V (33%) (the code writes these as "1:2" and "1:3", vertical to horizontal). A node claimed by both a cut cone and a fill cone is flagged as a retaining condition.
  • Volumes. Four-corner prism per cell: the mean of the four corner height differences × cell area. Cells straddling the cut/fill line are supersampled 4×4 and 8×8 bilinearly, and the difference between the two passes is printed as the error bar.
  • Bank, loose, compacted. Loose = bank × (1 + swell); fill needs compacted ÷ (1 − shrink) of bank material. The factors are handbook ranges stamped UNVERIFIED in the code, for example common earth swell 15–35%, shrink 8–25%. Trucks are counted at 12 yd³.
  • Balance. Bisection on net volume, up to 60 halvings.
  • No AI.
• The professional method:
  • Existing surface. Civil 3D builds a TIN from surveyed spot shots and breaklines (curbs, toes, tops of bank), or from 1 m lidar.
  • Proposed surface. Built from feature lines and grading objects with true daylight projection.
  • Volumes. Computed TIN-to-TIN (prismoidal on the combined triangles, exact for the two TINs) or by average end area along corridors.
  • Other quantities. Estimators add topsoil stripping, unsuitable-material undercut, haul (mass-haul diagrams) and compaction by lift, using factors from the geotechnical report.
• The gap, specifically:
  • Sampling dominates the error, and the printed error bar does not include it. The ± figure measures only discretisation within straddling cells. It says nothing about the roughly 100 ft gaps between measured points. Terrain between nodes is assumed bilinear, and a swale, berm or bank between samples is invisible.
  • Footprint quantisation. A pad is rasterised at nodes roughly 12,000 sq ft (1,100 m²) apart, so a 100 × 150 ft building pad captures one or two nodes. Its volume can be off by a large fraction, often ±50% or worse. Large terraces of several acres converge far better.
  • Missing quantities. No topsoil strip, undercut, rock or haul distance. All of these usually add cost and volume, so real earthwork generally exceeds the geometric figure.
  • Unvalidated factors. Swell and shrink come from generic ranges, not the geotechnical report.
• Where ours is as good or better:
  • The integration is correct and tested. Straddling cells are split so cut and fill don't cancel, which a naive spreadsheet borrow-pit does not do.
  • Bank, loose and compacted volumes are separated explicitly, and the balance solver is a teaching instrument Civil 3D does not foreground.
  • It is instant, needs no license, and runs on real terrain.
• Code: src/lib/grade/earthwork.ts, src/lib/grade/surface.ts, src/lib/grade/materials.ts, src/app/api/grade/route.ts, src/lib/grade/dem.ts

• Our method:
  • Parsing. The shared parseEPW (Gable Studio weather.js) reads ten columns: dry-bulb, dew point, RH, pressure, GHI, DNI, DHI, wind direction, wind speed and sky cover. EPW missing-value sentinels (99.9/999/9999/999999) become NaN.
  • Aggregation. Monthly means and Wh-sum totals. Design temperatures are the sorted hourly dry-bulb read at rank round(p·(n−1)), p = 0.004 and 0.996. The wind rose uses 16 sectors, speed edges at about 1.1/4.5/9/13.4/17.9/22.4 mph (0.5/2/4/6/8/10 m/s), and calm below 1.1 mph (0.5 m/s).
  • Psychrometrics. The hour cloud uses Arden Buck saturation pressure and w = 0.622·pv/(P − pv) at the file's mean station pressure.
  • Strategy shares. climateFingerprint uses fixed zones: comfort 68–81°F (20–27°C), w ≤ 0.012, RH ≤ 80%; passive solar down to 53°F (11.5°C); ventilation to 90°F (32°C); mass to 91°F (33°C) when the swing is ≥ 14°F (8°C); evaporative when Stull wet-bulb ≤ 72°F (22°C). Displayed in °F.
  • Sun path. Computed from latitude and longitude with the NOAA algorithm.
  • No AI and no upload.
• The professional method:
  • Design temperatures. ASHRAE derives them from long station records (a multi-year period of record), not from a TMY.
  • Climate Consultant. Plots the Givoni/Milne zones with editable ASHRAE-55/adaptive criteria and daily-range-based mass and night-flush zones, plus many more charts.
  • Ladybug and CBE Clima. Ladybug computes PMV, adaptive and UTCI comfort with MRT, wind and clothing inputs; CBE Clima computes UTCI scenarios and the adaptive comfort model from the same EPW.
• The gap, specifically:
  • Design temperatures from a TMY are biased mild. A typical year is stitched from typical months, so extremes are under-represented. The 99.6%/0.4% values will usually be less extreme than ASHRAE's station values, often by a few °F (the size varies by station; unverified).
  • The mass share is overstated. The fingerprint's "diurnal swing" input is the monthly max − min averaged over the year, which is much larger than the true daily range. In most climates it clears the 14°F (8°C) mass gate year-round, so thermal mass is credited in humid, low-swing climates where it helps little.
  • The comfort zones are fixed, air-temperature-only teaching boxes: no MRT, air speed, clothing or metabolic rate.
  • No precipitation, snow, illuminance or ground temperature.
• Where ours is as good or better:
  • Parsing and charts are equivalent in accuracy to Climate Consultant for the same file, and faster to read on one page.
  • It is fully client-side, and the parser is shared (parity-tested) with the toolkit's energy tools, so what you read here is what they simulate with.
• Code: public/tools/gable-studio/web/v2/weather.js, public/tools/gable-studio/web/core.js, src/lib/almanac/psychro.ts, src/lib/almanac/adapt.ts, src/app/(app)/almanac/AlmanacTool.tsx

• Our method:
  • Canvases. Three canvases: the visible paper, an offscreen mask and a scratch layer. The paper is 1,200 × 900 px. Loading a reference rescales the paper so its long side is exactly 1,400 px, which is also the export size.
  • Operations. Each operation is recorded in a list and drawn onto the mask with Porter–Duff compositing (destination-out for erase, destination-in to clip the style). Undo replays the list.
  • Flood fill. Scanline fill treating alpha ≤ 30 as empty.
  • Nolli view. A 16% tint under a 45° hatch.
  • Export. SVG writes rectangles, polygons and strokes as true vector. Any flood-fill operation turns the whole SVG into one embedded PNG.
  • Coverage. Measured on a 120 × 90 downsample.
  • No data and no AI.
• The professional method:
  • GIS. GIS footprints are measured polygons in a projected CRS, so the figure-ground is to scale, and area coverage and grain metrics can be computed from them.
  • Illustrator. Tracing gives unlimited resolution, layers and precise paths.
• The gap, specifically:
  • No scale, north arrow or units.
  • Maximum 1,400 px output.
  • No persistence across reloads.
  • A flood fill breaks the vector export.
  • Accuracy is only as good as your hand. A GIS figure-ground is measured, not traced.
• Where ours is as good or better:
  • Zero setup.
  • Works on any image, including historic maps (Nolli's own 1748 plan is the archetype) where no footprint data exists.
  • The reference is never exported, and figure versus Nolli poché is one toggle.
• Code: public/tools/figure-ground/index.html, src/app/(app)/media-2d/figure-ground/page.tsx

• Our method:
  • Image preparation. Images are rescaled client-side to a long edge of 1,568 px or less; up to 3 images per read.
  • The read. Any image-carrying pass is pinned to the Fast tier (Haiku 4.5), except on the Open tier, which visionTier passes through. Grounded mode adds up to 4 text-only web searches. Search results are filtered by a domain deny-list (up to 64 domains) and ranked official > academic > institution > press.
  • Parsing. The JSON comes back unforced in grounded mode and is recovered by a fenced-block parser.
  • Wikidata. A single read searches once and scores the top 3 entities (enrich.ts); the batch filename/text ladder allows at most 4 searches and 8 entity fetches (filename-hint.ts). The scorer vetoes (−10) a "not-a-work" description without architect or coordinates evidence, and an architect contradiction scores −10. Nothing under a score of 4 is accepted. The Wikidata label overrides the model's naming.
  • Reverse image. Google Vision web detection, with SerpApi Lens only when Vision is unconfigured or throws (an empty Vision answer does not trigger it).
  • Verified mark. Only the user can set "verified"; no model path can.
  • Batch. Fast tier, no web search, leads from filename parsing, reverse-image search and the text the vision read transcribes from the image.
• The professional method:
  • A cataloguer identifies from provenance: the archive's accession record, the publication the image came from, the photographer's credit.
  • Cataloguers use controlled authorities (ULAN, AAT, LCNAF) and full-text databases (Avery, Artstor).
  • Reverse-image engines are used to trace the image's first publication.
• The gap, specifically:
  • Hallucinated identifications. The model can confidently name the wrong building. The guard is the Wikidata scorer's veto and the fact that the model never sets "verified". A plausible wrong candidate that happens to match a real Wikidata entity (same architect, similar name) can still pass.
  • Coverage bias. Wikidata and the web cover famous buildings well and minor or regional work poorly, so accuracy drops sharply off the canon.
  • Search links are not probed. Opened sources are deny-listed and tiered, but unlike the Surveyor and Interlocutor they are not HTTP-probed for liveness.
  • Model and image limits. The Fast tier and three images cap how much a drawing set can be read.
  • No archive matching. No image-archive matching at all (a deliberate choice), and no provenance chain.
• Where ours is as good or better:
  • Combines vision, reverse-image and authority lookup in one step with explicit confidence.
  • The catalogue paragraph must state what remains unverified.
  • The batch reconciler cannot overwrite fields the user pinned.
  • Much faster than manual triage of a shoebox of downloads.
• Code: src/app/api/librarian/route.ts, src/lib/library/wikidata.ts, src/lib/library/reverse-search.ts, src/lib/anthropic/cost-policy.ts, src/app/api/librarian/batch/route.ts

• Our method:
  • Plot and cells: 6 × 6 cells of 16 ft (5 m) each. Moisture is a base value plus a linear east–west gradient; fertility is uniform.
  • Sowing: default about 570 stems per acre (0.14 stems/m²), randomly placed. Each stem gets its own traits: growth rate ±8% (Gaussian), shade and drought tolerance ±0.05.
  • Light and growth, each year: stems in a cell are sorted tallest first, and each gets light = e^(−2.0 × crown area above / cell area). Crown radius grows by k·(crownMax − size)·light^(1−shadeTol)·moistMatch, where moistMatch is a Gaussian around the species' moisture optimum.
  • Mortality: 1 − (1−bg)(1−stress)(1−crowd)(1−below), capped at 0.96. The four hazards are:
    • background, 0.40/longevity
    • growth stress, 0.06
    • crowding once the cell's crown load passes 1.15, coefficient 0.05
    • a below-ground shortfall against supply 0.9 + 3.4·moisture·fertility, coefficient 0.18
  • Seeding: mature stems (age ≥ 10% of longevity, clamped to 6–28 yr) cast up to 6 seeds a year on an exponential kernel. Sown species also get a 0.6% per-cell background seed rain.
  • Establishment: probability = 0.35 × light^(1.8·(1−shadeTol)) × moistMatch × (0.5 + 0.5·seedMass). Capped at 900 recruits a year and 4 per cell.
  • Cover: 1 − e^(−1.30·Σcrown/area). Closure is the first year cover reaches 60%.
  • Ensemble: 20 runs with Beer ±12%, establishment ±15%, stress ±15%, background ±12% and below-ground ±15%.
  • No data is fetched and there is no AI.
• The professional method:
  • SORTIE-ND computes each tree's light from 3-D crown geometry over the whole sky hemisphere. Its growth, mortality and recruitment functions are fitted to field plots from specific forest regions.
  • FVS projects stand tables with growth equations fitted to regional inventory data (FIA).
  • LANDIS-II models species-age cohorts across real landscapes with fire, wind, harvest and browse disturbance modules.
• The gap, specifically:
  • Uncalibrated traits: growth rates, longevities and fecundities are illustrative (the page footer says so). Every timing is therefore uncertain by an unknown factor, not by a known ± value.
  • Light: one 16 ft cell, with no side light and no sun angle. Edge stems and gap edges get no lateral light, so gap-phase regeneration is understated.
  • No herb or shrub layer and no browse: in the eastern US, grass competition and deer browse commonly suppress tree establishment for decades. Leaving them out makes closure come too early.
  • No soil, no seed bank, no invasives, no disturbance regime beyond what the rate constants imply.
  • The spread is not a confidence interval: it comes from a fixed ±12–15% jitter on five constants, not from measured parameter uncertainty.
• Where ours is as good or better: Speed (an ensemble runs in seconds in the browser), transparency (every constant is in one HTML file) and teaching value. Showing a distribution of futures instead of one render is more honest than a "mature planting" rendering.
• Code: public/wilding-prototype.html, src/app/(app)/wilding/page.tsx

• Our method:
  • Grid: default 30 × 30 cells on a 720 px square sheet. Each community carries a capacity and a time constant (for example woodland capacity 0.95, τ 12; old field capacity 0.60, τ 26).
  • Moisture, each year: soil class (sand 0.28 / loam 0.46 / clay 0.60), plus water proximity 0.55·e^(−d/2.6) (d from a multi-source breadth-first search), minus drought 0.30, plus canopy retention 0.10·canopy. It is then blended 35% toward the neighbourhood mean.
  • Cover: grows by r·(cap − cover), where r = 1/(τ·(1.2 − 0.5m)). Cells are also colonised from the highest-cover 4-neighbour.
  • Light: e^(−2.2·shadeKnob·blurred canopy). Pioneers are suppressed by that light term, and canopy accrues from cover above 0.35.
  • Mycelium: diffuses into vegetated neighbours.
  • Marks: one geometry pass turns the driver fields into primitives. Stipple uses a jittered lattice with stored thresholds, so fills accrue without re-scattering. Hatches are Liang–Barsky-clipped sweeps, and cross-hatch is a second pass at +78°. The mycelium web uses Runions space colonisation. The same primitive list is drawn to Canvas2D live and to SVG on export.
  • Wilding import: can instead import a Wilding run through the landscape_mosaic localStorage key.
  • No data and no AI.
• The professional method: In pro drawing tools the designer places hatches and symbols by hand or from a pattern library. Time-based vegetation is shown as discrete phase drawings. Some render engines (Lumion, Twinmotion, Laubwerk plant models) offer plant age or season variants (feature details unverified), but not a succession process driving the linework.
• The gap, specifically:
  • No dimensions, layers-by-object or plant schedule. It is a single-sheet drawing, not a CAD/BIM plan.
  • The succession model is stylised: capacities and time constants are tuned to look plausible, not fitted to data. The years are therefore illustrative.
  • The grammar is a convention you author, not a standard (the page says "a drawing system, not measured data").
• Where ours is as good or better: It is the only tool here that makes the drawing itself a function of process: marks accrue, thin and pulse with the model. Output is resolution-independent SVG identical to the screen, and building a representation grammar is itself useful teaching.
• Code: public/hatchling-prototype.html (simulate(), the marks pass and the SVG backend), src/app/(app)/hatchling/page.tsx

• Our method:
  • Beams: f_n = λ²_n/(2π)·(r/L²)·√(E/ρ), with λ² = 3.516015 / 22.034492 / 61.697214 (cantilever), π², 4π², 9π² (simply supported) and 22.3733 / 61.6728 / 120.9034 (fixed-fixed). r = d/4 for a rod, t/√12 for a blade.
  • String: f_n = n/(2L)·√(T/μ).
  • Membrane: f = α/(2πa)·√(Ts/σ), with J₀ zeros 2.404826 / 5.520078 / 8.653728.
  • Hand on the element: a Rayleigh tip mass, f × 1/√(1 + m/(0.2357·m_beam)).
  • Materials: nine handbook entries (for example softwood E = 11 GPa, ρ = 420 kg/m³).
  • Listen tab: up to 24 Hann-windowed frames of 16,384 samples at half-frame hop, then the top five peaks between 20 Hz and 6 kHz with parabolic interpolation.
  • Rig: MPU-6050 at ±2 g, 1 kHz sampling, digital low-pass filter off (about 260 Hz accelerometer bandwidth), 500,000 baud. The analysis picks the axis with the most variance and trims the ring-down.
  • Damping fit: linear regression of ln(peak) against time gives σ. Then ζ = σ/√(σ²+ω²), f_n = f_d/√(1−ζ²) and T60 = ln(1000)/σ. The fit is refused with fewer than 4 peaks.
  • Playback: the element's voice is three sines with gains 1, ½, ¼.
  • No AI, and nothing is uploaded.
• The professional method:
  • FE modal analysis: solves the generalized eigenproblem for arbitrary geometry, orthotropic timber, real joint stiffness and added masses. It returns every mode shape, including torsion and plate modes.
  • Experimental modal analysis: fits poles and residues to measured frequency response functions from a calibrated force input.
  • Perception work: uses calibrated displacement or acceleration at the skin, with frequency weightings from the ISO standards.
• The gap, specifically:
  • Membrane modes: only the axisymmetric (0,n) modes are listed. The (1,1) mode at ≈1.59× the fundamental and (2,1) at ≈2.14× are skipped, and an off-centre strike excites them. The listed modes 2 and 3 are therefore the (0,2) and (0,3) modes, not the drum's actual second and third modes.
  • Beams: bending in one plane only. No torsion, no shear or rotary inertia (Timoshenko effects matter for short, thick planks, where frequencies come out lower than predicted), and no orthotropy.
  • Rig bandwidth: with the filter off the accelerometer rolls off near 260 Hz, and that gentle roll-off is the only anti-alias protection below the 500 Hz Nyquist limit. The fingertip optimum (~250 Hz) sits right at the edge of what the rig can verify, and higher modes may alias.
  • Sensor mass: the breakout board and leads add mass, which lowers the measured frequency on light reeds. The calibration step folds this into an "effective E", which is correct for that build but not a material property.
  • Microphone: laptop and phone microphones roll off in the low bass, and the analysis floor is 20 Hz. The 4–8 Hz whole-body band therefore cannot be measured with the Listen tab.
  • No amplitude: no vibration levels (m/s² or µm) are predicted or measured in calibrated units, so the threshold comparison is about frequency only.
• Where ours is as good or better: The design → build → measure → back-solve loop is exactly what an engineer does with a prototype, and the exact eigenvalue constants remove rounding error. It costs a few dollars, gives an answer in seconds, and treats the pluck test as the real datasheet.
• Code: src/lib/resonator/elements.ts, src/lib/resonator/analysis.ts, src/lib/resonator/arduino.ts, src/lib/resonator/band.ts, src/app/(app)/resonator/ListenTab.tsx

• Our method (grove-engine.js):
  • Plot: 98 ft (30 m) square by default. Tree competition uses 16 ft (5 m) buckets.
  • Light and growth: Beer's light e^(−2.0·crown load). Growth multiplier = light^(1−shadeTol) × moistMatch × (0.55 + 0.45·fertility).
  • Mortality: five compounding hazards (the same four as Wilding plus windthrow 0.006 × (size/crownMax) × (age/longevity, capped at 1.6)), capped at 0.97. Stems in waterlogged cells take an extra 0.22 × (1 − flood tolerance).
  • Masting: every 5 years heavy-seeded species get a 1.9× fecundity boost.
  • Soil and ecosystem fields: a parallel field grid (5 ft / 1.6 m cells, 12–44 a side) steps light (e^(−2.2·density)), moisture, litter, deadwood, humus and mycelium each year, and these feed back into establishment.
  • v2:
    • A seedling with a surviving parent takes traits = species mean × r + parent × (1−r), with r = (1 − heritability)/2 and heritability 0.55.
    • It then mutates with σ = 0.05 × (0.4 + 1.1 × plasticity). Plasticity is 0.9 for pioneers and 0.4 for climax species.
    • Establishment is divided by (1 + 0.6·own-species density) and multiplied by (1 − 0.7·others' allelopathy).
  • v3:
    • 16 members, with the same year-0 stand in each.
    • Each member redraws k and longevity uniformly inside a range (for example red oak k 0.042–0.062, longevity 150–300 yr) cited to Silvics of North America (paired with i-Tree Species or the USDA hardiness map) for the twelve trees; these ranges are informed by the sources, not a per-species calibration. Uncited species get ±30%.
    • Hardiness: site zone plus a "warming" step (0 = 2012, 1 = 2023, 2 = 2023 + 1).
  • Drawing: a mass-conserving crown splat onto the drawing grid, with cover = 1 − e^(−1.6·occupancy).
  • No AI, no fetch.
• The professional method:
  • Forestry models: calibrated on inventory plots, with explicit crown geometry, site index and disturbance modules.
  • i-Tree: uses measured urban tree growth and mortality rates.
  • Climate suitability: assessed with species distribution models (for example the USFS Climate Change Tree Atlas) or with heat-zone plus hardiness data, not a single cold-hardiness integer.
• The gap, specifically:
  • Structure uncalibrated: even in v3 only two traits vary, and the establishment and mortality functions stay fixed. The band is therefore narrower than the true uncertainty.
  • Hardiness drift is coarse: one warming step adds a full integer zone, which is 10°F. The 2012 → 2023 USDA revision averaged about 2.5°F warmer across the contiguous US: about half the country moved one half-zone (5°F) warmer and the other half did not change. The "2023" setting therefore overstates the shift at least twofold everywhere, and by the whole zone where nothing changed.
  • Hardiness zones measure winter cold only. zoneMax is treated as a heat limit, which USDA zones do not measure; the American Horticultural Society Heat Zone map does.
  • Evolution: 100 years is one to three tree generations. The v2 drift is real selection on standing variation, but its speed comes from the plasticity and mutation constants, not from data.
  • Browse is off by default (browse: 0.0), and there are no invasives. Both make establishment optimistic in eastern-US settings.
• Where ours is as good or better: Nothing in practice lets a designer author the ecology (edit any trait), watch it run and draw it, all in one loop. v3's cited ranges, per-stem kill odds and uncertainty band are more transparent than most research demos.
• Code: public/grove-engine.js, public/grove2-engine.js, public/grove3-engine.js, public/grove3-prototype.html, src/app/(app)/grove/GroveVersions.tsx

• Our method:
  • Map: MapLibre with a WMS GetMap tile template in EPSG:3857 carrying TIME=YYYY-01-01, from dmsdata.cr.usgs.gov/geoserver/mrlc_Land-Cover-Native_conus_year_data. The year slider swaps the template.
  • Trajectory: WMS 1.3.0 GetFeatureInfo per point per year. The query is a 101 × 101 px window around a ±0.0008° box, read at the centre pixel. Palette index = NLCD class code.
  • Requests: 9 years × 9 points = 81 requests, 5 at a time, each with a 14 s timeout that returns null on failure.
  • Buckets: developed 21–24, cropland 81–82, forest 41–43, grass/open 31/52/71, wetland 90/95, water 11–12.
  • Year folding: each year gives a coverage count, shares and a dominant bucket.
  • Grading (opt-in): direction bins at ±0.1 and ±0.3 share change, and a 30% share threshold for a "partial" answer.
• The professional method: GIS zonal statistics count every 30 m pixel inside a drawn polygon for each annual raster: roughly 75–95 pixels for this footprint, not 9. Change products such as Annual NLCD's own change and confidence layers and LCMS add per-pixel change years and model confidence. Historic research layers imagery and maps back to the 1930s or earlier.
• The gap, specifically:
  • Sampling: 9 points instead of ~80–90 pixels. A class covering 20% of the footprint can read 0% or 33% depending on where the grid lands.
  • Resolution: the 100 ft (30 m) pixel cannot see features narrower than about one pixel. "Canopy" here is the forest-class share, not a tree-canopy product (NLCD also publishes a separate Tree Canopy Cover product).
  • Classification error: NLCD classes have published per-class accuracies, and confusions such as pasture/grassland or woody wetland/forest pass straight through the six buckets.
  • Footprint fixed: you cannot draw your site boundary.
• Where ours is as good or better: Zero setup. There is no GIS install, no download and no key, and the whole 1985–2025 record can be scrubbed in seconds. It reads the same federal dataset a GIS analyst would use, and it abstains instead of guessing when a request fails.
• Code: src/lib/palimpsest/nlcd.ts, src/lib/palimpsest/reclass.ts, src/lib/palimpsest/score.ts, src/app/(app)/palimpsest/PalimpsestTool.tsx, src/app/(app)/palimpsest/PalimpsestMap.tsx

• Our method:
  • Ground:
    • The Surveyor's 3DEP ImageServer samples, spaced about 26 ft (8 m), are cut to the plot square and re-datumed.
    • The cut is bilinearly resampled to a 41–97-cell working grid, so a 400 ft plot has ~16 real samples across and 41 working cells.
    • A cut is flagged "under-sampled" below 12 real samples, and "too flat" under 3.3 ft (1 m) of relief.
  • Hydrology:
    • Fill: priority-flood + ε (Barnes, Lehman & Mulla 2014), seeded from the whole boundary on a binary min-heap, with ε = 1e-5 m per cell. Rise above the measured surface greater than 0.4 in (0.01 m) counts as ponding; 6 in (0.15 m) or more becomes the "standing water" band.
    • D8: steepest distance-weighted descent (O'Callaghan & Mark 1984), with diagonals divided by √2. Every boundary cell is an exit.
    • Accumulation: one pass sorted high to low. Each cell counts as plot area divided by n², so accumulated area sums exactly to the plot. Uniform rainfall excess is implicitly assumed.
    • Channels: accumulation ≥ 1.2% of cells (minimum 8), chained head to foot.
  • Painted fields:
    • Moisture: TWI = ln(a/tanβ), with a = accumulation × cell width and β taken from the filled surface (floored at 0.001). It is then converted to a rank within the plot, and ponded cells are pushed up.
    • Exposure: McCune & Keon folded aspect about 225°, (1 − cos)/2, weighted linearly by slope up to a 30% grade. This is the folded-aspect transform, not the full heat-load-index regression with latitude.
    • Fertility: 0.62·(1 − slope rank) + 0.38·rank(log accumulation).
  • Bands, in order of precedence: water; steep (slope ≥ 78%); in a channel → riparian; moisture ≥ 0.86 → marsh; 0.66 / 0.40 / 0.20 cut points with exposure splits at 0.62 / 0.66; ridge below that.
  • Stand:
    • Sown at 170 stems/acre (420/ha); each seed takes with probability 0.35 + 0.65 × moisture match.
    • Height growth is monomolecular, k·hMax·(1 − h/hMax), scaled by light^(1−shadeTol), moisture match, (0.55 + 0.45·fertility) and a heat-stress penalty on hot, dry cells.
    • Light is Beer's law with k = 0.62 over crowns splatted into 9 height strata from 2 ft to 89 ft (0.6–27 m), plus half of the stem's own stratum.
    • Deaths: age hazard 0.06·(age/longevity)⁴; suppression after 12 years below 6% of potential growth; 22% a year when moisture match < 0.08; 0.4% chance.
    • Establishment is refused above 1.3 low-layer or 2.6 total crown layers.
    • Shade and drought tolerance are USDA PLANTS classes; everything else is authored.
• The professional method:
  • GIS terrain analysis: runs the same fill and D8 steps, but usually on 3 ft (1 m) lidar DEMs. Practitioners hydro-condition the DEM first: they burn in culverts and streams, or breach embankments (Lindsay's least-cost breaching in Whitebox) instead of filling behind them. They often compute TWI with multiple-flow-direction (Freeman/Quinn) or D-infinity (Tarboton 1997) routing, and they delineate the full upstream watershed.
  • Runoff design: a rainfall event plus losses (SCS Curve Number, Green–Ampt) and routing through time (unit hydrograph, kinematic wave, or SWMM's dynamic wave through pipes). The outputs are peak flows and volumes.
  • Wetness: field soil survey, hydric-soil indicators, hydrology indicators and water-table data.
• The gap, specifically:
  • No run-on from outside the plot. Hydrology runs on the plot square only, so a channel entering from upslope arrives with zero contributing area. On any plot below a larger catchment this underestimates flow and wetness on the downhill side, possibly by orders of magnitude.
  • Resolution: samples ~26 ft apart, interpolated to ~10 ft cells. Features under ~50 ft, such as roadside ditches, curbs, berms and small swales, are invisible, and interpolated channels look sharper than the data supports.
  • Fill instead of breach: a road embankment with a culvert becomes a filled "pond" upstream. This overstates standing water behind embankments.
  • D8 only: flow concentrates into parallel single-cell lines on planar or convex slopes, so TWI is striped: too high on those lines and too low beside them. This is why most TWI work uses multiple-flow-direction or D-infinity routing.
  • Relative, not absolute: moisture and fertility are ranks within the plot, so a dry site still shows its own "marsh". There is no rainfall, no soil, no infiltration and no water table, which makes the answer wrong on deep sand, hardpan or a perched table.
  • No time and no volume: nothing is computed in cfs or acre-feet.
  • The stand is illustrative: authored growth, longevity and dispersal values.
• Where ours is as good or better: The flow-routing core is the standard algorithm, correctly implemented: the priority-flood heap, √2-weighted diagonals, area normalised so it sums to the plot, and Horn's slope with edge-aware denominators. The tool also states its own sampling limits. It runs in seconds with no GIS setup, and the direct link from landform to planting to drawing is rare even in professional workflows.
• Code: src/lib/swale/hydrology.ts, src/lib/swale/paint.ts, src/lib/swale/stand.ts, src/lib/swale/ground.ts, src/app/(app)/swale/swale.worker.ts

• Our method:
  • Terrain: 81 × 81 samples, either from Surveyor/AWS terrain tiles (3DEP-derived in CONUS, ~13–33 ft / 4–10 m source) or a 390 ft (120 m) demo hillside.
  • Lounges: each is buildModel(params) from the V4 gene catalogue (wall height, width, length, roof pitches, ridge, overhangs, plinth, south window, rotation).
  • Scoring:
    • Solar: six solar keys re-evaluated with Möller–Trumbore rays against all lounges plus the terrain triangles. A solo pass without neighbours isolates the neighbour effect (solo − field).
    • Radiation (full mode only): a Tregenza-145 sky matrix from an EPW, occluded, with diffuse light treated as isotropic.
    • Wind: exposure weighted by the 16-sector EPW wind rose and projected area.
    • Comfort: V4's climate-fingerprint comfort response.
    • Force deck: thirteen weighted terms (seven per-lounge V6 terms averaged over the field, plus the six field terms), each (value − seed)/|seed|, plus a program-hold penalty on floor-area drift.
  • Walker (SPSA, Spall 1992):
    • Two score evaluations per tick at x ± cΔ, with Δ a random ±1 per gene.
    • a_k = 0.12/(k+16)^0.602 and c_k = 0.08/(k+1)^0.101, a momentum step, then clamping to bounds and snapping to each gene's step grid, at about 6 Hz.
    • Walk mode drops the EPW sky matrices and decimates the terrain occluders.
    • By default it negotiates position, level and rotation only; proportions are opt-in.
• The professional method:
  • Ladybug: incident radiation from Radiance's gendaymtx, using the Perez all-weather sky on Tregenza or Reinhart patches, ray-traced against context. Sun hours come from hourly sun vectors.
  • Forma: comparable sun, daylight and wind analyses at neighbourhood scale, including CFD-based wind.
  • Optimisers: Galapagos (genetic algorithm, simulated annealing), Wallacei (NSGA-II Pareto fronts) and Opossum (model-based RBFOpt) search globally or for Pareto trade-offs rather than a single weighted local ascent.
• The gap, specifically:
  • Isotropic diffuse sky, not Perez: this underestimates circumsolar diffuse on sun-facing surfaces and flattens contrast between orientations. The effect is modest for comparing layouts and larger for absolute kWh/m².
  • Walk mode scores analytic solar keys, not EPW radiation: the optimiser climbs a cheaper proxy than the number that gets exported.
  • Wind is a projected-area × wind-rose index with no flow field. It cannot capture channelling between lounges or wake sheltering.
  • A local optimum on unit-free weights: change the weights or the starting layout and you get a different "answer". There is no Pareto front.
  • The cap is a hand-transcribed polygon, not a surveyed boundary or the ROD's institutional-control map.
• Where ours is as good or better: Live, always-on field scoring during manual layout, including the neighbour effect split out per lounge, which few pro workflows show directly. SPSA needs only two evaluations per step whatever the number of genes, which is efficient at this scale. Phased freezing is a clean way to teach path dependence.
• Code: src/lib/ecolounges/metrics.ts, src/lib/ecolounges/objective.ts, src/lib/eco6/gable-walker.ts, src/lib/eco5/metrics.ts, src/app/(app)/ecolounges/EcoloungesTool.tsx

• Our method:
  • Embodied: gableCarbonQuantities re-derives the roof-clipped wall faces, roof faces, apertures and plinth volume from the saved parameters, parity-pinned to the vendored engine to 1e-9. computeEmbodiedCarbon multiplies each layer's thickness × density × ICE v4.0 factor. Examples: softwood "no carbon storage" 0.26259 kgCO₂e/kg; RC25/30 concrete 0.11874; glass-wool density a stated assumption of 1.5 lb/ft³ (24 kg/m³).
  • Replacements: the full component cost at today's factors, at each whole multiple of its service life.
  • Operations: hours × 1.0 kW × grid(year), with the grid falling linearly to endFraction by endYear.
  • Climate:
    • Open-Meteo Climate API daily temperature_2m_mean from MRI-AGCM3-2-S, EC-Earth3P-HR and MPI-ESM1-2-XR.
    • Monthly means (future minus reference) are averaged across models. The offset follows the line through (2005.5, 0) and (2043, Δ) up to 2050.
    • After 2050 the offset is multiplied by (AR6 anomaly(year) − 0.85)/(AR6 anomaly(2050) − 0.85). The anomaly is interpolated from 4.3°F (2.4°C) at 2050.5 to 7.9°F (4.4°C) at 2090.5, then held, so the ratio reaches ≈2.29 ((4.4 − 0.85)/(2.4 − 0.85)).
• The professional method:
  • LCA tools: cover A1–A3 plus A4–A5 (transport, construction), B1–B5, and C1–C4 end of life (module D reported separately). They use product-specific EPDs and component service lives from RICS or product data.
  • Operational energy: simulated hourly with EnergyPlus against the design's envelope, schedules and systems, then multiplied by regional, time-varying emission factors (eGRID subregion or Cambium).
  • Future weather: Belcher-type morphing (shift and stretch) of an hourly EPW, or statistically downscaled projections across several pathways.
• The gap, specifically:
  • Operational carbon ignores the design. Hours × 1 kW does not change with insulation, glazing or orientation. Two very different designs give the same operational curve unless the student edits the hours. The crossover year is therefore mostly a function of the assumptions.
  • Grid: a US national average, CO₂ only (not CO₂e), generation-side, on a linear path. Regional grids differ from it substantially, in both directions.
  • Embodied scope: A1–A3 of four assemblies only. There are no foundations below the plinth, fixings, finishes, services, transport, construction or end of life, and biogenic storage is excluded. This underestimates whole-life embodied carbon. Rough scale: the missing modules often add tens of percent in LCA practice (not quantified here).
  • Climate past 2050: one global ratio stretches a 2050 local pattern. From 2090.5 to 2126 (~36 years) the offset is held flat while SSP5-8.5 keeps warming, which understates late-century warming. Only one pathway is shown.
  • Climate is shift only: the mean temperature change, with no change in variance or extremes, and it does not feed back into the hours in the carbon lane.
• Where ours is as good or better: Transparency: every assumption is an editable number beside the curve it bends, and each lane marks where its data runs out (solid versus dashed). The embodied geometry is taken from the student's own saved design, not a generic box. The replacement step function and the grid scenario show structure that a single "total kgCO₂e" hides.
• Code: src/lib/hundredyear/lanes/carbon.ts, src/lib/hundredyear/lanes/climate.ts, src/lib/hundredyear/climate-fetch.ts, src/lib/hundredyear/ingest.ts, src/app/(app)/hundred-year/HundredYearView.tsx

• Our method:
  1. Prompt. The V1 prompt is the rails contract: box, cylinder, cone, sphere, prism, member, subtract, loft, shell, repeat, grid, polar, union, range, lerp, plus Math. Coordinates are Z-up and in feet. The model tier is Fast (Haiku 4.5), Deep (Sonnet 5) or Max (Opus 4.8, collaborators and owner only), with an open-weight overflow tier. It returns a structured schema: the code, a params array, optional metrics() and objectives, maxTokens 8,000.
  2. Lint. lintCode rejects import/require/fetch/eval/Function/process/globalThis/.constructor and obvious infinite loops.
  3. Parse on the server, run in the browser. The server compiles the program (new vm.Script) to catch syntax errors and never runs it. Until 2026-10-11 it ran it in node:vm, which let a constructor escape through the library reach the server's environment. The browser's worker runs it at the default sliders with the same caps and a 4 s kill.
  4. Enforce caps. The kernel allows 256 solids, 500,000 vertices, 250,000 triangles, 2,000 per repeat/grid/polar and 1,000,000 solid constructions. validateIR rejects non-finite coordinates and any coordinate over 1e6 ft.
  5. Repair once. A lint or syntax failure gets one repair turn on the server; a failure when the browser runs a freshly written program is sent back once automatically. Either way the repair carries the real error, both versions are shown, and a further failure is the student's button to press.
  6. V2 commands. Input is parsed by a hand-written parser (no eval). The model only translates English into up to 60 command lines, each re-parsed by the same parser. It gets one repair round and escalates Fast to Deep once.
  7. Run in the browser. Sliders re-run the program in a Web Worker (terminable, network globals nulled).
  8. Optimize (optional). NSGA-II searches the ticked sliders: SBX ηc 15, polynomial mutation ηm 20, crossover probability 0.9, population 8–120 (default 40), generations 5–120 (default 40), seeded mulberry32. It scores seven geometry metrics (material volume ft³, bounding-box volume ft³, bounding-box footprint ft², height, surface area, compactness, part count) plus any authored ones.
  9. Export. The .3dm rebuilds primitives as Extrusion/Cylinder/Cone/Sphere/NURBS from primitive provenance, falling back to mesh per solid (a loft has no primitive provenance, so lofted solids always export as meshes). Also exported: a watertight STL, a rhinoscriptsyntax .py and a session JSON.
• The professional method:
  • Grasshopper is a dataflow graph over the full RhinoCommon kernel: NURBS curves and surfaces, trees, exact Brep booleans and intersections, and a plug-in ecosystem. Galapagos, Octopus and Wallacei do the search.
  • Text-to-CAD tools generate a CAD program (Zoo's KCL, or CadQuery/OpenSCAD) over a B-rep or CSG kernel. Their checking is usually "does it compile/render". Our "execute in a sandbox, check caps, one repair" is roughly the same level.
• The gap, specifically:
  • Booleans. subtract is box-from-box, axis-aligned only. A rotated or curved opening can't be cut. Grasshopper's Solid Difference works on any closed Breps.
  • union merges meshes; it is not a boolean. Overlapping solids interpenetrate, so the divergence-theorem "material volume" double-counts overlaps. The number runs high whenever parts overlap.
  • No free-form surfaces. There are no NURBS surfaces through curves, no sweeps, no network surfaces. loft needs two same-count plan polygons.
  • Only one thing is checked: that the program runs, stays in bounds and produces finite geometry. Nothing checks that it matches the brief ("a 3-storey block" could come back as 4 floors). You verify intent by reading the code and the model.
  • Proxy metrics only. Compactness is total surface area ÷ bounding-box volume, and footprint is the bounding box's plan area. There is no daylight, energy or structure behind the objectives, unlike Grasshopper + Ladybug/Karamba optimisation loops.
  • The optimizer searches sliders, never topology. Grasshopper + Galapagos has the same limit. Evolving the code itself is out of reach in both.
• Where ours is as good or better:
  • The pedagogy. The whole program is one short readable function. The student sees exactly what the AI wrote.
  • Sandboxing and repair logging are stricter than most text-to-CAD demos.
  • The NSGA-II implementation is standard. Export produces true Rhino Extrusions rather than meshes wherever primitives allow.
  • V2's commands are a gentle on-ramp to Rhino's command-line habits.
• Code: src/lib/conjure/rails.ts, src/lib/conjure/server-validate.ts, src/app/api/conjure/route.ts, src/lib/conjure/nsga2.ts, src/lib/conjure-v2/commands.ts

The options at a glance

V4 · Gable Studio

The parametric house itself: sliders, goals, climate, the brainstormer, and the Rhino round trip.

• What it adds: This is the base. It is an iframe onto shell.html, which has its own V1–V4 switcher and defaults to inner V4 (app4.js).
  • Inner V1 is the original.
  • Inner V2 adds the EPW sky matrix, per-face kWh/m² (incidentByModel), and a Ladybug side-by-side where you paste Ladybug's five-orientation results.
  • Inner V3 adds NSGA-II over the gene catalog (defaults: population 80, 60 generations, SBX ηc 20, ηm 20, pc 0.9, pm 1/G).
  • Inner V4 has the goals board, the brainstormer, carbon, the 2050 toggle and export.
  • Terrain is always the synthetic ravine (core.js DEFAULTS.site.terrain).
• Method:
  • Solar. 15 suns: declination +23.45°/0°/−23.45° × solar hours 8, 10, 12, 14 and 16, from latitude alone. Each is summed as area·max(0, n·L) and divided by 15, or by 5 per season. The scored keys are not self-shaded; only the analysis overlay ray-casts (sampleSolarGrid). "South" is a hard-coded azimuth window of 135–225°, so it is northern-hemisphere only.
  • Wind. One azimuth and one speed. The load proxy is ½·1.225·V²·windward area.
  • Ventilation.
    • Stack: Cd 0.61, with A* split by height.
    • Cross-flow: A* split by the sign of n·wind, with √ΔCp = 0.84.
    • The two are combined in quadrature.
  • Comfort. The EPW hours are binned into Givoni-style zones. comfortResponse then scales each passive share by how well the geometry delivers it: ventilation against 10 ACH, mass ratio against 0.45, winter solar index against 5.
  • Carbon. ICE v4.0 A1–A3 factors for four fixed build-ups.
  • 2050. Shift-only morph of dry-bulb (climate2050.js).
  • AI. The brainstormer is one streamed call on the Deep tier (claude-sonnet-5, max_tokens 2200). It returns 401 for anonymous callers, and each run is logged as gable-studio:brainstorm. The client keeps a proposal only if its metric key, operator and number all validate (app4.js parseGoals). The model proposes goals; it never produces a metric.
  • Loading an EPW sets latitude and longitude only. Wind stays on its slider (a Surveyor pipe also sets the wind azimuth; the speed stays on its slider).
• Fidelity: Classroom proxy. The solar index has no DNI weighting, no clouds and no shading, and the comfort hours assume a free-running interior. Ventilation and carbon are Standard method. The brainstormer is AI reading, but its output is only a proposed goal, never a score.
• Professional equivalent: A Grasshopper gable definition with Ladybug's sun path and psychrometric chart. Climate Consultant for the strategy bins. Inner V2 radiation vs LB Incident Radiation.
• Trust it for / don't use it for: Trust the direction of each slider on a known form. Don't use it for anything where shading, cloud or site matters: the headline keys see none of it.
• The gap:
  • The solar index. 8 am in winter counts as much as noon in summer. There are no clouds, no diffuse sky and no overhang shadow in the score. For an overhang study, this over-reads summer glazing gain.
  • No heat balance. The HVAC hours are bin counts, not kWh.
  • The thermal-mass gate uses each month's highest minus lowest temperature as its swing; see Shared.
• Code: public/tools/gable-studio/web/shell.html, web/core.js, web/v4/app4.js, web/v4/climate2050.js, web/carbon.js, web/v2/app2.js, web/v3/nsga2.js, python/gable_core.py, src/app/api/gable-studio/brainstorm/route.ts

V5 · Site Forces

Any geometry (the gable or an imported .3dm/.obj/.stl/.ply/.glb) against the real site.

• What it adds:
  • Terrain. Real terrain (details below).
  • Occluded solar. The six solar keys are recomputed, with every sample ray-tested against the massing plus the terrain. The same 15 suns are used, and "south" becomes ±45° of the equator, so it works in either hemisphere.
  • An EPW branch (from a dropped file or the Surveyor pipe):
    • radGlazingAnnual/Winter/Summer and radEnvelopeAnnual in kWh/m², from annual and hemisphere-aware seasonal sky matrices.
    • A 16-sector rose-weighted windward area and load.
    • Comfort through core.js on the final, occluded metric bag.
  • An energy layer from crucible's evaluator. This is a quasi-steady seasonal balance (energy.ts) giving heat-loss rate, winter heat demand, solar fraction, summer float and indoor swing.
  • Search. Imports get an orientation sweep in 5° steps. The gable gets NSGA-II.
  • A lineup for comparing candidates.
• Method:
  • Terrain.
    • Tile fetch: AWS terrarium tiles at zoom ≤15 through /api/terrain, decoded as R·256 + G + B/256 − 32768. The patch is 1,312 ft (400 m) square on a 64 × 64 grid, about 21 ft (6.4 m) cells. It is re-datumed so the site centre sits at z = 0.
    • Surveyor pipe: a 200 ft × 200 ft cut of Surveyor's 3DEP grid instead.
  • Radiation.
    • Sky. Tregenza-145 patches; diffuse is isotropic (DHI/π·Ω per patch); beam goes wholly into the nearest patch. Cooper's declination and a longitude correction are used, with no equation of time (sky.js).
    • Surface reading. Incident = Σ R[p]·max(0, n·d_p), skipping blocked patches, read at each surface's centroid lifted 1.2 in (0.03 m) (radiation.js). The gable has about 11 faces, so it gets about 11 points. Imports above 512 surfaces are clustered by normal and space into ≤256 samples.
  • Imported models get a directed-edge closure test. Closed solids are counted at ×0.5 skin, open ones at ×1.
  • Wind. Wind speed is set to the EPW rose's mean non-calm speed.
  • Ventilation. The cross-flow uses that speed, multiplied by a shelter factor that stays 1 because V5 sets no class.
  • NSGA-II (conjure/nsga2.ts): population 28 (8–96), 18 generations (5–80), SBX ηc 15, polynomial mutation ηm 20, pc 0.9, pm 1/G. Soft goals are objectives; hard goals are constraints.
  • Energy constants:
    • U-values: wall 0.056, roof 0.039, floor 0.053, glazing 0.32 Btu/h·ft²·°F (0.32, 0.22, 0.30, 1.8 W/m²K).
    • SHGC 0.6.
    • Clear-sky beam 190 Btu/h·ft² (600 W/m²).
    • Infiltration 0.3 ACH.
    • ISO 13790-style gain utilisation.
• Fidelity: Screening estimate. Radiation is the Standard method cumulative-sky integral, read coarsely. The energy rows are Classroom proxy here: V5 builds its site with toCrucibleSite, which spreads DEFAULT_SITE. So the winter day stays 32°F (0°C), the summer day 82°F (28°C), the swing 18°F (10 K) and the beam clear-sky, whatever EPW is loaded. The readout says so. The gable's windows also enter that balance unshaded.
• Professional equivalent: LB Incident Radiation on a sensor grid, with the topography mesh as context. LB Wind Rose. Honeybee-Energy for heating demand. Forma for early site sun and wind.
• Trust it for / don't use it for: Trust it for "does the hill or the eave shade this opening at these suns" and for ranking façades by annual kWh/m². Don't use it for heating demand or overheating from the energy rows, or for the energy on half a window.
• The gap:
  • One point per surface. An overhang either blocks a window's centroid from a patch or it doesn't. Ladybug's grid gets the partial shadow. On a half-shaded wall the error can be large in either direction. The on-building colour field (face-field.ts, ~20 in / 0.5 m cells) does show the band, so the picture is finer than the score.
  • Isotropic diffuse instead of Perez. This under-reads sun-facing surfaces and over-reads shaded ones, by a modest share annually. There is no ground-reflected term, which under-reads walls. Snapping the beam to the nearest patch misplaces the sun by up to about 6° per hour.
  • Wind. The 33 ft (10 m) airport mean speed is applied at the window with no height or terrain correction and a single ΔCp. This likely over-reads cross-flow on sheltered sites.
  • NSGA-II at ~500 evaluations by default is a small run next to typical Galapagos or Wallacei studies.
• Code: src/lib/eco5/metrics.ts, src/lib/eco5/terrain-client.ts, src/lib/eco5/site-state.ts, src/lib/crucible/evaluator.ts, src/lib/crucible/energy.ts, src/app/(app)/site-design/eco5/eco5.optimize.worker.ts

V6 · Form Finder

The gable walks its own sliders toward the site's forces, live.

• What it adds: The optimiser is a live SPSA walker (simultaneous-perturbation stochastic approximation, Spall 1992) instead of V5's batch NSGA-II. The design repaints every tick.
  • Scoring. It uses the V5 stack verbatim: buildModel → gableToSemantic → computeEco5Metrics. The terrain patch here is 853 ft (260 m) on 48 × 48, about 18 ft (5.5 m) cells, with the synthetic ravine as fallback.
  • Sliders walked by default (15 genes): room rotation, both pitches, ridge rise, south window width and height, plinth position and thickness, the chained room and roof positions, ridge rotation, and north angle.
• Method:
  • Objective. J = Σ wₜ·dirₜ·(mₜ − baseₜ)/|baseₜ|. Every force is normalised against the seed design, so J(seed) = 0. The seven forces, with default weights:
    • Winter sun, 1.0: radGlazingWinter, else solarWinterUseful.
    • Summer shade, 0.6.
    • Wind shelter, 0.5: windRosePressure, else windPressure.
    • Compactness, 0.4: surface-to-volume.
    • Bed-in, 0.3: buried fraction.
    • Cross-vent, 0.4: ventCapacity.
    • Comfort, 0.8: passiveComfortFraction, used only with an EPW.
  • Holds and fences:
    • A program hold (weight 1) penalises floor-area drift.
    • A buildability fence (weight 3) subtracts the penalty from six rules measured on the built model: roof clears ground, headroom, ridge height, roof covers walls, walls on plinth, a door that fits.
  • Each tick:
    • Two probe evaluations at u ± cₖΔ, with Δ = ±1 per gene on genes normalised to 0–1.
    • Gains cₖ = 0.08/(k+1)^0.101 and aₖ = 0.12/(k+16)^0.602, frozen after k = 500.
    • Momentum β = 0.55, then clamp and snap to the slider step.
  • Terrain in the score. The ground affects the occluded solar, and burial read at one point: the terrain height under the plinth centre (gable-adapter.ts).
• Fidelity: The scores are Screening estimate, the same as V5, and the energy rows still run on V5's placeholder weather. The search is a Standard method: textbook SPSA. It is not the algorithm Galapagos runs (genetic algorithm or simulated annealing).
• Professional equivalent: Galapagos single-objective (weighted-sum fitness), or Opossum (RBFOpt, model-based) for expensive evaluations.
• Trust it for / don't use it for: Trust it to show which sliders the weighted forces pull, and how hard (the per-gene "pulls" readout). Don't treat where it stops as an optimum.
• The gap:
  • It is a local hill-climber. It settles on ridges, and the result depends on the seed and on the weights.
  • Normalisation. Normalising against the seed makes weights unit-free, but a metric whose baseline is near zero stops being normalised and then dominates.
  • The fence is soft, so heavy weights can buy small violations.
  • Galapagos and Opossum keep a population or a surrogate and can escape local optima. SPSA cannot.
• Code: src/lib/eco6/gable-walker.ts, src/lib/eco-architect/buildability.ts, src/app/(app)/site-design/eco6/eco6.walk.worker.ts, public/tools/gable-studio/web/v3/genome.js

V7 · Compare

Several named approaches to one site, and the trade-offs between them.

• What it adds:
  • A deck of seven weightings, four live by default: Even hand (V6's defaults), Sun-first, Cool-first, Shelter-first, Lean skin, Bedded in, Comfort-first. Each drives its own V6 walker from the same seed and the same baselines, ticked round-robin off one evaluator.
  • The archive. Every design visited is kept with its metric bag.
  • Cross-scoring. Because J needs only (metric bag, weights, baselines), every archived design is re-scored under every weighting at no extra geometry cost.
• Method:
  • Robust picks:
    • Maximin: the design with the best worst-case J across weightings.
    • Minimax regret: the smallest maximum shortfall against each weighting's own champion.
    • Ties are broken by mean J.
  • Pareto front: non-dominated designs on any two metric axes (O(n²)).
  • Consensus: the spread of each gene across the weightings, normalised by the slider range.
  • Ledger: a deterministic diff of two designs into sentences with signed numbers, exportable as Markdown. There is no AI.
  • Site: terrain 853 ft (260 m) / 48 grid. Energy rows run on placeholder weather, as in V5.
• Fidelity: The underlying scores are Screening estimate. The decision rules (maximin, minimax regret, Pareto dominance) are Standard method decision theory, correctly applied.
• Professional equivalent: Wallacei or Octopus for multi-objective fronts. Design Explorer for browsing a design space. Robust decision making or minimax-regret analysis in planning practice.
• Trust it for / don't use it for:
  • Trust it for: which moves every weighting agrees on (low spread = the site decided) versus which are genuine judgement calls.
  • Don't use it for: treating the "least-regret" house as the answer. It is least-regret only among the preset weightings you switched on, against V5's proxy scores.
• The gap:
  • The approaches are fixed weight vectors, not true multi-objective search.
  • The front is assembled from what the walkers happened to visit, not grown by a GA with diversity pressure. Wallacei or NSGA-II explore the front systematically and keep generation histories.
  • The comparisons inherit all of V5's limits: one point per surface, placeholder energy weather.
• Code: src/lib/eco7/council.ts, src/app/(app)/site-design/eco7/eco7.council.worker.ts, src/app/(app)/site-design/eco7/Eco7Tool.tsx

V8 · Ground Truth

The real site scores the house, today and in 2050, with every adopted design recorded.

• What it adds:
  • The ground:
    • The studio's five Superfund grounds (STUDIO_SITES centroids), or a Surveyor survey consumed whole.
    • A ground-size ladder of 200 / 400 / 800 ft, ¼ mi or ½ mi (default 400 ft). The grid is 64 × 64 below 750 ft and 96 × 96 above; at 400 ft that is about 6 ft cells, finer than the 13–33 ft (4–10 m) source, so the ground is interpolated.
    • Latitude clamped to −55…66°.
  • Energy from the EPW. This is the first version whose energy rows read the EPW. deriveFromParsed supplies the winter and summer means, the seasonal DNI in the 8–16 h window, and the swing. The gable's own shading is in the balance.
  • The era axis: today vs 2050.
  • The parallax read: one fixed design scored on all five grounds, with analytic keys only.
  • A trajectory of up to 40 adopted steps, each with its weights, era and ground, diffed through V7's ledger.
• Method:
  • Walker. V6's walker at about 8 Hz.
  • 2050 morph (era.ts):
    • Belcher–Hacker–Powell shift term only. Each hour's dry-bulb moves by its month's delta. RH, radiation, wind and the swing stay as measured.
    • Deltas: Open-Meteo Climate API daily mean temperature, from three CMIP6 HighResMIP models (MRI-AGCM3-2-S, EC-Earth3P-HR, MPI-ESM1-2-XR). Each model's monthly mean for 2036–2050 minus 1991–2020, then the three averaged.
    • Deltas are cached per location and never invented: no deltas means no 2050.
  • The other era. Each tick re-derives the comfort quintet under the era not being walked, in O(1).
  • AI: none. The only network calls are terrain tiles and Open-Meteo.
• Fidelity: Screening estimate. The 2050 read is a Screening estimate of temperature stress only. The indoor-swing energy row is Classroom proxy (see the mass-gate swing in Shared).
• Professional equivalent: Ladybug and Honeybee on a topography context, with a future EPW from CCWorldWeatherGen (full Belcher shift + stretch across several variables) or Meteonorm future scenarios. A design-options report for the trajectory.
• Trust it for / don't use it for: Trust it for how the same moves read on a real landform, and for the direction warming pushes the comfort bins. Don't read the 2050 numbers as a prediction.
• The gap:
  • What the morph leaves out:
    • No stretch term, so the diurnal and variance changes are missing.
    • RH is held, which over-feeds the muggy bins.
    • The 2036–2050 window is centred around 2043, so it under-reads 2050.
  • The energy dials are not morphed. The 2050 era still scores winter and summer means from today's EPW. The energy rows do not move with the era; only the comfort keys do.
  • The ground in the score. Burial is still one point under the plinth, and the terrain otherwise enters only as an occluder.
• Code: src/lib/eco8/era.ts, src/lib/eco8/grounds.ts, src/lib/eco8/trajectory.ts, src/lib/crucible/climate.ts, src/lib/hundredyear/climate-fetch.ts, src/app/(app)/site-design/eco8/eco8.walk.worker.ts

V9 · Parallax

One brief, five real grounds walking at once, and what each landform grows.

• What it adds:
  • Five seats. Five walkers with one weight deck, one seat per Superfund ground. Each seat scores at its own latitude and in its own terrain.
  • Normalisation. J is normalised against the seed on that seat's own ground, so cross-scoring is not free here.
  • An on-demand cross-read. Each seat's champion is re-evaluated on every ground: 5 × 5 = 25 evaluations. It names:
    • the maximin design (best worst-case J across grounds);
    • the least-regret design;
    • the consensus spread per gene.
  • Send to V8. The focused ground can be sent to V8.
• Method:
  • Scoring. The V8 evaluator with climate: null, sky: null and occlusion on. The terrain is 64 × 64 on the ladder (default 400 ft); a failed fetch becomes a flat seat.
  • Site. DEFAULT_SITE is spread unchanged, so wind is 270° at 11 mph (5 m/s) and the energy dials are placeholders at every ground.
  • No AI.
• Fidelity: Classroom proxy. What actually differs between seats is latitude, terrain occlusion of the 15 analytic suns, and the single-point burial. Wind, climate and comfort are identical fictions across the five sites, and the radiation and comfort keys are absent.
• Professional equivalent: None packaged. The nearest practice is running one Grasshopper optimisation against several context models in batch (Colibri + Design Explorer), or a robust-design study across scenarios in Wallacei.
• Trust it for / don't use it for: Trust it for "does this sun or landform move survive a change of ground?" Don't use it for any claim about climate differences between Tar Creek and Butte. It cannot see them.
• The gap:
  • No EPW at any ground.
  • The same prevailing wind everywhere.
  • Placeholder winter and summer days in the energy rows.
  • Everything in V6's search limits.
• Code: src/lib/eco9/ground-council.ts, src/app/(app)/site-design/eco9/eco9.council.worker.ts, src/app/(app)/site-design/eco9/Eco9Tool.tsx

Shared across all options

• One engine.
  • core.js (buildModel, 15-sun solar, ventilation, comfort, psychrometrics) is imported, not ported, by V5–V9 through src/lib/eco5/engine.ts.
  • V5–V9 score through crucible/evaluator.ts, a pinned port of computeMetrics that adds energy, floor-sun and carbon. It uses the same Cd 0.61 and √ΔCp 0.84, plus an LBL shelter factor that is 1 unless set.
  • Carbon is ICE v4.0 A1–A3 in both carbon.js and crucible/carbon.ts. The timber rows use "No Carbon Storage" factors and there is no A4–C, so it under-reads whole-life emissions, while leaving out biogenic storage makes timber look worse than an LCA that credits it.
• Radiation (V5–V8, and inner V2 of V4): Tregenza-145, isotropic diffuse, one point per surface.
• Comfort (V4–V8 when an EPW is loaded):
  • The zones. Comfort 68–81°F (20–27°C) with W ≤ 0.012 and RH ≤ 80%. Passive solar down to 53°F (11.5°C). Ventilation to 90°F (32°C). Mass to 91°F (33°C) if the swing is ≥ 14°F (8 K). Evaporative below a 72°F (22°C) wet bulb.
  • The mass-gate swing. The swing the mass gate uses is annual.diurnalRange: the mean over months of each month's highest minus lowest temperature, not the mean daily range. The comfort fingerprint takes it in weather.js, climate2050.js and era.ts.
    • Size. On the Chicago O'Hare TMY3 file this is about 53°F (29.4 K); the mean daily range, taken day by day, is about 18°F (10.0 K).
    • Effect on the fingerprint. In practice the gate never closes. For Chicago the fingerprint is the same either way, because both values exceed 14°F. In marine or humid-tropical climates, where the daily range is under 14°F, some hours land in "mass" that a daily-range test would place in evaporative or sensible cooling; the effect on the passive fraction is small.
    • Which versions. It applies to V4 (both eras), V5, V6 and V7 (whenever an EPW is loaded) and V8 (both eras).
    • A larger effect in V8. crucible/climate.ts passes the same value to the energy balance as diurnalSwing, so V8's indoor swing row scales with it: on the Chicago file it is about 2.9× what a daily-range calculation gives.
    • V9 does not use it (no EPW). The V5–V7 energy rows don't either, because they use the 18°F (10 K) placeholder.
• Exports: the Rhino surfaces + mesh pair and a watertight STL (V5 onward), and V4's zip with the Python rebuild.

The options at a glance

V1 · Bench

Any massing, judged against site dials, with the optimizer and Claude authoring.

• What it adds: This is the base the other versions build on. You author a massing from a program's sliders, have Claude write or edit one, or import a Rhino .3dm or .obj. You drag the site dials and read about fifty keys. Goals can go to an NSGA-II search.
• Method: Engine: evaluate() (evaluator.ts), a parity port of Eco-Architect's core.js. Sun: 15 fixed suns (declinations +23.45°, 0°, −23.45° × solar hours 8, 10, 12, 2 and 4). The six classic solar keys are cosine-weighted area and not ray-cast. The shaded pair (winter sun kept, summer sun cut, the floor and focus sun, and the gain the energy balance banks) is ray-cast against the massing's own opaque parts only. Weather: with no weather year the dials are placeholders (latitude 42°, wind from the west at 11 mph (5 m/s), ΔT 11 °F (6 °C), winter 32 °F (0 °C), summer 82 °F (28 °C), internal gains 1.3 Btu/h·ft² (4 W/m²)). A dropped .epw, a searched place or a studio-site press loads a year (a modelled 2023 year from Open-Meteo, or the station file). That sets the dials and switches the engine to computeEpwMetrics: the six solar keys become occluded at the same 15 suns, and the weather year adds rad* kWh/m² from a Tregenza-145 sky, the 16-sector wind-rose keys and passive-comfort hours. Terrain: a studio press fetches terrain tiles (terrarium, 96 samples) and seats them for the picture only: shading paint, floor light, path tracer. The landform never enters V1's score. Search: NSGA-II (Deb 2002), 40 designs × 30 generations, seed 1, in a worker that scores with plain evaluate(), the flat bench engine, without the landform or the weather-year keys. With a weather year loaded, its candidates' scores therefore differ from the readout beside them. AI: /api/crucible in author, edit, ask and brainstorm modes. See Shared below.
• Fidelity: Screening estimate (ventilation Standard method, energy and mass Classroom proxy). The optimizer is Same engine as Wallacei's NSGA-II. Describe is Authoring; Ask and Brainstorm are AI reading.
• Professional equivalent: Ladybug sunlight-hours and radiation on a Rhino massing, with Galapagos or Wallacei driving Grasshopper sliders.
• Trust it for / don't use it for: Trust it for early massing comparisons with no site yet, and for learning which dial moves which key. Don't use it where a hill or a neighbour matters, and don't compare its sun keys with V2/V5–V8 unless both have a weather year loaded.
• The gap:
  • Without a weather year the sun-on-opening keys ignore self-shading. An overhang does not reduce "Winter/Summer solar gain" (it does reduce sun kept/cut and energy), so deep overhangs read too sunny.
  • The ground is display-only. A south ridge that blocks December sun leaves every number unchanged.
  • The 15 suns stop at 8 am and 4 pm solar time, so the late-summer west sun is not counted.
• Code: src/app/(app)/tools-3d/crucible/CrucibleTool.tsx, src/lib/crucible/evaluator.ts, src/lib/crucible/eco5-bridge.ts, src/app/(app)/tools-3d/crucible/crucible.optimize.worker.ts

V2 · Grounds

The same engine standing on one real site, with the landform in the score.

• What it adds: The site comes first: the five Superfund studio sites, a searched place, or a Surveyor pipe carrying its measured grid and a synthesized .epw. The landform enters the score. The massing rotates instead of the world (site.northAngle is locked at 0, rotateSolidsZ), so the georeferenced ground stays put. There is a live SPSA Tune walker, plus Send to Scoreboard and the Rendered layer.
• Method: Engine: computeGroundedMetrics (eco5-bridge.ts). The terrain triangles, minus every score triangle whose plan box overlaps the building's, join the massing in one occluder soup. All six solar keys, the shaded pair, the floor sun and the energy balance are Möller–Trumbore ray-cast against it at the same 15 suns. With a weather year it adds rad*, the rose keys and the comfort coupling; without one those keys are absent, never zero. Terrain: terrain tiles at about 13–33 ft (4–10 m) source spacing for a studio press or a place, or the Surveyor's 3DEP grid when piped. The score uses every third grid line, about 41 ft (12.6 m) at the ¼-mi extent. Tune walker: Eco-Architect's SPSA walker (Spall 1992; gains aₖ = 0.12/(k+16)^0.602 and cₖ = 0.08/(k+1)^0.101, plus a momentum term β = 0.55 and the gains frozen after 500 ticks) on the flat evaluate(). The page says so: "tuning by the bench forces, measuring by the grounded instruments". AI: none. There is no Describe drawer and no Brainstorm.
• Fidelity: Screening estimate.
• Professional equivalent: Ladybug direct-sun or radiation studies with a survey mesh or Elk/Heron topography as context geometry.
• Trust it for / don't use it for: Trust it for "does this hill cost me winter sun" and for siting on a slope. Don't use it for anything a bank against the wall decides: up to one score cell (about 40 ft) of ground around the building is dropped from the score, so near-building terrain shade reads low.
• The gap:
  • Tiles are landform, not survey: no curbs, walls or trees, and no neighbours unless you model them.
  • The Tune walker climbs the flat score, so it can push toward a move the grounded readout disagrees with.
  • Views are still one point-source eye at the plan centre, and the mass is still the stylised ratio.
• Code: src/app/(app)/tools-3d/crucible/v2/AssayerGroundsTool.tsx, src/lib/crucible/eco5-bridge.ts, src/lib/eco5/terrain-client.ts, src/lib/eco6/gable-walker.ts

V3 · Live

A whole field of variants scored at once and culled down to one.

• What it adds: No 3-D viewport. A worker samples the program's sliders and streams scored variants onto a wall, batched by count or time, whichever comes first. Spread pushes each gene past its declared range (Declared ×1, Wide ×2, Extreme ×4, Feral ×8; a per-gene override goes up to ×32). Six samplers answer different questions: Edge hunt (the default: axial extremes, then corners, then diverse fill), Axial, Corners, Antipodal, Diverse (best-candidate), and Even (LHS, Swarm's own Latin hypercube). Builds that throw are kept as captioned black tiles. A keep/cull ladder narrows the box wave by wave.
• Method: Every variant is scored by plain evaluate() through Swarm's KPI evaluators. The ground is flat. A studio press or a place sets the dials from the Open-Meteo year (seasonal means, beams, prevailing wind), but no hourly keys exist and no .epw can be dropped. The sun is the 15-sun bench with the unshaded classic keys. AI: none.
• Fidelity: Screening estimate for the numbers. The sampling is standard design-of-experiments (LHS, extremes, maximin-distance fill).
• Professional equivalent: Colibri (TT Toolbox) iterating a Grasshopper definition into Design Explorer, or a DOE run in modeFRONTIER. These are sampling and visualisation, not optimisation.
• Trust it for / don't use it for: Trust it for finding where a parametric model breaks, and which variable drives which KPI (Axial is the only sampler whose differences have a single cause). Don't use it for siting questions or anything the weather year or terrain would change.
• The gap:
  • Same engine limits as V1 without a weather year, with every variant's sun-on-opening keys unshaded.
  • A field at ×8 contains forms the engine's assumptions don't cover (a one-zone room, fixed U-values), so its extremes are plausible to the formulas, not to physics.
  • Unlike Design Explorer, there are no images of each variant beyond the tile.
• Code: src/app/(app)/tools-3d/crucible/v3/AssayerLiveTool.tsx, src/app/(app)/tools-3d/crucible/v3/live.worker.ts, src/lib/assayer3/samplers.ts, src/lib/assayer3/spread.ts

V4 · Council

Named approaches form-finding the same massing, then judged under each other's weights.

• What it adds: A deck of seven positions (Even hand, Sun-first, Cool-first, Shelter-first, Lean skin, Least carbon, View-first; four on by default). Each is a weighting of seven force terms: winter sun, summer shade, wind shelter, compactness, cross-ventilation, view, carbon. Each position gets its own SPSA walker on the same massing, with orientation walkable as a site gene and the buildability fence as a soft penalty. It is the only version that cross-scores: every candidate is re-judged under every position's weights, then two robust picks are made, maximin (best worst case) and minimax regret (Savage). You also get the gene consensus, a two-axis front, and an A-vs-B ledger exported as Markdown.
• Method: Each term is J = Σ w·dir·(m − base)/|base|, a relative change against the seed, and the terms are unit-free. The worker runs compileProgram once, then evaluate() per evaluation, so the engine is flat, weather-year-free and terrain-free, the same as V1 without a file. A studio press sets the dials from the Open-Meteo year and says "Flat bench: the landform is not in this version's score." The winter and summer terms read the massing-shaded keys first. A build that throws returns a heavy rulePenalty. "Council" is not an AI. The positions are hand-written weight sets, and the ledger is generated from the numbers; V4 makes no model call.
• Fidelity: Screening estimate for every number. Maximin and minimax regret are Same engine as the published decision rules; the walker is Spall's SPSA with an added momentum term (β 0.55).
• Professional equivalent: Wallacei or Octopus multi-objective runs with their analytics, or a facilitated multi-criteria decision session (weighted-sum sensitivity). No mainstream package cross-scores named stances like this.
• Trust it for / don't use it for: Trust it for showing a studio that "best" depends on the weights, and which genes every stance agrees on (the site decided those). Don't use it for treating a maximin pick as an optimum: the weights are the tool's teaching values, and every term is a screening key.
• The gap:
  • Normalising against the seed makes a term whose baseline is near zero act as an absolute term (stated in gable-walker.ts).
  • SPSA is a local climber: each walker finds a nearby improvement, not a global front as NSGA-II does.
  • No terrain, no weather-year keys, and the view is the plan-centre point source.
• Code: src/app/(app)/tools-3d/crucible/v4/council.worker.ts, src/lib/crucible/council.ts, src/lib/eco7/council.ts, src/lib/crucible/fence.ts

V5 · Freehand

One walker, with the search itself authored by you, read by V7's full chain on real ground.

• What it adds: Every parameter of the search is yours. You set per-gene min/max/step bounds (the walker normalises against them, not just the display), pin or lock genes mid-walk, and edit weights and direction flips on the shipped terms. You can build custom forces from any catalog metric; a key the engine never produces is rejected with a reason, never scored as zero. The fence is on, with its rules editable, and a scrubber rewinds up to 6,000 ticks so you can walk on from any of them. Since 2026-09-21 the walked design is read by V6/V7's hook (useSiteForceReadings): verdicts, the nine force sheets, the energy panel, and the focus when the starter is the jig (its default).
• Method: The SPSA walker runs with grounded: true, scoring each evaluation with computeGroundedMetrics: seated terrain (every third grid line) plus the weather year's rose, comfort fingerprint and Tregenza-145 sky. The walker therefore climbs the same numbers the readout prints, which V2's walker does not. Terrain: terrain tiles (96 samples) for studio grounds, or the Surveyor's 3DEP grid through the pipe (#v5+site-pipe). V5 does not fetch 3DEP for a bare coordinate the way V6 does. Readings: everything V6 reads except the Air layer: sun per pane, BS 5925 air with sizing and de Gids & Phaff, mass by material, views from 9 × 9 stations, the Year, the sun calendar, earth and the ventilation year. AI: none.
• Fidelity: Screening estimate (readings as V6). The walker is Same engine (SPSA).
• Professional equivalent: Galapagos or Wallacei with a hand-built fitness function over Ladybug/Honeybee outputs.
• Trust it for / don't use it for: Trust it for testing an argument about what the site wants, with the objective fully visible and editable. Don't use it for claiming the walk found "the" optimum. SPSA is local and stochastic, and a custom force can reward a screening key's artefact.
• The gap:
  • There is no Air layer, EnergyPlus-network drawing or CFD (the scene is its own and moves every tick).
  • The ground is coarser than V6's unless piped from the Surveyor.
  • A flipped direction or a custom term is a claim you made. The tool labels it but does not test it.
• Code: src/app/(app)/tools-3d/crucible/v5/AssayerFreeformTool.tsx, src/app/(app)/tools-3d/crucible/v5/freeform.walk.worker.ts, src/lib/crucible/freeform.ts, src/app/(app)/tools-3d/crucible/v6/useSiteForceReadings.ts

V6 · Site forces

The full-service bench: every force broken open, on measured ground, across the whole year.

• What it adds: On top of the grounded score (as V2), V6 adds per-force modules under lib/crucible/v6, nine verdict cards with the lines each is graded on, a fitness note per reading, a change ledger, saved studies and the 36″ × 36″ studies plate (V6 only). It also brings back V1's Describe drawer and NSGA-II Improve, and adds the Air layer and the shelter dial.
• Method: Score: computeGroundedMetrics with the seated landform, at 15 suns. Sun sheet: each pane is sampled on a 3 × 3 grid (PANE_GRID) over the 10 solstice suns, ray-cast against the opaque parts and the seated ground at full resolution (about 14 ft cells at ¼ mi). A one-dial sweep draws the overhang curve. Year: monthly kWh/m² from the file's cumulative Tregenza-145 sky (isotropic diffuse, beam binned to the nearest patch). The sun calendar runs every 30 min for 365 days on the standard clock, with the NOAA solar-position algorithm (declination and equation of time). The climate strip counts the hours in a 68–79 °F band. Air sheet: BS 5925 plus sizing, de Gids & Phaff and AM10 reach. Mass: δ-limited RC, seven cited materials (mostly CIBSE Guide A; rammed earth from HB 195, water as the reference case). View: 9 × 9 stations, exact Van Oosterom–Strackee solid angles, 0.1 sr within ±45°. Earth: Horn slope and aspect, prism cut and fill, priority-flood + D8. Terrain: USGS 3DEP about 26 ft (8 m) via /api/site-analysis/terrain over a 1-mi (1,609 m) box (or twice the ground extent, if larger), cut to at most 97 samples a side; terrain tiles only outside 3DEP coverage. Weather: a modelled 2023 year from Open-Meteo, a station .epw, or the Surveyor pipe. AI: Describe (author, edit and ask; Max tier only for owners and collaborators) and Brainstorm goals. Improve runs NSGA-II on the flat evaluate(), not the grounded score.
• Fidelity: Mixed. Terrain algorithms are Same engine; ventilation is Standard method; sun, Year, views and carbon are Screening estimate; energy and mass are Classroom proxy. See the reading table below.
• Professional equivalent: Ladybug/Honeybee (Radiance + EnergyPlus) or ClimateStudio, plus a GIS terrain workflow.
• Trust it for / don't use it for: Trust it for scheme comparison on a real site with every force visible at once, and for teaching which professional tool supplies each real number. Don't use it for any absolute load, comfort, daylight or carbon claim.
• The gap: Covered reading by reading in the table below. The V6-specific ones:
  • Improve's candidates are scored without the landform or the weather-year keys while the readout beside them includes both, so a card can promise gains the grounded readout does not show.
  • The Year's isotropic sky under-weights circumsolar radiation (equator glass reads low).
• Code: src/app/(app)/tools-3d/crucible/v6/AssayerPassiveTool.tsx, src/app/(app)/tools-3d/crucible/v6/useSiteForceReadings.ts, src/lib/crucible/v6/{solar,airflow,mass,view,year,ground,feedback}.ts, src/lib/crucible/measured-ground.ts

V7 · Four rectangles

V6's bench on the ARCH 273 jig, read from the fourth rectangle: the focus.

• What it adds: It opens on the 4 Rectangles jig with free_roof on, so the ridge governs, with warnings for broken tolerances. Rect D is a table pushed up or a pit cut into the plinth. Any solid whose name carries "focus" (or an import's Focus:: / _FOCUS layer) becomes the focus plane. Three things are read from it: the sun on the focus, the mass a table adds or a pit removes (area × rise), and every view from the seat, with the eye 3′-11″ (1.2 m) above the surface you sit on. The four rectangles are drawn in plan. Three things are left out: Describe (and with it Ask), Explore in Swarm, and the studies plate. The studies ledger stays.
• Method: Everything is as V6, with the same 3DEP ground, weather handling and flat NSGA-II Improve. Focus sun (computeFloorSun in evaluator.ts, with the window projection in floor-projection.ts): each lit window is projected along the winter and summer suns onto the focus plane, straddling panes are clipped, and every cell in a patch fires a ray (lifted ¾ in / 0.02 m) against the massing and the loaded ground. The pit's own rim, the walls and the roof therefore count. The result is the share of the focus in sun per season. AI: Brainstorm goals only.
• Fidelity: Screening estimate for the focus readings; everything else as V6.
• Professional equivalent: A Ladybug direct-sun or sunlight-hours study on a test surface at table height, and a Ladybug view study from a seated point.
• Trust it for / don't use it for: Trust it for comparing where the sun lands on the focus between schemes, and whether the seat sees out. Don't use it for claiming hours of sun on the table: the focus uses the solstice suns (8, 10, 12, 2 and 4 solar), not every daylight hour.
• The gap:
  • The focus sun is direct beam only: no diffuse, no reflection, no daylight illuminance (use Daylighter, then ClimateStudio).
  • The equinox and afternoon-after-4 pm sun are missing, so west light on the focus is undercounted.
  • The seated view sees only the model's glass, with no context.
• Code: src/app/(app)/tools-3d/crucible/v7/AssayerFourRectanglesTool.tsx, src/lib/crucible/focus.ts, src/lib/crucible/floor-projection.ts, src/app/(app)/tools-3d/crucible/v7/FocusPanel.tsx

V8 · Air at the date

V7 exactly, with the drawn air following the Date + time bar: winter is not summer.

• What it adds: One prop, airDate. The air drawn in the model, its readout, the opening tints, the wind arrow and the key all read the weather year at the bar's day and hour. Every score, the Air card, the verdicts, goals and studies still read the design dials.

• Method (lib/crucible/v6/air-moment.ts):

  1. Solar time is converted to the file's standard clock time (4 min per degree of longitude off the zone meridian, plus Spencer's equation of time).
  2. The window is the file's hours within ±15 days and ±1 clock hour, about 93 hours.
  3. Outside air is the median dry bulb, with R-7 quartiles.
  4. Wind is the modal 16-point sector and the median station speed.
  5. The room is held, not simulated. It uses ASHRAE 55-2020's adaptive comfort temperature 0.31·t̄ + 17.8 °C (0.31·t̄ + 54.1 °F) on the prior 30 days' mean. Below a 50 °F (10 °C) mean it is heated to 68 °F (20 °C); above 92 °F (33.5 °C) it is capped.
  6. ΔT is signed, so a hot afternoon reverses the stack. BS 5925's T̄ becomes the real mean temperature, and the EnergyPlus network uses the real outside density.

  The readout applies ISO 7730 draught rate (Tu 40 %) below 77.9 °F (25.5 °C). From there up to 93 °F (34 °C) it applies the ASHRAE 55-2010 air-speed offset (up to 4 °F / 2.2 °C at 236 fpm / 1.2 m/s). The heat the air carries is 1.08 Btu/h per cfm per °F. A CFD run in V8 is solved for the date's wind direction. With no weather year, the outside air is a placeholder cosine through the Winter and Summer dials, and the wind stays on the dials.

• Fidelity: The drawing is Classroom proxy (as the drawn air). The date readouts are Standard method formulas on Screening estimate inputs.

• Professional equivalent: An hourly EnergyPlus AirflowNetwork run with a zone heat balance (Honeybee, DesignBuilder), reading the chosen hour; Climate Consultant or the CBE Comfort Tool for the comfort reading.

• Trust it for / don't use it for: Trust it for seeing that the same openings behave differently in January and July, and when the stack reverses. Don't use it for predicting a room temperature or a draught complaint.

• The gap:

  • EnergyPlus would compute the indoor temperature hour by hour from the heat balance. Here it is a comfort rule, so the stack ΔT is an assumption, not a result.
  • One hour of the Open-Meteo year is one modelled event on a 6–15 mi (9–25 km) model cell. The window's median smooths out gusts and fronts.
  • The dated air never reaches a score, so V8 cannot rank schemes by seasonal ventilation. The ventilation year (below) does that.

• Code: src/app/(app)/tools-3d/crucible/v8/AssayerSeasonalAirTool.tsx, src/lib/crucible/v6/air-moment.ts, src/lib/crucible/v6/air-display.ts, src/app/(app)/tools-3d/crucible/v6/AssayerPassiveTool.tsx

Air layer · Drawn air (potential flow), V6–V8

Where the air goes, round the building and through the room.

• What it adds: Moving lines and a speed plane (at a height, or on the section cut) inside and around the model.
• Method: Laplace ∇·(k∇φ) = 0 on a room voxel grid (about 240k cells) and a street grid (about 300k) at the default "fine" tier (the four tiers run 90k–960k room cells), solved by SOR. It is fed the opening flows from the Air sheet's BS 5925, or from the EnergyPlus network ("Flows"), so it draws the path and the fed flows set the amount. Wind is sheltered by the LBL class dial.
• Fidelity: Classroom proxy (a picture, not a velocity field).
• Professional equivalent: Streamlines from an OpenFOAM, SimScale or Autodesk CFD run.
• Trust it for / don't use it for: Trust it for which inlet feeds which outlet and where the breeze crosses the floor. Don't use it for any speed at a point.
• The gap: Potential flow has no jets, wakes, recirculation, separation or buoyancy. Corner speed-ups grow with grid fineness (1.9–2.8× the wind in 3-D, up to about 5× on the refined section slice), so peaks are artefacts.
• Code: src/lib/crucible/v6/air-field.ts, src/lib/crucible/v6/air-slice.ts, src/app/(app)/tools-3d/crucible/crucible.air.worker.ts

Air layer · EnergyPlus airflow network (and the ventilation year), V6–V8

The flows EnergyPlus would compute for one zone.

• What it adds: A second set of opening flows, always computed while the layer is on and set beside BS 5925 in the readout. It also adds UCSD cross-ventilation jet and recirculation speeds, the neutral plane in a calm, and the ventilation year.
• Method: This is a port of EnergyPlus's AirflowNetwork (Solver.cpp, Engineering Reference). Wall Cp comes from Swami & Chandra and roofs under 45° from the Holmes table. Wind is brought down to each pane by the ASHRAE power law for the terrain class. Each pane is a SimpleOpening (Cd 0.61) integrated over its height, so it can flow two ways. The room pressure is found by bisection; EnergyPlus uses Newton, and the root is the same for one zone. The UCSD correlations (about 8 % jet and 17 % recirculation error) are flagged outside their 14 fitted CFD cases. Ventilation year: all 8,760 hours through the same network against a fixed indoor 79 °F (26 °C), every pane at its operable share, bisection to 1e-4 Pa. Hours are sorted mild, cool or hot; the tool counts purge hours (≥ 4 ACH) and still hours (< 1 ACH). This is checked against Chicago O'Hare TMY3 in a selftest.
• Fidelity: The equations are Same engine. The ventilation year is a Screening estimate.
• Professional equivalent: EnergyPlus AirflowNetwork (via Honeybee, OpenStudio or DesignBuilder) or CONTAM.
• Trust it for / don't use it for: Trust it for comparing opening layouts, and for seeing wind and stack as one pressure balance. Don't use it for relying on natural ventilation in a partitioned building.
• The gap:
  • There is one zone: no doors, partitions or multiple rooms, which can change the answer completely.
  • There is no zone heat balance (the indoor temperature is a dial or V8's rule).
  • The Cp correlations are for an isolated rectangular low-rise block; L-plans, courtyards and neighbours fall outside them.
  • A one-sided room gets only each pane's own stack in the year (no wind term across one facade, no gust term), so it reads near zero purge hours (a two-window south room in the Chicago year read 0 %). The Air sheet's de Gids & Phaff rate covers that case separately.
• Code: src/lib/crucible/v6/air-network.ts, src/lib/crucible/v6/air-year.ts, src/app/(app)/tools-3d/crucible/crucible.vent-year.worker.ts

Air layer · Run CFD (coarse / fine / finest), V6–V8

A coarse wind-tunnel simulation that finds its own flows, jets, eddies and the age of the room's air.

• What it adds: Flows through each opening computed by the solver, not fed in. Also the local mean age of air (Sandberg), the air-exchange efficiency, and per-inlet tracers.

• Method: Lattice Boltzmann LES (D3Q19, regularized BGK, Smagorinsky Cs 0.10, synthetic inflow turbulence), Re ≈ 10⁵ on building height. The tunnel runs 2H upwind, 4H downwind, 1.5H to each side and 2H above. The resolutions are:

  • Coarse: 120,000 cells, about 15 s, openings 4–5 cells across, reading about 25 % low.
  • Fine: 400,000 cells, about 1 min.
  • Finest: 1,000,000 cells, about 3 min, within 5 % of fine.

  It runs as WebAssembly SIMD across worker slabs, with an optional WebGPU engine that self-checks against JS. The age-of-air pass uses a Poisson-projected flux, TVD advection, BiCGSTAB with ILU(0), and five conservation checks. Its eddy diffusivity is fitted on five cases (errors −13 % to +5 %).

• Fidelity: Screening estimate.

• Professional equivalent: OpenFOAM (Eddy3D, Butterfly), Ansys Fluent or Autodesk CFD, usually RANS on meshes of several million cells or more. SimScale's pedestrian-wind solver is also LBM.

• Trust it for / don't use it for: Trust it for seeing jets, dead zones and which openings actually work, and for comparing two layouts at the same resolution. Don't use it for comfort, wind-load or stack claims.

• The gap:

  • The domain is far below COST 732 / AIJ practice (COST 732: 5H upstream, to the sides and above, 15H downstream; AIJ: 5H to the sides and above, at least 10H downstream; both ask blockage under 3 %). Blockage here is about 13 % on the jig, which raises the cross-room pressure.
  • It is isothermal (no stack), on flat ground, with one wind direction per run.
  • Wakes run long: reattachment behind a cube is at 2.8H, against about 1.6H measured.

• Code: src/lib/crucible/v6/air-cfd.ts, src/lib/crucible/v6/air-cfd-params.ts, src/lib/crucible/v6/air-interior.ts, src/app/(app)/tools-3d/crucible/crucible.cfd.worker.ts

Rendered layer (V1, V2, V6–V8)

A path-traced picture of the massing on its site.

• What it adds: A WebGL2 path tracer, accumulated to 2,000 samples, with sixteen blend modes over the other layers.
• Method: The sky is a Perez all-weather luminance distribution (Radiance gendaylit coefficients) over Tregenza patches. Beam and diffuse come from the ASHRAE clear-sky model, scaled by a Clear / Partly cloudy / Overcast setting, not the weather file. The sun is a 0.53° disc. BVH triangles, simple materials.
• Fidelity: Authoring.
• Professional equivalent: Enscape, V-Ray, Cycles (Radiance if the image must be photometric).
• Trust it for / don't use it for: Trust it for massing images and shadow pictures. Don't use it for reading a light level or a glare judgement.
• The gap: No textures, entourage or denoiser, simple BRDFs, and a clear-sky model with a cloudiness factor instead of the weather file's sky. It is not calibrated luminance the way Radiance output is.
• Code: src/app/(app)/tools-3d/crucible/render-pathtracer.ts, src/lib/crucible/render-sky.ts, src/lib/crucible/render-scene.ts

Shared across all options

Engine by version (from code):

Claude calls (src/app/api/crucible/route.ts): the only model spend. It returns 401 when signed out and is metered. Modes:

• author / edit (Authoring): writes a build() program, linted for no import, fetch or while(true), and run in a network-stripped worker. Up to 8,000 tokens. The Max tier (Opus) is only for owners and collaborators.
• ask (AI reading): answers over the live metrics.
• brainstorm (AI reading): at most four goals on catalog keys.

The default tier is Fast (Haiku); Deep is Sonnet. An env-gated "Open" tier can route a call to an open-weight model where the server configures one (lib/anthropic/models.ts). Every number still comes from the engine.

The readings, with the versions that carry each:

The constants behind each reading are as in the tool-level section: the 1¼ in ray lift, BS 5925 T̄ = 293.15 K, the U-values 0.056/0.039/0.053/0.32 Btu/h·ft²·°F, 0.3 ACH leakage, the 68 °F set point, ICE factors and the 27.9/55.7 kgCO₂e/ft² lines. All exports (the .3dm surfaces-and-mesh pair and watertight STL in every version but V3, Save, and the hand-offs) carry geometry only, not simulation results.

• Our method:
  1. Sample. Latin hypercube (McKay et al. 1979): per gene, a seeded Fisher–Yates permutation of n strata with a jitter inside each stratum. Or a k^G grid capped at 200. Points are snapped to each slider's step and deduplicated.
  2. Or search. The shared lib/conjure/nsga2.ts: constrained domination (Deb 2002), fast non-dominated sort, crowding distance, binary crowded tournament, SBX ηc 15 at p = 0.9, polynomial mutation ηm 20 at p = 1/G, and elitist (μ+λ) survival. The seed is the current design. Population is 8–60 (default 28) and generations 3–60 (default 18). Generations are trimmed until population × (generations + 1) ≤ 3,000. A thrown build or a null KPI becomes a NaN objective, which is penalised as +1e6 constraint violation.
  3. Score. The worker compiles the rails program, builds, converts to Proving Ground's SemanticGeometry and runs evaluate(). KPIs bind to Scoreboard's metric ids. "Derived" ids must carry an engine note naming the substitution.
  4. Mark the front. An O(N²) scan marks non-dominated variants; nulls are skipped, not zeroed. The knee is the front member nearest the min–max-normalised ideal corner, unweighted.
  5. No AI call. Signed-in runs log a trace row.
• The professional method:
  • Wallacei runs NSGA-II for as many generations as you set and stores every individual of every generation. It gives fitness-trend and standard-deviation charts per objective, k-means phenotype clustering, and lets you reinstate any individual.
  • Octopus uses SPEA-2/HypE with elitism and archive handling, and supports user-steered "preference" search.
  • Design Explorer only browses a precomputed catalogue, usually full-factorial from Colibri.
• The gap, specifically:
  • Search mode shows only the final population, deduplicated (at most 60 rows). It does not show the up to 3,000 designs evaluated along the way. A good design found in generation 4 and crowded out later is invisible. Wallacei would still show it.
  • Small budgets. At most 3,000 evaluations (population 60 × 50 evaluation rounds: the seed population plus 49 generations), 8 genes, continuous genes snapped to steps. On a rugged multi-objective landscape the reported front is "best of what we looked at".
  • No convergence diagnostics. There is no hypervolume, spread or clustering, only a front-size-per-generation chart. You can't tell whether more generations would help.
  • The objectives are proxies. Proving Ground's metrics are screening physics. A Wallacei study wired to Honeybee or Karamba optimises validated numbers. Swarm optimises proxies faster.
  • The knee point uses implicit equal weights (labelled as such). Octopus/Wallacei let you weight or pick interactively.
• Where ours is as good or better:
  • Sampling. Latin hypercube with step-snap dedup gives better marginal coverage per evaluation than Galapagos-style random initialisation.
  • Nulls are never zeros, and infeasibility is explicit.
  • Axes share ids and blind-spot notes with Scoreboard, which no pro tool enforces.
  • Zero install, reproducible from a seed.
• Code: src/lib/swarm/run.ts, src/lib/swarm/sample.ts, src/lib/swarm/dominate.ts, src/lib/conjure/nsga2.ts, src/app/(app)/tools-3d/swarm/swarm.worker.ts

• Our method:

  • Thresholds, stated once in lib/rap/fingertip.ts:

    • minimum raised line 0.02 in (0.5 mm);
    • ridges fuse below about 0.08 in (2 mm) pitch;
    • about 0.1 in (2.5 mm) of blank paper between textures;
    • at most 7 distinct fills.

    Plates are checked against these numbers.

  • Tactile Image.

    1. A probe measures paper share, mid-tone share, stroke thinness and tonal flatness.
    2. Tones are banded by hand thresholds or by 1-D Lloyd k-means on the histogram.
    3. Rulings are inked by perpendicular distance, so pitch is true at any angle.
    4. A groove of blank paper is cut at band boundaries, and features under the minimum are despeckled.
    5. The plate is tiled onto 8.5 × 11 or 11 × 17 in sheets and exported as PDF at 100 %, with a separate key sheet with braille dots.

  • Relief STL.

    1. The plate is regridded at 0.012 in (0.3 mm).
    2. Heights are in whole 0.008 in (0.2 mm) layers: base 4, ink 3, band steps 0–6 (default 0, flat like swell paper).
    3. It is meshed directly as a closed stepped surface, with no booleans and T-junctions avoided. Diagonal pinches are filled.
    4. It is audited for naked, over-shared and mis-wound edges, and Manifold confirms one closed body.

  • Tactile Drawings.

    1. Import and weld (250,000-triangle budget).
    2. Slice at the cut and hatch per layer.
    3. Extract feature edges (boundary, crease, silhouette) and test visibility by sampling along each edge at page-diagonal/700. A uniform page-space grid is the occluder index.
    4. Section pair: vertical slabs every slice interval (max 12 bands, about 1/16 in (1.5 mm) per step, a 5/64 in (2 mm) plate), unioned per object in Clipper2/Manifold CrossSection. Stepped or continuous h(d) depth, with a notched depth ramp, and Manifold union to a watertight STL.

  • Braille. Uncontracted Grade 1 Unicode with capital and number indicators, and a totality contract (no dropped characters). Output is NABCC .brf at 40 × 25. Title-block dots are 0.055 in (1.4 mm) on a 0.098 in / 0.244 in (2.5 / 6.2 mm) dot / cell pitch.

  • Alt Text (Fast/Deep toggle, vision):

    • Input. A system prompt built from UI settings, one image, max_tokens = clamp(700 + 6 × word budget, 1,500, 8,000), thinking off.
    • Output. Macro/meso/micro, alt, confidence, uncertain list, verbatim text.
    • Server check. The server nulls the identification when naming is off. A coach pass turns complaints into at most 4 bounded style rules.

  • Studio assistant. It returns Controller command strings. Every command is dry-run through the real interpreter in order. A deny-list (phase, focus, schema, clear, reset, undo, redo, room, diff, mark) is enforced server-side. It gets one repair round, and the spoken reply is rewritten so it never claims an edit that did not apply. Ask mode has no commands field.

• The professional method:
  • A tactile transcriber redraws rather than converts. They simplify, choose what to omit, re-layout, and add a key and transcriber's notes to BANA guidance. Tiger/TactileView automate conversion but still expect that editing.
  • Duxbury/liblouis do rule-based Grade-2 contraction with formatting codes.
  • Make2D computes exact analytic visibility over NURBS and meshes.
  • Human describers know context the pixels don't show.
• The gap, specifically:
  • Grade 1 only. Longer text, and not what most adult braille readers read fluently. Every export says so.
  • Conversion, not interpretation. The editorial simplification a transcriber does is not automated. The probe and warnings help, but a dense architectural photo will still produce a busy plate.
  • Sampled HLR. Visibility is sampled along edges, so short hidden or visible transitions shorter than the step can be misclassified. It is orthographic only.
  • Uncalibrated constants. The section-pair constants and fingertip thresholds are working figures from published guidance, not yet measured on this studio's PIAF or printers.
  • Alt text is a model reading pixels. It can misread. The contract (state what it couldn't tell, identification labelled as a claim) reduces but does not eliminate confident error. The Studio assistant can still produce a valid command that isn't what the student meant. The dry-run proves "applies", not "intended".
• Where ours is as good or better:
  • Integration. A blind student's own Rhino model becomes scaled tactile sections in minutes. No commercial product does model-to-tactile-section plus a depth-coded 3D print.
  • Self-audit. The totality contract and fingertip self-audit are stricter than typical conversion software.
  • Command-level auditability. The Studio's model is plain text commands, auditable line by line, with a server-enforced deny-list. That is a stronger AI guard than general assistants offer.
• Code: src/lib/rap/fingertip.ts, src/app/(app)/rap/image/engine/pipeline.ts, src/lib/rap/relief-stl.ts, src/app/(app)/rap/tactile/engine/hlr.ts, src/app/(app)/rap/tactile/engine/sectionPair.ts, src/app/api/rap/agent/validate.ts

• Our method:
  1. Solve. Clamp, then solve the roof in "ridge" mode (ridge height + offset give the pitches) or "slopes" mode (runL·tanθL = runR·tanθR, runL + runR = width).
  2. Take off sheets. Lay a 4 × 8 grid in both orientations, Sutherland–Hodgman clip against each cell, count every touched cell, and keep the cheaper orientation. This is an upper bound with no offcut reuse.
  3. Loads.
     • Snow: pf = 0.7·Ce·Ct·Is·pg; Cs = 1 − (θ − 15°)/55 for a slippery unheated roof; the low-slope minimum below 15°.
     • Roof live: Lr 20 psf.
     • Wind: qh = 0.00256·Kz·Kd·V² with Kz = 2.01(z/zg)^(2/α) (exposure B: 7 / 1,200 ft; C: 9.5 / 900 ft), Kd 0.85, Kzt = Ke = 1.
     • Wall pressures: girts qh(1.0 + GCpi); columns qh(0.85·0.8 + GCpi); GCpi 0.18 or 0.55.
  4. Member checks. NDS No. 2 values with CD, CF, Cfu and Cr 1.15, CL = 1 assumed braced. Bending, shear at 1.5V/A, deflection 5wL⁴/384EI against IBC 1604.3 limits. Columns use Cp with c 0.8 and the 3.9.2 interaction, Kf 0.6 for nailed plies. Footing by 1,500 psf presumptive bearing.
  5. Size. The auto-sizer runs up to four passes.
  6. Loft. 50 psf office live load and a 7 ft headroom check.
  7. Drawings and estimate. Drawings go to an R12 DXF in inches. The estimate is quantity × waste × price + tax + labour, then trade and project markups. Leveling flags outliers at more than 25 % from the median and flags <80 % / >125 % of our estimate.
  8. Foreman. A toggle-tier model, maxTokens 2,000, via runWithRepair. Every edit is resolved against a registry, snapped and range-held, previewed on a copy, and applied only on click.
• The professional method:
  • Post-frame engineering treats posts as embedded or pier-mounted cantilevers (EP486). It designs roof and wall diaphragms to carry lateral load to end walls (EP484), with wind by MWFRS directional or envelope procedures including uplift (0.6D + 0.6W). It adds unbalanced and drift snow and designs connections.
  • Truss manufacturers run full truss analysis.
  • Estimators use local price books or supplier quotes.
• The gap, specifically:
  • No lateral system. There are no diaphragm or bracing checks and no embedded-post bending or embedment depth. For a post-frame barn these often govern post size, so column sizes here can be unconservative.
  • No uplift combination (0.6D + 0.6W) and no connections. Roof purlin and truss hold-downs are unchecked, which can be the governing failure in wind.
  • Snow is balanced only. There is no unbalanced, drift or sliding snow, and no rain-on-snow. Unbalanced loads on the leeward slope can exceed balanced by tens of percent.
  • Simplified wind. Column wind uses windward MWFRS only and girts use a flat GCp −1.0. Corners (zone 5) run higher, so the girt check is unconservative there; it also credits no composite stiffening from the steel panels, which errs the other way.
  • ASCE 7-16, not 7-22. 7-22 changed ground snow to risk-category-specific values, and the owner types pg and V.
  • Ballpark prices (Sep 2026 US Midwest).
  • Schematic drawings. The DXF has exploded dimensions and no hatches.
• Where ours is as good or better:
  • Integration and legibility. One model drives drawings, takeoff, the pre-check and bids, so they can't disagree. Every check prints its formula with numbers substituted, which a sizing tool like ForteWEB doesn't show as plainly.
  • The sheet count is a defensible upper bound.
  • The Foreman can't change a number without the engine's before → after.
• Code: src/lib/barn-jig/model.ts, src/lib/barn-jig/sheets.ts, src/lib/barn-project/structure.ts, src/lib/barn-project/takeoff.ts, src/lib/barn-project/foreman.ts

• Our method:

  1. Charges. A point is a distance to a point. Line and polyline charges are capsules (closest-point to segment). A mesh charge uses a triangle BVH with a closest-point query, capped at 20,000 triangles.

  2. Falloff. With u = (d/R)² and r = d:

     • Wyvill: 1 − (22/9)u + (17/9)u² − (4/9)u³, which is C¹ at R (value and slope both zero there; the second derivative jumps).
     • Bourke: 1 − 3(r/R)² for r ≤ R/3, else (3/2)(1 − r/R)², which is C¹.

     Both are exactly zero beyond R.

  3. Sparse grid. Cells are activated only where some charge's support reaches. If the estimate passes 2,000,000 cells, the cell size doubles.

  4. Polygonize. Marching cubes (Lorensen & Cline; Bourke's tables), with corners cached and vertices welded by edge key. Iso is clamped 0.01–0.99.

  5. Refine (optional). Newton projection along the analytic gradient, after an optional midpoint subdivision.

  6. Measure and export. Volume by the divergence theorem, area from Float64 positions. Export to OBJ, binary STL, or a .3dm mesh; the surfaces row is disabled with a stated reason.

  7. Where it runs. Everything runs in a Web Worker, which the page terminates to cancel. It runs no authored code, only charge data.

• The professional method:
  • Cocoon evaluates a summed charge field (point, curve, Brep charges) and runs marching cubes, with a refine/resample step. It lives inside Grasshopper, so charges come live from any upstream geometry.
  • Dendro converts geometry to OpenVDB level sets. Its sparse narrow-band volumes do smooth, offset and boolean at far higher resolution.
  • ShrinkWrap (Rhino 8) wraps any geometry into a watertight mesh by voxel offsetting.
• The gap, specifically:
  • Resolution ceiling. 2,000,000 active cells in a browser worker is well below Dendro/Houdini VDB, so fine details between charges smear. Cell size auto-coarsens on large setups.
  • No true Brep charges. Imported geometry is meshed and capped at 20,000 triangles, so the distance field follows the tessellation, not the NURBS.
  • Classic lookup-table marching cubes with no ambiguity-resolving variant (asymptotic decider / MC33). Rare topological ambiguities at saddle cells are possible (unverified whether any arise here). The mesh has uniform-voxel triangles with no adaptive remeshing. Our refine pass reduces the iso error but does not remesh; Cocoon's Refine component is described as also cleaning up marching-cubes triangulation and valence (unverified in detail).
  • No SubD/NURBS output. The surfaces row is disabled with a stated reason; Rhino's QuadRemesh is the next step.
  • The STL row is a plain binary STL of the MC mesh, written in raw studio units with no scale picker (the .3dm mesh row reads studio units as metres). It is not passed through a Manifold watertightness check. The mesh is closed by construction when the surface is closed, but check it for closure and scale before printing.
• Where ours is as good or better:
  • Correct sparse activation. Compact-support kernels make sparse activation exact rather than heuristic.
  • Exact volume and area on the welded mesh.
  • Built-in mirror and linear/radial array authoring, and SVG-to-tactile import. Cocoon has no such components of its own; in Grasshopper you would build these upstream.
  • Zero install, with a readable choice of falloff.
• Code: src/lib/wrap/field.ts, src/lib/wrap/grid.ts, src/lib/wrap/marching-cubes.ts, src/lib/wrap/refine.ts, src/app/(app)/tools-3d/wrap/WrapTool.tsx

• Our method: Topology comes from five built-in builders (grid, disc, tube, line, scatter) or a welded OBJ/.3dm. Each frame runs 4 substeps (dt 0.02). First, force goals (gravity weighted by tributary area on the rest geometry, point loads, pressure, one-sided wind) feed a Verlet step with damping 0.98. Each step's move is clamped to half the mean rest edge. Next come 20 Jacobi projection rounds: every projection goal proposes a move and a weight, and each particle moves by Σ(w·move)/Σw. Pins have infinite weight. Settling means the largest move stays under 6×10⁻⁵ of the mesh span for 4 consecutive substeps, with a hard stop at 4,000 steps. There are ten presets, which are saved goal stacks. Material "bundles" such as chain, fabric and "stiff shell" are stylised stiffness and density numbers. An anchor reaction is the sum of (d − rest) over the incident edges, in solver units. No AI, no data.
• The professional method: Kangaroo2 treats nearly everything, loads included, as a projection goal and adds a momentum term. Force density (Schek 1974) solves one linear system for a chosen force-to-length ratio q. Dynamic relaxation (Barnes) integrates real member stiffnesses and masses to a static state. Membrane codes form-find with isotropic surface stress and then patterning.
• The gap, specifically:
  • Forces are unit-stiffness and uncalibrated, so they give the ratio between members at best. You cannot size a cable from them.
  • Soap film is a uniform-weight zero-rest spring net. That gives a uniform-weight (umbrella-Laplacian) equilibrium, not the cotangent-weight discrete minimal surface. Near uneven boundaries and dense corners the surface visibly departs from a true soap film.
  • The shape of a hanging net depends on spring stiffness against gravity (stretchy nets sag more). In force density you choose q directly. So "the" funicular here is one of a family.
  • Wind is a steady push on projected area. Friction is a stylised stick.
• Where ours is as good or better: It uses the same move form as Kangaroo2, with no Grasshopper and runs in a browser. The goal deck is inspectable, and the hang, invert and send-to-Truss loop is fast for teaching Hooke's inversion.
• Code: public/tools/catenary/web/engine.js · public/tools/catenary/index.html · src/app/(app)/tools-3d/catenary/page.tsx

• Our method: Planarity is diagonal distance / mean diagonal. Defaults are 1/100 for flat and a cold-bend warp knob that opens at 25 mm (≈1 in). Glass and metal presets set it to diagonal/2000 and diagonal/300. Planarising runs up to 120 quasi-static steps on Relax's goal kernel: coplanarity, an anchor at 0.05 strength, smoothing and periodic cluster-snap. A leash of r × 5% of the bounding diagonal limits how far any vertex can move. Flat clustering is greedy. Horn's quaternion fit is tried over 8 ring correspondences, with a reflected copy when mirroring is allowed. The mould tolerance defaults to 3 mm (≈⅛ in) and is loosened by the repetition slider. Curve mode fits a Gaussian-weighted local quadric (Monge jet) with a 40° crease cutoff. It classifies by the sagitta s = κa²/2, and a panel whose corner residual exceeds the budget (default: the larger of diagonal/100 and 3× the mould tolerance) goes FREEFORM. The coach route (auth-gated, metered, 600 output tokens) responds to a committed part-count guess, so it answers only in predict mode (?predict=1). It re-runs the clustering on the server before the model writes.
• The professional method: EvoluteTools and the Pottmann/Liu/Eigensatz line solve a joint nonlinear optimisation. The design surface moves inside a tolerance while panel types and moulds are shared, using second-order solvers and PQ or conical constraints.
• The gap, specifically:
  • The counts are greedy and order-dependent with the surface held fixed. They are true upper bounds, so the real minimum can be much lower after joint optimisation.
  • Planarisation is first-order. On strongly double-curved nets whose layout is not near a conjugate network it stalls at the leash rather than finding a PQ mesh.
  • Curvature is fitted to the mesh vertices, not a NURBS design surface. A boundary panel is fitted from one side and can read one rung more curved.
  • There is no glass stress, springback, thickness, trim or tolerance stack-up. Cold-bend numbers are stated as unverified.
• Where ours is as good or better: The planarity metric and the sagitta mould-sharing rule are exact and transparent. It is fast and free, and the two-mode comparison, where one tolerance governs every class, teaches well.
• Code: public/tools/panelizer/web/solve.js · web/cluster.js · web/panelfit.js · web/planarity.js · src/app/api/panelizer/route.ts

• Units: Spans are shown in metres (feet in parentheses) and wind speed is entered in m/s.
• Our method: The stock typologies and space frame build a node/member graph. A pin goes at the lowest left node and a roller at the right. Loads split equally over nodes in the top or bottom 15% height band, or come from a sliding point load. Wind is a horizontal total H = ratio × W over the top band. It is superposed on gravity with both factors at 1.0 and compared against a gravity-only solve to flag sign reversals. Maxwell's rule is checked first. Then comes Gaussian elimination with partial pivoting, where a pivot below 10⁻¹⁰ × the largest diagonal counts as a mechanism. The "buckling watch" ranks struts by |N|·L². It is a ranking, not a capacity. The deflected shape is drawn at a fixed fraction of the span.
• The professional method: SAP2000, RISA and Karamba use the same linear stiffness method, but with real E, A and section catalogs. They add self-weight, ASCE 7 load cases and LRFD/ASD combinations (1.2D+1.6L, 0.9D+1.0W, …), P-Δ where asked, and AISC 360 / NDS member checks with K-factors.
• The gap, specifically:
  • Indeterminate trusses (lattice, X, double Warren, space frames): real force splits follow relative EA. Equal EA can misassign forces between redundant paths by tens of percent when chords are much stiffer than diagonals.
  • There is no self-weight, which in a long-span steel truss is a large share of the load. There are no load factors either. The wind reversal check is close in spirit to 0.9D+1.0W, but it is unfactored.
  • There is no buckling capacity (no KL/r, no AISC E3 column curve) and no connection eccentricity.
• Where ours is as good or better: It gives the exact determinate answer and reports mechanisms explicitly. The load-path lesson is instant and costs nothing.
• Code: public/tools/truss/web/engine.js · public/tools/truss/index.html · src/app/(app)/tools-3d/truss/page.tsx

• Large parts: A part with more than 512 vertices is matched on its measured invariants alone, without the vertex-level check, so a mirrored left and right pair of that size counts as one part.
• Our method: A 27-neighbour quantised spatial-hash weld is followed by union-find over triangles, capped at 8,000 parts. Each part gets a divergence-theorem volume, an area-weighted covariance diagonalised by Jacobi (principal frame, oriented bounding box) and a sheet flag. Congruence buckets parts by exact triangle count and runs a tolerance-widened gate on box dimensions, area and volume. Then a part with 512 or fewer unique vertices is tested in 24 proper re-framings (48 with mirroring) with nearest-neighbour pairing and a Kabsch polish. The flat layout puts each part on its thinnest face. It finds the exact minimum-area rectangle, which shares a side with a hull edge (Freeman & Shapira 1975), and packs next-fit-decreasing-height by shelves. The fill percentage is printed. The round-barn demo reuses Barn Jig's solver.
• The professional method: In BIM and MCAD, parts are already discrete objects with types, so schedules count by family or type, not by geometry. Shop software adds grain, stock optimisation, kerf and machining. Commercial nesters use true-shape (no-fit-polygon) nesting with rotations.
• The gap, specifically:
  • The split is by connectivity only. Touching parts merge and the count moves with the weld tolerance.
  • Shelf packing of bounding rectangles wastes material. True-shape nesting typically fills a plate noticeably better, and the gap is largest for triangles and L-shapes.
  • Footprints are projected shadows. A curved piece is not unrolled.
• Where ours is as good or better: Counting by geometry rather than by name catches "different" parts that a BIM schedule labels the same, and the reverse. It reads a dumb mesh from any source and runs in the browser.
• Code: src/lib/parts/split.ts · src/lib/parts/congruence.ts · src/lib/parts/layout.ts · src/lib/parts/barn.ts · src/app/(app)/tools-3d/parts/PartsTool.tsx

• Units: Armature works in SI with European sections and grades: loads in kN and kN/m, moments in kN·m, deflections in mm, stresses in MPa, steel sections such as IPE with grade S235, and C24 timber. Convert before comparing with US tables.
• Our method: analyze() builds 6×6 local stiffness matrices from E, A and I (strong axis). It converts member UDLs, including self-weight = A·ρ·g with g = 9.80665 m/s² (32.17 ft/s²), to equivalent nodal loads and condenses released rotations. Gaussian elimination with partial pivoting follows. A pivot below 10⁻¹⁰ × scale yields a null vector that drives the mechanism advisor. Diagrams are sampled at 17 stations, plus the interior extremum of M. Utilisation = max(|N|/A / f + M/W_el / f_m, |N_c|/N_cr). N_cr = π²E·I_min/L² with K = 1 over the element length. Strengths are characteristic with γ = 1. The optimiser walks each group's catalog to the lightest section with utilisation ≤ target (default 1.0), re-solving up to 12 passes. Catalogs: IPE (European table), CHS/SHS computed, rectangular timber, rod. Materials: S235 (34 ksi / 235 MPa), S355 (51 ksi / 355 MPa), 6061-T6, C24, GL24h.
• The professional method: Karamba3D runs 3-D beams and shells with second-order theory, eigenmodes, buckling eigenvalues and BESO, and its Optimize Cross Section component designs to EN 1993-1-1 (Eurocode 3), including flexural and lateral-torsional buckling and cross-section classes 1–4 (Karamba3D manual). SAP2000 and RISA generate ASCE 7 combinations, run P-Δ and modal analysis, and design to AISC 360 (LRFD φ, or ASD Ω) and, in RISA, NDS.
• The gap, specifically:
  • No load or resistance factors. An LRFD design (≈1.2D+1.6L, φ = 0.9) or ASD design (Ω = 1.67) carries about 1.5–1.8× more margin. With the default target of 1.0, optimised sections are correspondingly under-sized where strength governs.
  • Euler-only buckling, no column curve. At the yield/Euler crossover (F_e = F_y), AISC E3 gives F_cr = 0.658 F_y, so this check overstates capacity by about 1.5× for intermediate-slenderness struts. K = 1 is applied regardless of end fixity. For a drawn column split into several elements, N_cr uses each element's length, which is unconservative. (Rotunda checks buckling over the whole physical run instead.)
  • There is no lateral-torsional buckling, which is unconservative for unbraced beams. The elastic W instead of plastic Z makes compact braced beams about 12–15% conservative. Shear and shear deformation are ignored.
  • Timber uses EN 338 characteristic values with no k_mod/γ_M or NDS adjustment factors. That is roughly 2× less conservative than a code check.
  • There is one load case, no pattern loading, and only 2-D.
• Where ours is as good or better: The first-order solve is exact within its theory. The mechanism advisor (zero-energy mode, then ranked fixes) is friendlier than a "singular matrix" error. It is free, instant and open to inspection.
• Code: public/tools/armature/web/engine.js · public/tools/armature/index.html · public/tools/armature/test/engine.test.mjs · src/app/(app)/tools-3d/armature/page.tsx

• Our method: Snow is 25 psf on plan, roof dead load 15 psf on slope, mow deck 12 psf, and hay per unit volume tapering with the mow. All are applied through the tributary width 2πr/n, so they grow with r. Self-weight is applied by Rotunda so the ties stay weightless. Each ring's tie has area 2·sin(π/n)·A, which makes its stiffness match δr = T·r/EA. The tie force is the rib's radial thrust P, converted to hoop T = P/(2 sin(π/n)). Buckling is re-checked over the whole physical run, not per element. Sheathed runs use L_eff = hoop spacing. Material is C24 or GL24h (European characteristic values) in US nominal sections. Wind is handled only as a global drag comparison, C_d 0.7 round against 1.3 rectangular.
• The professional method: A shell or plate model of the roof, or a full 3-D frame of every rib and ring. Hoop action is then everywhere, and asymmetric load cases (ASCE 7 wind, unbalanced snow), ring out-of-round buckling, P-Δ and NDS-adjusted timber design are all available.
• The gap, specifically:
  • Only axisymmetric loads are modelled. Real governing cases for a round roof are often asymmetric (wind, unbalanced snow), which puts bending in the ring that this model cannot see.
  • A compression ring is taken as infinitely stable in plane. Out-of-round buckling is not checked, which is unconservative for a light curb.
  • The deck-as-hoop switch adds axial area to one ring only. There is no true shell action, which would make the real barn stiffer.
  • Timber utilisation is against C24 characteristic strength with γ = 1. An NDS ASD check on comparable lumber is roughly 2–3× more conservative.
• Where ours is as good or better: The ring-as-spring reduction is exact for n ribs (polygon statics). It turns a hard 3-D question into a readable section, and it is grounded in a primary source (Bulletin 143).
• Code: public/tools/rotunda/web/engine.js · public/tools/armature/web/engine.js · public/tools/rotunda/index.html · public/tools/rotunda/test/engine.test.mjs

• Our method: Floor-to-floor = plates + stud + joist depth + drawn subfloor, capped at 12 storeys. Studs sit on the module (16 in o.c. default) with a corner post owned by one wall. The header comes from a size ladder for a two-ply header: 2x4 to 2 ft, 2x6 to 4 ft, 2x8 to 6 ft, 2x10 to 8 ft, 2x12 to 12 ft of opening. Only the 2x12 rung reaches the carpenter's "foot of opening per inch of depth" ratio; the smaller rungs stop short of it. Joist and rafter spans come from a built-in #2 SPF table (40 psf live / 10 dead / L/360 for joists; 20 psf / L/180 for rafters). A species multiplier (0.99–1.09) is applied, then span × (base/actual live load)^(1/3). A girder and posts appear when the clear run exceeds the table. The support oracle joins members within ⅛ in (½ in for masonry) and flood-fills from members bearing within ½ in of the datum. The takeoff uses nominal board feet and rounds cuts up to stock 8–24 ft. The other systems (balloon, timber frame, CLT, cast concrete, CMU) are geometry plus takeoff. Rebar and formwork are ratio estimates.
• The professional method: Code prescriptive tables (IRC R502/R802/R602) plus braced-wall-line design, or engineered design to NDS with adjustment factors (C_D, C_F, C_r, C_L) and load combinations. Framing CAD produces shop-ready panels.
• The gap, specifically:
  • Spans are a single-species table plus multipliers; they are not re-derived. The load-scaling rule span ∝ w^(-1/3) only holds for deflection-governed spans, so at high loads where bending governs it is unconservative. The joist cells run a few percent short of IRC Table R502.3.1(2) (for example, 2x10 SPF #2 at 16 in: 14 ft 11 in here against 15 ft 5 in in the IRC), so the base table errs slightly conservative.
  • There is no lateral system (braced walls, hold-downs), no point-load path from girders to foundations, and no hips or valleys.
  • The support check is connectivity only, not a load path.
  • The stud-height limit allows 2x6 bearing studs to 20 ft. IRC Table R602.3(5) lists 10 ft for laterally unsupported 2x6 bearing studs; 20 ft is the non-bearing figure. Taller bearing studs need R602.3.1 Exception 2 (Table R602.3.1, limited conditions) or engineering.
• Where ours is as good or better: It goes from massing to sticks in seconds, straight from Proving Ground solids. The floating-member oracle catches modelling errors that framing add-ins happily draw. Every rule is a visible parameter.
• Code: src/lib/stick/build.ts · src/lib/stick/lumber.ts · src/lib/stick/floors.ts · src/lib/stick/roof.ts · src/lib/stick/support.ts

• Our method: R = clamp(round(H / target riser), 2, 80), and riser = H/R. The checks, in exact mm, are: riser 100–180 mm, going ≥ 250 mm, 2R+G 600–640 mm, and headroom as a reminder only. In ramp mode, the number of segments = max(ceil(rise/760 mm), ceil(run/9,000 mm)), with a fixed 1,500 mm landing. Slope passes if it is 1:12 or flatter. Output is an OBJ in mm and a dimensioned SVG. The display is imperial by default.
• The professional method: IBC §1011: riser 4–7 in, tread ≥ 11 in, uniformity within ⅜ in, width ≥ 44 in (36 in for an occupant load under 50), headroom 80 in, and at most 12 ft vertical rise per flight. Also handrails (§1014), guards (§1015) and landings at least the stair width. For ramps, IBC §1012 and ADA §405: slope ≤ 1:12, ≤ 30 in rise per run, landings ≥ 60 in, clear width ≥ 36 in, cross slope ≤ 1:48, handrails when rise > 6 in, and edge protection.
• The gap, specifically:
  • The riser check accepts risers up to 7.09 in (180 mm). IBC 1011.5.2 caps risers at 7 in. At the tool's defaults (10 ft / 3,048 mm, target 7 in / 178 mm) it rounds to 17 risers of 7.06 in (179.3 mm) and shows a pass, so check risers against the code yourself.
  • The going minimum of 250 mm (9.8 in) is looser than IBC's 11 in.
  • The ramp landing is a fixed 1,500 mm tested against ≥ 1,500 mm, so the landing check always passes. 1,500 mm is 1 in short of ADA's 60 in.
  • Both caps sit just under ADA's: 760 mm is 29.9 in and 9,000 mm is 29.5 ft. So a full 30 in rise at 1:12, which ADA allows as a single 30 ft run, is split into two runs with an extra landing. This errs long, not unsafe.
  • Width, handrails, guards, nosing, flight rise ≤ 12 ft, landing depth and ramp cross slope are all unchecked.
• Where ours is as good or better: It is quicker than a BIM stair for iterating footprint and run. The developed section and the exact-mm model are handy.
• Code: public/tools/stair/index.html · src/app/(app)/tools-3d/stair/page.tsx

• Our method: subtreeMass recurses the tree. Arms are pivot·L and (1−pivot)·L. An arm is balanced when |net moment| ≤ 0.1% of the larger moment. Auto-balance works bottom-up, and branching splits a weight's mass evenly. Tilt = sign × min(1, 2.4 × relative imbalance) × 78°. That is a diagnostic, not an equilibrium angle. Strings always hang vertically. The on-screen motion adds sinusoidal sway of 0.06 or 0.02 rad to each arm's resting tilt. Layout is a single 2-D elevation.
• The professional method: For design, nobody uses dedicated software. A fabricator hand-balances or computes centres of mass including the rod. A dynamic simulation would model rigid bodies on pinned joints with air drag.
• The gap, specifically:
  • Rod self-weight is ignored. It pulls the balance point toward the rod's midpoint: p = (m_R + m_rod/2)/(m_L + m_R + m_rod). For a 3:1 split with a rod weighing 10% of what hangs from it, the pivot moves by about 2% of the rod length.
  • Real Calder arms are bent, so attachment points sit below the pivot and an unbalanced arm settles at a finite, stable tilt. Here the tilt is a capped visual cue, not that angle.
  • There is no out-of-plane rotation, collision between arms, or air.
• Where ours is as good or better: The balance arithmetic is exact and shown. It is instant and good for teaching moment equilibrium.
• Code: src/lib/calder/model.ts · src/lib/calder/layout.ts · src/lib/calder/render.ts · src/app/(app)/tools-3d/calder/Calder.tsx

• Our method:
  • SQUEEZE: seven postures with folded heights of 0.75, 0.62 and 0.42 × stature, with compressibility allowances (10% shoulder roll, 15% shoulder and 8% chest head-first). A separate rigid-head ellipsoid veto applies. PASS means ≥ 2 in clearance. Throughput uses a 1.5 s headway.
  • CHUTE: a = g(sin θ − μk cos θ) with g = 32.174 ft/s² and μs = 1.25 μk. Run-out is v²/(2μg), and curve load is v²/(Rg) against a self-set 1.5 g. The inverse is μ = (sin θ − a/g)/cos θ with a = 2L/t².
  • MEMBER: closed-form I, S and A for four shapes. M and Δ use support × load coefficients. Steel allowable is 0.60 F_y. Wood uses unadjusted NDS reference F_b (875–900 psi) and cast iron a self-set 6 ksi. Deflection limit L/240, with a default impact factor of 2 on people × weight.
  • CLIMB: pitch bands at OSHA's 30/50/70/75° lines. IBC and IRC riser/tread checks, Blondel 24–25 in, and Drillis & Contini knee 0.285, trochanter 0.530 and reach 1.258 × stature.
• The professional method: F1487 and CPSC set exit-region, use-zone, surfacing and critical-height rules, verified by test. AISC 360 checks compactness, LTB, shear and connections. NDS applies C_D, C_F, C_r and C_L. Ergonomic fit uses measured subjects and 3-D manikins.
• The gap, specifically:
  • MEMBER uses S (elastic) rather than Z, which is conservative by 1.1–1.7× depending on shape (a solid round is 1.7). Unadjusted NDS F_b omits C_F, which is conservative by up to 1.5× for a 2x4. But LTB, shear, connections and corrosion are unchecked, and those govern found members.
  • The μ table is order-of-magnitude. Drag is omitted, which the tool justifies as roughly 0.1 g at 20 mph.
  • SQUEEZE has no ribcage mechanics and no exit path.
• Where ours is as good or better: Every number is traceable to a formula at its control. It works offline on a phone in front of the object, and the μ back-solve is a sound field method.
• Code: src/lib/clamber/squeeze.ts · src/lib/clamber/chute.ts · src/lib/clamber/member.ts · src/lib/clamber/climb.ts · src/lib/clamber/state.ts

• Our method: Faces come from successive convex splitting. validateDesign enforces edge spans, a ¼ in corner margin, a 2° minimum line angle, 0.05 in minimum crossing separation, and breadth-first connectivity after the cuts. Each face is fan-triangulated from its centroid. Axial springs use EA = 150 and dashpots ζ = 0.45. Crease hinges (k = 40) drive toward the dialled angle, and facet hinges (k = 0.4) drive toward flat. Semi-implicit Euler runs with a displacement clamp, global damping 0.98, dt = 0.9/(2π√k_max), and targets ramped over 400 steps. The wall is a rigid tiling of one converged module with quarter-turn orientation.
• The professional method: Origami Simulator uses the same idea (axial, crease and face constraints, explicit integration on the GPU). Rigid-origami solvers enforce rigid panels and solve the kinematic constraint exactly, reporting when a pattern cannot fold rigidly. Structural origami tools (MERLIN) add large-displacement mechanics with physical stiffnesses.
• The gap, specifically:
  • The stiffnesses are tuning values, not cardstock. The face-warp magnitude is qualitative.
  • There is no self-collision, so faces can pass through each other. There is also no check between neighbouring modules in the wall.
  • Paper thickness is zero, with no bend allowance.
• Where ours is as good or better: The ruling validator (connectivity after the cuts) is specific to this studio exercise. It prints a true-scale cut sheet and runs deterministically in the browser.
• Code: src/lib/screen-wall/geometry.ts · src/lib/screen-wall/mesh.ts · src/lib/screen-wall/solver.ts · src/lib/screen-wall/wall.ts · src/lib/screen-wall/svg-export.ts

• Our method:
  • Thermal: exterior film R-0.17. The interior film depends on heat-flow direction: 0.61 up, 0.92 down, 0.68 horizontal. Wood framing uses parallel paths enumerated over all 2ⁿ stud/cavity combinations, with framing fractions from 0.28 at 12 in to 0.22 at 24 in. Steel studs use effective R = R·a/(a+R) with a = 0.68 × spacing, a fit to ASHRAE 90.1 A9.2B.
  • Moisture: temperature is linear in R along the cavity path. Vapor pressure is linear in Σ(1/perm) from indoor air to the innermost ventilated gap or outdoors. Saturation uses the Magnus formula over water. Risk is p > p_sat at interfaces and at each layer's interior peak (40-step ternary search). There are extra flags for two layers under 1 perm with material between them, and for vapor-closed cladding with no vent. Defaults are 70°F / 35% RH inside and 10°F / 80% outside. The smart retarder is a fixed 2 perms.
  • Benchmarks: U 0.045 wall, 0.026 roof, 0.033 floor ("IECC CZ5"). The wall figure is from IECC 2021; the roof figure is the IECC 2018 ceiling value, and IECC 2021 lists U-0.024, plus a Passive House ballpark.
• The professional method: THERM meshes the 2-D geometry and solves conduction with boundary films, giving U and Ψ for junctions. WUFI solves coupled transient heat, vapor diffusion and liquid transport. It uses hourly climate files, driving rain, solar and radiation, moisture storage curves and RH-dependent permeance, and reports moisture content over years against ASHRAE 160 criteria. ISO 13788 Glaser computes the monthly condensate mass and whether it dries out over a year.
• The gap, specifically:
  • There is a flag, not a quantity. The true Glaser method redraws the vapor profile tangent to the saturation curve and computes a condensation rate. Here the profile is the unconstrained straight line, so the tool cannot say how much water or whether it dries seasonally.
  • Nothing is transient: no storage, drying time, rain or solar-driven inward drive. The flags are therefore conservative for hygroscopic sheathing in mild winters and unconservative for reservoir cladding in summer.
  • Magnus over water below freezing overstates p_sat. At 14°F it is about 10% higher than over ice, so frost risk at cold sheathing is slightly under-flagged.
  • Permeance is constant. A smart retarder at 2 perms understates both its winter tightness and its summer openness.
  • The analysis is 1-D. Plates, headers, slab edges and structural bridges are invisible (the gallery is illustrative).
• Where ours is as good or better: The parallel-path and steel-derate thermal numbers are what an engineer does by hand, and they are instant. The profile drawing aligned to the section, the direction-aware films and the carbon/cost readout are good for iterating.
• Code: src/lib/wall-section/model.ts · src/lib/wall-section/types.ts · src/lib/wall-section/materials.ts · src/app/(app)/tools-3d/wall-section/WallSectionTool.tsx

• Our method: The file is parsed in the browser. A .3dm is also reopened with rhino3dm (WASM) to inventory layers, blocks and hidden or locked objects. Vertices are welded by snapping to a grid whose spacing is 1e-6 of the bounding-box diagonal (floor 1e-9). Every triangle edge is hashed by its sorted welded-index pair: one face means a naked edge, two means manifold, three or more means non-manifold. Interior edges whose two faces run the same direction are flagged as a flipped-normal proxy. Naked edges are chained into loops. The unit guess scores the longest bounding-box side under mm, cm and m, keeps the candidates that land between 4 in and 1,640 ft (0.1–500 m), and tie-breaks on log distance to 26 ft (8 m). The guess is compared with the declared unit and never replaces it. Bed fit tests five machines (Bambu A1 mini and Prusa MINI+ at 7.1 in (180 mm) cubed, Ender-3, Prusa MK4, Bambu X1/P1) with a 0.08 in (2 mm) keep-out on each side, trying both XY orientations. Triangle count is banded as light (≤150k), heavy, or very heavy (>1M).
• The professional method: Rhino tests naked and non-manifold edges on the Brep topology (the trims and edges of joined NURBS faces), not on a tessellation. Netfabb and Magics analyse the mesh like Plumb does, then add self-intersection detection, shell counting, wall-thickness and overhang analysis, and automatic repair (hole filling, normal unification, stitching).
• The gap, specifically:
  • No self-intersection test. A mesh that is closed but intersects itself gets a clean "safe for solid printing" verdict, and slicers can still fail on it.
  • No wall-thickness or minimum-feature check, which is the most common reason a study model breaks at 1:200.
  • A .3dm is checked through its render meshes. Joined polysurfaces whose adjacent faces tessellate with different vertices can show false naked edges. Meshless objects are rebuilt from the untrimmed surface, so a trimmed hole can read as filled.
  • Snapping to a grid is a proxy for a true distance tolerance: two coincident vertices that fall on either side of a cell boundary do not weld, which can produce false naked edges on noisy exports.
  • The unit guess cannot tell a correctly sized 130 ft (40 m) study model from a mis-scaled one. The tool says so.
• Where ours is as good or better: It runs instantly in the browser and uploads nothing. Findings are ranked, reported as loops rather than raw edge counts, and each one names the toolkit tool it affects. The unit-sanity check, which catches the classic "40 km building", is something pro checkers mostly leave to the user.
• Code: src/lib/plumb/edges.ts, src/lib/plumb/checks.ts, src/lib/plumb/report.ts, src/lib/plumb/beds.ts, src/lib/plumb/doc3dm.ts

• Our method:
  • Computed (deterministic): A massing is a list of solid and void boxes. For a plan cut, each box contributes its footprint polygon (rotated boxes included). For a vertical cut, it contributes the chord of its footprint on the plane, multiplied by its height range, which is an exact rectangle. Fill is the union of solids minus the union of voids, evaluated as a single predicate. There are no mesh booleans. A plane that only grazes a face counts as a miss. The student sketches on a 640×480 canvas, and the ink mask is the alpha channel above a threshold. The truth is rasterised to a grid 200 cells on its long side. The sketch is aligned by centroid translation plus one uniform scale, the ratio of RMS radii clamped to 0.25–4. Rotation and aspect are never corrected, on purpose. Score = 55% IoU + 25% voids kept open + 20% solids covered. Named misses: a void more than 45% filled, a solid less than 35% covered, and a 3×3 silhouette zone that deviates by more than 4% of the true area. Regions under 20 cells are skipped. Levels are interleaved round-robin across four difficulty buckets.
  • LLM-generated (optional): The "Explain my misses" button sends the level name, lesson text, cut axis and position, score/IoU/coverage/precision and up to ten miss lines to Claude. The default tier is Fast (Haiku 4.5), and Deep (Sonnet 5) is selectable. It returns a 90–130-word narration and one strategy tip under a JSON schema, capped at 1,200 tokens. The model never sees the sketch or the geometry. The route refuses when there are no misses and the score is zero. It returns 401 for anonymous callers, is metered, and logs usage to tool_runs. Every committed round is also logged at zero tokens.
• The professional method: Rhino and Revit compute sections of arbitrary NURBS or BIM geometry by surface-plane intersection and fill closed regions (Rhino ClippingDrawings, Revit's cut patterns). The MCT is a paper multiple-choice test. Neither scores a freehand drawing.
• The gap, specifically:
  • Only boxes (axis-aligned or rotated about Z) and principal-axis cut planes. No sloped roofs, curves or oblique cuts.
  • Only the cut profile is scored. Projected elevation beyond the plane, which is half of a real section drawing, is neither drawn nor scored.
  • The score uses weights of our own choosing. It is not calibrated against MCT results and claims no MCT equivalence.
  • The narration can only restate the engine's findings. Its value is in the phrasing, not in any extra analysis.
• Where ours is as good or better: Every miss is named in terms of which element was missed, which no CAD tool does. The truth is exact rather than tessellated. The AI is strictly downstream of a deterministic diagnosis, so it cannot invent a miss.
• Code: src/lib/sectionist/section.ts, src/lib/sectionist/scoring.ts, src/lib/sectionist/levels.ts, src/app/api/sectionist/route.ts, src/lib/anthropic/sectionist-prompts.ts

• Our method: The model is loaded (3DM through Rhino's render meshes, or STL/OBJ/PLY/glTF), scaled so its longest side is 8 units, and centred. Each of the 15 leaf projections picks one of five render paths. Parallel views use an orthographic camera at the defining direction. Dimetric is solved from the ratio as a² = r²/(2 + r²). Trimetric is inverted from two axis angles using tanθx = sinε·tanφ. Oblique views use an orthographic camera square to a face, with the projection matrix post-multiplied by a shear. The cavalier preset is 45° at full depth, cabinet is 45° at half depth, and military is 90° in plan at full depth. Perspective views use a real perspective camera (preset FOV 45°, 40° or 50°). The vanishing-point count is the number of principal axes whose view-direction component exceeds sin 1.5°. Multiview uses four orthographic panes, scissored and sharing one frustum height, and only the cell layout differs between first and third angle. For the curvilinear view, a 640-px cube map is rendered every frame and a full-screen shader samples it along r = f·θ (equidistant) up to a 160° preset. Edges are drei <Edges>, which draws crease-angle edges with a depth test, and the silhouette is an inverted-hull outline.
• The professional method: Rhino's viewports are GPU raster views as well, but Make2D produces exact vector hidden-line curves from NURBS and meshes, and Rhino has no native oblique projection. Cycles and V-Ray trace fisheye cameras per sample with full shading.
• The gap, specifically:
  • The output is raster (PNG). There are no visible/hidden vector layers, lineweights are not graded by depth, and a hidden line is simply removed by the z-buffer rather than kept as dashed geometry.
  • The multiview sheet has no title block, projection symbol or line-type hierarchy (ISO 128 / ASME Y14.3 conventions are named but not drawn).
  • The fisheye resolution is limited by the 640-px cube faces, so edges soften at wide angles. Barre–Flocon's hand construction is a different member of the curvilinear family.
  • A 3DM is shown through its render mesh, so curved surfaces are faceted.
• Where ours is as good or better: It covers the complete taxonomy in one place, measures foreshortening from the live camera instead of looking it up in a table, and has true oblique views, which Rhino lacks (the exported script shears a copy of the geometry). It is a better teaching instrument than any pro viewer for this purpose.
• Code: src/lib/projections/geometry.ts, src/lib/projections/taxonomy.ts, src/app/(app)/tools-3d/obliquify/ObliqueScene.tsx, src/lib/projections/rhino.ts

• Our method: The sensor presets are full-frame, APS-C and Micro Four Thirds, with CoC values of 0.029, 0.019 and 0.015 mm (roughly diagonal/1500). FOV = 2·atan(d/2f). H = f²/(N·c) + f. Near = H·s/(H + (s − f)), far = H·s/(H − (s − f)), and far is infinite once s − f ≥ H. The blur disc is b = A·f·|d − s|/(d·(s − f)). The DoF pass reads the depth buffer, computes each pixel's blur radius, capped at 36 px, and gathers 48 golden-angle taps inside that radius. A neighbour tap is accepted when its own blur reaches this pixel, and nearer taps are allowed to bleed onto farther ones. Lens shift writes the off-axis term directly into the projection matrix (elements[9]), computed from the façade height and the vertical FOV. Vanishing points come from projecting each world axis as a homogeneous point at infinity.
• The professional method: Path tracers sample a point on a lens aperture for every camera ray (thin-lens or realistic-lens models), so defocus, partial occlusion and bokeh are physically correct. Real lenses add vignetting, distortion, and aberrations that shape bokeh.
• The gap, specifically:
  • A gather from a single depth layer cannot reveal background hidden behind a blurred foreground edge (no partial occlusion). Expect halos at depth discontinuities.
  • The 36-px cap means very strong defocus is understated.
  • Bokeh is a uniform disc. There is no blade shape, cat's-eye, vignetting or diffraction.
  • The CoC of diagonal/1500 is a print-viewing convention, so the "acceptably sharp" limits shift if you assume a different viewing standard.
• Where ours is as good or better: The formulas are the standard ones and are exact for a thin lens. It updates instantly, and the tilt-versus-shift lesson (a projection-matrix offset rather than a rotation) is clearer here than in any renderer UI.
• Code: public/tools/vantage/web/optics.js, public/tools/vantage/web/dof.js, public/tools/vantage/web/app.js, public/tools/vantage/web/overlay.js

• Our method: The scene is kept in metres and packed into float uniform arrays, so edits never recompile the shader. Each light's emission is premultiplied by its Kelvin tint (a Planckian-locus cubic fit valid from 1667 to 25000 K, normalised to D65), its gel and its power, divided by its area. At the same power, a bigger modifier is therefore dimmer per unit area. Each frame adds one sample per pixel. At each vertex one light is chosen uniformly and sampled directly (spheres by their visibility cone, area lights by area) and combined with BSDF sampling by the power heuristic. The BSDF is Lambert plus GGX with a metalness parameter, and scrims have their own diffuse transmit/reflect split. The bounce budget runs 1–6 (default 4). Russian roulette starts after depth 2 with survival clamped to 0.05–0.95, and fireflies are clamped at 24 after the first hit. Accumulation stops at 1,600 spp, and rendering drops to 45% resolution while dragging. Output goes through white balance, exposure, ACES fit and sRGB. The stops-vs-key readout is an inverse-square illuminance estimate at the focus point. It is not read off the traced image.
• The professional method: Cycles, V-Ray and Arnold use the same family of estimators, with BVH-accelerated meshes, many-light sampling, full microfacet and layered materials, textures, IES profiles, physical units (W, lm, cd), adaptive sampling and AI denoisers (OIDN, OptiX). set.a.light 3D models specific real strobes and modifiers.
• The gap, specifically:
  • Units are relative. A fixed flux-to-radiance constant only centres the exposure slider, so the absolute brightness means nothing.
  • Choosing lights uniformly is noisier than power-weighted or many-light sampling when one light dominates. Harsh setups can still be grainy at 1,600 spp, and no denoiser runs.
  • Primitives only: the "bust" is a sphere on a cylinder. There are no faces, cloth or skin, and no subsurface scattering, which is what portrait lighting is actually about.
  • The stops readout ignores occlusion and bounce, so it can disagree with the picture when a flag or card is in play.
• Where ours is as good or better: It runs in real time in the browser with no install. Plan and section rigs are drawn next to the image, the effect of a single bounce budget can be seen directly (1 bounce kills the fill), and the relationship between softbox size and softness is correct by construction.
• Code: src/app/(app)/media-2d/gaffer/shaders.ts, src/app/(app)/media-2d/gaffer/pathtracer.ts, src/lib/gaffer/pack.ts, src/lib/gaffer/photometry.ts, src/lib/gaffer/scene.ts

• Our method: Vertices are welded with a tolerance of diag·1e-5, clamped between 1e-7 and 1e-3 m. Feature edges are boundary and non-manifold edges, creases whose dihedral angle exceeds 20°, and silhouettes where two adjacent faces disagree on sign(n·(centroid − eye)). This per-triangle test is correct under perspective. Visibility is decided from screen-uniform samples along each edge (0.024 in (0.6 mm) on the page, 3–256 samples), mapped to world space with the perspective-correct map s(u) = u·wA/(wB + u·(wA − wB)). Each sample casts a shadow ray to the eye against Crucible's BVH, stopped short by max(1e-5 m, d·1e-4). Clear glass is peeled up to 8 layers. Runs of samples with the same verdict are merged. The frame clip is Liang–Barsky in NDC after near-plane clipping. Weight w(d) ramps linearly from 0.02 in (0.5 mm) near to 0.005 in (0.13 mm) far, applied per vertex and split into up to 8 constant-weight runs. The SVG has groups cut/visible/hidden/silhouette/ground, with hidden lines as real dashed paths.
• The professional method: Make2D computes hidden lines analytically on curves and surfaces (Brep edges, silhouettes of NURBS), with output layered as visible/hidden/tangent/clipping. It does not grade weight by depth. Freestyle builds a view map and assigns quantitative invisibility to view edges by ray casting, then applies styles (thickness along distance, chaining, stroke textures).
• The gap, specifically:
  • Tessellation-bound: a curve is only as smooth as the render mesh, and the 20° crease rule adds false creases on coarse cylinders and drops soft fillets.
  • Visibility is sampled, not solved, so an occluder narrower than the sample step (0.024 in (0.6 mm) on the page, coarser on edges long enough to hit the 256-sample cap) can be missed. Make2D has no such sampling error.
  • There is no tangent-edge or seam classification of the kind Make2D offers, and no chaining or stroke styling of the kind Freestyle has.
  • The linear depth ramp is a drawing convention of our own, not a standard.
• Where ours is as good or better: Depth-graded weights come automatically, which Make2D does not do (Make2D does compute perspective silhouettes, and exactly, on NURBS). The SVG is millimetre-true with stable layer names. It runs client-side, and a camera can be passed in from Photomatch or Scout.
• Code: src/lib/scribe/edges.ts, src/lib/scribe/visibility.ts, src/lib/scribe/weight.ts, src/lib/scribe/draw.ts, src/lib/scribe/svg.ts

• Our method: For a flat view, PD = picture distance × scale (for example 40 ft at 1/4 in = 1 ft gives PD = 10 in), and shift is derived from the position of the centre of vision within the frame. For panoramas, R = PD. On a cylinder, x = CVx + R·φ and y = CVy − R·dy/d. On a sphere, y = CVy − R·atan(dy/d). Panoramas are traced as wedges no wider than 45°, each a flat Scribe camera with its vertical reach widened by 1/cos(half-width), then re-projected in steps of at most 1°, using a sine-rule parameterisation. The fold-exact fan turns adjacent views by atan(edge/PD) + atan(next edge/next PD). Frames are ellipses (144 sides), arches (72-segment head), diamonds or rectangles. Strokes are split at outline crossings and kept by an even–odd midpoint test, and later opaque frames subtract from earlier ones. Lineweight uses one depth ramp for the whole sheet by default, 0.028 in (0.7 mm) near to 0.006 in (0.15 mm) far, with silhouettes multiplied by 1.6. The preview samples every 0.1 in (2.5 mm) and the export every 0.024 in (0.6 mm). Output is one SVG in inches with a mm viewBox, and named views are exported to Rhino through Scout's emitter.
• The professional method: Rhino gives exact Make2D per view but no multi-station sheet construction, no curved picture surfaces, and no measuring points. Illustrator or InDesign then handles layout and clipping masks, which hide covered strokes rather than cutting them. Renderers produce cylindrical or spherical images as pixels, not as linework.
• The gap, specifically:
  • It inherits every limit of Scribe: tessellation, sampled visibility, and a line-only drawing.
  • Panoramas are level only. Measuring points, ground line and cone are drawn for level flat views only.
  • Named views exported to Rhino carry no lens shift, so an off-centre CV frames differently in Rhino.
  • Tracing on the main thread can freeze the page on large models or many views.
• Where ours is as good or better: There is no pro tool that constructs measured cylindrical or spherical perspective linework at a stated scale, or that makes folded picture planes meet exactly at the seam. The collage clip is geometric, so there are no hidden strokes lurking under masks.
• Code: src/lib/polyptych/view.ts, src/lib/polyptych/pano.ts, src/lib/polyptych/shapes.ts, src/lib/polyptych/construction.ts, src/lib/polyptych/compose.ts

• Our method: The plan cut intersects every triangle with a horizontal plane at the cut height (default 4 ft (1.2 m)) by interpolating along the edges that change sign. Footprint mode projects all edges, capped at 150,000 segments. Eye height defaults to 5 ft 3 in (1.6 m). The cone check compares the diagonal FOV strictly against 60°, while the plan wedge is drawn at half the horizontal FOV. The verticals check computes tilt t from the forward vector's up component, and the correction is shiftY = tan(t)/tanY, flagged past ±1.0 NDC, which is a 1/2 in (12 mm) rise on a full-frame gate. Declination uses Cooper's formula, δ = 23.45°·sin(2π(284 + n)/365). The equation of time uses the common three-term fit 9.87 sin 2B − 7.53 cos B − 1.5 sin B, with B = 360°(n − 81)/364. Solar time adds 4 min per degree of longitude from the standard meridian. Altitude and azimuth come from the spherical-triangle formulas in solar-field.ts, and a sun below the horizon returns null. The .3dm export uses rhino3dm 8.17 and calls changeToPerspectiveProjection before setting the frame and frustum.
• The professional method: Revit and SketchUp place cameras the same way, with crop regions and rendered previews. Rhino's Two-Point Perspective handles verticals as a projection mode. PhotoPills and TPE use higher-accuracy astronomical algorithms (their internals are not published; unverified). Ladybug uses the NOAA solar-calculator equations (after Meeus).
• The gap, specifically:
  • The sun has no refraction, nutation or leap-year correction. Error is small at mid-day and grows near the horizon, which is exactly when photographers care most.
  • Plans come from tessellated triangles and are strided on large models.
  • There is no preview through the camera. Scout sites the camera, and Scribe or Rhino draws the view.
  • On non-3:2 gates, Rhino's lens readout differs from Scout's. The framing is correct, but the lens number Rhino shows will not match.
• Where ours is as good or better: It makes eye height, tilt and the 60° cone explicit, which pro viewport UIs hide. It computes the exact shift that fixes verticals rather than offering a mode toggle, and it writes back to a live Rhino model.
• Code: src/lib/scout/cone.ts, src/lib/scout/sun.ts, src/lib/scout/export3dm.ts, src/lib/camera/camera.ts, src/app/(app)/tools-3d/scout/Scout.tsx

• Our method: Every edit passes through normalizeSpec, which clamps weights and stores colours as RGB. A weight boost of 0.25–6 multiplies every line family, but families that are switched off stay off. The contrast ratio is the WCAG relative-luminance ratio, taken as the worse of the two ends when the background is a gradient. The still life's intersection curves come from a Möller-style triangle–triangle test (clip against the other triangle's plane, then overlap along the common line), with a bounding-box, uniform-grid and per-triangle-box broad phase and coplanar contacts handled separately. The TechnicalMask bits (edges, hidden, silhouettes, creases, seams, intersections) are set only for families whose weight is above zero. The preview uses a three.js shadow map clamped to 256–4096 px.
• The professional method: Rhino's display pipeline (OpenGL, or Metal on Mac) draws the same settings on the real document. The Technical modes compute silhouettes, creases and intersections from the scene geometry. The exact internal method is not published, but it works on actual objects rather than a fixed still life.
• The gap, specifically:
  • The preview is three.js, not Rhino. Shading, shadow filtering and line rasterisation will differ in detail.
  • Shadow-map sizes above 4096 are written to the .ini (the default is 8256) but previewed at 4096.
  • Intersections are faceted on the preview meshes, whereas Rhino's are computed on the real objects.
  • Only the fields the writer exposes are emitted. A mode hand-edited in Rhino can hold more.
• Where ours is as good or better: The weight boost with its hierarchy preserved, the measured contrast ratio, and the accessibility-first presets have no equivalent in Rhino's panel. It also documents each .ini key, which Rhino does not.
• Code: src/lib/display-modes/ini.ts, src/lib/display-modes/geometry.ts, src/lib/display-modes/presets.ts, src/app/(app)/inker/InkerScene.tsx

• Our method: The photo is decoded in the browser with its long side capped at 2400 px. Each segment becomes a normalised homogeneous line, and the VP is the smallest eigenvector of the length-weighted scatter matrix Σwᵢl̂ᵢl̂ᵢᵀ, found by cyclic Jacobi (64 sweeps) on Hartley-conditioned coordinates. The solver refuses: a bundle with less than 0.5° of direction spread, segments shorter than 2 px, duplicate axis labels, VPs closer than 5% of the diagonal, and f outside 0.02–200 image diagonals. f = √(−v₁·v₂), with the principal point assumed at the image centre. R comes from Gram–Schmidt with a right-handed third axis. A third bundle is used only to check the result (the third-axis angular error). Height is solved by two-ray least squares, t_top·D_top − t_base·D_base = (0, h, 0). Rectification is a four-point DLT with h₈ = 1, solved by Gaussian elimination with partial pivoting on normalised coordinates, followed by an inverse bilinear warp. Output is capped at 4096 px per side and 64 MP, and scale spans under 12 px are refused.
• The professional method: fSpy supports one- and two-VP modes, and can take the principal point from the image centre or compute it from a third VP (the orthocentre of the VP triangle). It exports straight to Blender. Photogrammetry suites solve intrinsics including radial distortion by bundle adjustment across images.
• The gap, specifically:
  • A fixed principal point: a cropped or shifted image gives a proportionally wrong focal length. The third bundle is used only as a check, not to locate the principal point.
  • No lens-distortion model. Straight edges in a barrel-distorted photo produce inconsistent VPs, which show up as a large third-axis error.
  • There is no one-VP mode (fSpy has one).
  • Rectification assumes a single plane. Bays, batters and bowing come out skewed.
• Where ours is as good or better: The refusals are explicit and name the offending bundle, where most tools return a wrong camera without comment. The ordinal confidence, residuals and third-axis check make the result auditable. It exports camera JSON directly to Scribe and Scout.
• Code: src/lib/photomatch/lines.ts, src/lib/photomatch/solve.ts, src/lib/photomatch/homography.ts, src/lib/photomatch/scale.ts

• Our method: The board formats are A3 in either orientation (2000×1414), square (2000×2000) and 16:9 (2000×1125). Imports are fit to 65% of the board and never upscaled. A scissor cut is a polygon in the layer's local space. A torn edge subdivides each side about every 14 px and jitters the points along the normal by ±amp (default 12 px) using seeded mulberry32. The filters run in a fixed order: posterize (2–8 levels), Rec.601 desaturate, monotone tint ramp, then seeded grain of ±64×amount. The halftone uses a 15° screen with dot radius 0.62·cell·√coverage, so dot area is proportional to darkness, and drops cells under 2%. Blend modes are source-over, multiply, screen and overlay. Ground scaling uses apparentHeight = (yFeet − horizonY)·realHeight/eyeHeight. Shadow length is h/tan(altitude), with altitude clamped to at least 1° and length capped at 60× the object's height, and a sun below the horizon is refused. The sky is a hand-picked gradient.
• The professional method: Photoshop offers non-destructive masks, about 27 blend modes, adjustment layers, smart objects, colour management, and Bitmap-mode halftone screens with selectable frequency, angle and dot shape. Vanishing Point scales pasted content inside user-defined perspective planes. Nothing in Photoshop scales a figure to a horizon automatically.
• The gap, specifically:
  • Masks are hard polygons only: no feathering, brush masks or edge refinement, and no automatic subject selection.
  • Only four blend modes, uniform scale and rotation, and no perspective, shear or warp on a layer.
  • A single-channel halftone. There are no CMYK separations or screen angles per ink, and no dot-gain compensation.
  • Shadows fall only on the ground plane, with nothing cast onto walls and no occlusion between cutouts. Their recession into depth uses a fixed look constant (0.5) rather than a projection, because a flat board carries no focal length, so shadow tips are plausible rather than constructed.
• Where ours is as good or better: Horizon-true scaling and one shared sun are automatic, and filter output is deterministic and reproducible from the saved file.
• Code: src/app/(app)/media-2d/collage/engine.ts, src/app/(app)/media-2d/collage/render.ts, src/lib/finisher/ground.ts, src/lib/finisher/shadow.ts

• Our method: The scene is Gaffer's StudioScene. The sensors and CoC values are the same three as Vantage, and focal length runs 14–300 mm. Crop factor is taken against a diagonal of 43.27 mm. The camera basis is pitched by the tilt angle, while shift is applied as a separate ray offset, patched into Gaffer's shader at two named anchor strings (the build throws if an anchor is missing). DoF samples the aperture disc per ray, with radius f/(2N) at the focus distance. The EV terms are aperture 2·log₂(4/N), shutter log₂(t/(1/60)) and ISO log₂(ISO/100). Grain amplitude is 0.05·√(ISO/100 − 1), applied in the present pass. Flash is metered with no shutter term. Above the sync speed (default 1/250 s) there is either a schematic black band (1 − shutter/sync) or, with HSS, a penalty of log₂(sync/shutter). The meter's scene term is an inverse-square estimate at the focus point, not a reading off the image.
• The professional method: Physical camera models in V-Ray or Corona apply ISO, shutter and f-number in real photometric units, and can add motion blur, vignetting and distortion. A real camera also has diffraction, curtain geometry that depends on the body, and sensor noise that varies with signal level.
• The gap, specifically:
  • Nothing moves in the scene, so shutter speed only changes brightness and there is no motion blur.
  • An ideal lens: no vignetting, distortion, chromatic aberration or diffraction softening at f/16–22. Bokeh is a uniform disc.
  • Grain is a static luma-scaled hash, not a shot-noise or read-noise model.
  • The meter ignores bounce and occlusion.
  • It inherits all of Gaffer's gaps: relative units, primitives only, 1,600 spp and no denoiser.
• Where ours is as good or better: The DoF here is physically sampled, which is better than Vantage's post-process gather. The exposure, flash-sync and HSS lessons are shown on a real traced image, which no calculator app does.
• Code: src/lib/lens/optics.ts, src/lib/lens/scene.ts, src/app/(app)/media-2d/lens/shaders.ts, src/app/(app)/media-2d/lens/pathtracer.ts

• Our method: Each material has a real repeat (concrete 59 in (1500 mm), brick 9 in (230 mm), CMU 16 in (400 mm), stone 63 in (1600 mm), and so on) and a generator. Brick and CMU are coursed rectangles. Stone is a 5×5 lattice jittered by an integer hash taken modulo the grid, so it tiles. Aggregate, gravel and sand are scattered with seeded mulberry32. Marks near the tile edge are wrapped to the opposite side to hide the seam. The scale is chosen from 1:20, 1:50, 1:100 or 1:200. Rotation is applied through patternTransform.
• The professional method: .pat hatches are line families (angle, origin, offset, dash) that CAD fills exactly inside boundaries and keeps associative. Revit separates model and drafting patterns and ties them to materials.
• The gap, specifically:
  • The output is SVG or PNG, not .pat, so it cannot be used as a native CAD hatch.
  • It offers metric scales only (1:20–1:200) and repeats in mm. There are no architect's scales such as 1/4 in = 1 ft.
  • The patterns follow no ANSI or ISO hatch standard.
  • Density does not affect masonry or poché.
• Where ours is as good or better: It produces seamless, scale-true patterns quickly for an Illustrator workflow.
• Code: public/tools/hatch/index.html

• Our method: An item's scale is (real height × px/m × item scale) ÷ authored box height. The ground line and 1.7 m dimension act as a visual yardstick. Items can be flipped within their bounding box. The export crops tightly to a transparent SVG or PNG in pixels.
• The professional method: CAD and BIM blocks are placed at true model units, and libraries offer hundreds of figures in plan, elevation and perspective.
• The gap, specifically: 22 items only. Exports are in pixels and carry no drawing-scale metadata. The tool knows nothing about the scale of the drawing you are composing over. The library works in metres internally, and the reference label reads "1.7 m".
• Where ours is as good or better: Everything rescales from one control, the tool is free, and it runs instantly.
• Code: public/tools/entourage/index.html

• Our method: The golden spiral is built by cutting successive squares (up to 12, stopping when a square is under 3 px) and joining their quarter-arcs. Root rectangles are constructed by swinging the diagonal: √2, √3, 2 (√4) and √5. The Modulor overlay is a nine-step golden subdivision of the frame height in red and blue series. The ratio readout picks the nearest of 1:1, 4:3, √2, 3:2, φ, √3, 2:1 and √5 within a relative error of 2%, and otherwise reports "non-standard". The SVG export contains the lines only, with no image.
• The professional method: Crop overlays in Adobe tools are fixed guides with no construction or ratio readout. Le Corbusier's Modulor is an anthropometric series anchored at 6 ft (1.83 m) and 7 ft 5 in (2.26 m).
• The gap, specifically: The Modulor overlay has no absolute anthropometric anchors. The frame locks only to free, 3:2, φ, √2 and 1:1. There is no perspective rectification, so an overlay on an oblique photo is meaningless (use Photomatch's rectify mode first).
• Where ours is as good or better: The constructions are true compass constructions, a spiral visibly fails when the frame is off-ratio, and the SVG output is in vector form.
• Code: public/tools/proportion/index.html

• Our method: Each drawn length is real units × (mm per unit ÷ scale ratio). For example, 1/4 in = 1 ft is a ratio of 48. The SVG coordinate space is millimetres. Label thinning always keeps the ends, the lead value and any custom pins, then adds the remaining labels left to right only where the estimated text widths plus a gap fit between neighbours. The north arrow is rotated by the chosen bearing.
• The professional method: GIS and CAD scale bars are live objects tied to the map or viewport scale, and GIS north arrows can account for grid versus true north.
• The gap, specifically: The bar is static and not linked to any drawing. Fonts are not embedded, so labels can reflow in the receiving application. There is no grid-versus-true-north or magnetic-declination handling.
• Where ours is as good or better: Label thinning and seven bar styles give clean results in seconds, and the file is millimetre-true for print.
• Code: public/tools/scale-bar/index.html

• Our method: Imports are downsampled to at most 1400 px. A pose is M = T(x, y)·R(rot)·S(±s, s)·T(−pivot). When the pivot is moved, the pose is re-solved so the sprite does not move on screen. Rotation snaps to 0.5° (15° with Shift) and scale is clamped to 0.05–10. A cut places its pivot at the shoelace area centroid. Torn edges subdivide about every 9 px and add seeded perpendicular jitter. Frames are pose snapshots, each held 1–12 beats. The GIF has one global palette of up to 256 colours built by median cut over sampled pixels, maps each pixel to the nearest colour with no dithering, and compresses with variable-width LZW that resets at 4096 codes. Work autosaves to localStorage after a 500 ms debounce.
• The professional method: Harmony and Animate provide bone or peg hierarchies, interpolation curves, drawing substitution and video export. Photoshop's subject selection uses a trained segmentation network. Encoders such as Photoshop's Save for Web offer perceptual or selective palettes with dithering.
• The gap, specifically: There is no hierarchy, so moving an arm does not carry the hand. The GIF has no dithering, which causes banding on photographic scans, and only one palette for the whole animation. There is no video or audio. localStorage quotas can silently stop autosave on large casts.
• Where ours is as good or better: Setup takes seconds, and a pivot can be re-hinged without the piece moving. The GIF encoder has no dependencies. It is also faithful to the medium, since held poses are the point.
• Code: src/lib/cutout/model.ts, src/lib/cutout/gif.ts, src/lib/cutout/persist.ts, src/app/(app)/media-2d/cutout/CutoutTool.tsx

• Our method: Two-click calibration gives pixel distance ÷ typed length. Named-scale calibration uses 10 architect's scales (3/32 in to 3 in = 1 ft), 7 engineer's scales (1 in = 10 ft to 100 ft) and 5 metric scales (1:50 to 1:1000), combined with the original page DPI. For example, 1/4 in = 1 ft at 96 DPI gives 24 px per foot. Lengths are summed Euclidean distances. Area uses the shoelace formula, with a segment-crossing test that rejects bowtie shapes. Angles are measured at the clicked vertex. Results are formatted in feet and inches to 1/2 in by default, with metric in parentheses. Work autosaves to IndexedDB.
• The professional method: Bluebeam and Acrobat measure against the vector geometry and the scale embedded in the PDF viewport, with snapping. Take-off tools add assemblies, counts linked to cost, and multiple viewports per sheet at different scales.
• The gap, specifically: It uses a single isotropic scale with no deskew or perspective correction (rectify first in Photomatch). There is no vector snapping, so accuracy is limited by click precision on the raster. The error is roughly one or two pixels divided by the pixels per unit, so calibrating on a short dimension inflates every result. There is no per-viewport scale on mixed-scale sheets.
• Where ours is as good or better: It is free, needs no install and runs locally. Recalibrating fixes every existing measurement, and it is imperial-first.
• Code: src/lib/scaler/calibrate.ts, src/lib/scaler/measure.ts, src/lib/scaler/format.ts, src/lib/scaler/doc.ts

• Our method: hex → sRGB → linearise → XYZ (D65 white derived from the sRGB primaries) → OKLab through Ottosson's concatenated matrices, or CIELAB with exact ε = 216/24389 and κ = 24389/27. Schemes rotate hue at fixed L in OKLCh, with HSL generated beside it as a foil. Gamut mapping follows CSS Color 4 §13.2: hold L and h, binary-search chroma (25 halvings, stop at 1e-6), and accept a clip only while ΔE_OK < 0.02 (JND). Differences use CIEDE2000 (25⁷ = 6103515625 in the G term, tested against the Sharma/Wu/Dalal pairs), plus HyAB and CIE76 for comparison. Contrast uses the WCAG 2.x ratio and APCA 0.1.9, with constants trc 2.4, normBG 0.56, normTXT 0.57, revTXT 0.62, revBG 0.65, blkThrs 0.022, blkClmp 1.414 and scale 1.14. Pairs disagree when "ratio ≥ 4.5" and "|Lc| ≥ 75" give different answers. CVD goes XYZ → LMS (Hunt-Pointer-Estévez), then the missing cone is replaced by a linear combination of the other two. The coefficients are solved from white plus a blue anchor (protan/deutan) or a red anchor (tritan), which is a single-plane Viénot-1999-style projection. Severity below 100% interpolates linearly. Naming: a structural OKLCh namer, plus the nearest of 267 vendored ISCC-NBS centroids by ΔE00. Image extraction: k-means++ (deterministic LCG seed, ≤ 20,000 samples, ≤ 40 iterations, k ≤ 16), run in both OKLab and RGB. Pigment mixer: CMY absorption weighted by amount × tinting strength; not Kubelka-Munk. Room: WebGL2 path tracer, up to 1,600 samples, with no BVH. No AI.
• The professional method: ICC colour management (device profiles, rendering intents, black-point compensation) converts between real devices. Spectrophotometers measure spectral reflectance. Paint and textile labs predict mixes with Kubelka-Munk two-constant theory from measured K/S spectra. CVD research tools add Brettel's two-half-plane projection and Machado 2009 for anomalous trichromacy.
• The gap, specifically:
  • No ICC profiles. "sRGB" means the standard, not your screen, and there is no soft-proofing to a print condition, so a palette can pass here and still shift in CMYK.
  • Tritan simulation uses a single plane where Brettel uses two half-planes. Neutrals and the anchor are exact, but errors grow for colours far from the anchor axis.
  • Partial-severity CVD is a linear blend, not Machado's shifted-cone model, so mild anomalies can be overstated or understated.
  • The pigment mixer gets the direction of a mix right (clean versus muddy) but not the actual colour. There is no spectral data, so it cannot predict metamerism.
  • ISCC-NBS naming uses the nearest centroid, not containing-block membership. It can give the wrong name near irregular block boundaries.
• Where ours is as good or better: The colour-space, ΔE00, gamut-mapping and APCA arithmetic is the standard itself, and it is tested. Putting WCAG and APCA side by side, and showing four "complements" at once, teaches more than any production picker.
• Code: src/lib/dyer/space.ts, src/lib/dyer/gamut.ts, src/lib/dyer/contrast.ts, src/lib/dyer/cvd.ts, src/lib/dyer/pigment.ts

• Our method: Six closed-form surfaces are normalised to 0–1 × amplitude. An imported mesh is raycast top-down on a 161-column grid (first hit only, double-sided) and rescaled so its long plan side is about 7.9 in (200 mm). Waffle: stations inset by max(1.5 t, 4% of the short side). Slot width = t − kerf, clamped to [0.016 in (0.4 mm), 80% of rib spacing]. Slot depth is H/2 at each crossing, B-ribs notched from the top and A-ribs from the bottom. Nesting is tallest-first shelf packing with a 0.24 in (6 mm) gap and no rotation, which is Next-Fit Decreasing Height on bounding boxes. Contour: the grid is sampled at 161 columns. The layer count is round(maxH / t), each level sits at k·t + 0.001 t, and every level is traced with 16-case marching squares, linear interpolation and a −1e9 border sentinel. Saddle cases always separate (no centre-value test). Loops smaller than 2 cells are dropped, and the next layer is scored in dashed blue. Print prep: volume by the divergence theorem. A face needs support if it points more than 45° below horizontal and is not within 0.02 in (0.5 mm) of the bed. The six axis orientations are ranked by support area. Bed fit allows a 0.08 in (2 mm) margin and a 90° turn. Plastic = min(V, A × 0.047 in (1.2 mm) shell) + interior × infill (default 15%). Time = plastic ÷ 10 mm³/s. Mass uses PLA 1.24, PETG 1.27 or ABS 1.04 g/cm³. No AI.
• The professional method: Slicer for Fusion 360 slices the actual solid, so undercuts survive. It lets you set slice direction and angle, sizes notches to the material with an offset, adds dowel holes for stacked slices, nests parts and generates assembly steps. Rhino Contour intersects the exact NURBS or mesh. True-shape nesters (RhinoNest; Deepnest/SVGnest use no-fit polygons with a genetic search) rotate and interlock parts. Print slicers generate real toolpaths: layer-by-layer perimeters and infill, support generation (tree/organic), bridging detection, and time from motion planning with acceleration.
• The gap, specifically:
  • The heightfield raycast drops every undercut before either laser strategy runs. That gives wrong geometry, not only lower resolution.
  • Contour resolution is limited by the grid. Vertices are linearly interpolated along cell edges, so each contour is piecewise-linear at the cell size, about 0.05 in (1.25 mm) at the default 7.9 in footprint; sharp ridges, summits and creases narrower than a cell are rounded off or lost.
  • Bounding-box shelf nesting cannot use the empty area above a curved rib's top, or rotate parts. Sheet use is lower than true-shape nesting, by an amount that depends on the form.
  • Time and material estimates ignore supports, so they underestimate whenever the model needs support. The tool states ±50% for time.
  • Orientation search covers only six poses. A slicer's auto-orient explores more.
  • Slot fit is t − kerf with no material-thickness variation or compression model; a test cut is still needed.
• Where ours is as good or better: one model feeds three strategies in one tab; each method is stated in the UI; it runs instantly with no install; the waffle and contour maths is short enough to read in class.
• Code: public/tools/fabricator/engine/heightfield.js, public/tools/fabricator/engine/waffle.js, public/tools/fabricator/engine/contour.js, public/tools/fabricator/engine/printprep.js, public/tools/fabricator/index.html

• Our method: The heightfield comes from six parametric forms, or an STL/OBJ/PLY raycast top-down on a 161-column grid (first hit, double-sided) and rescaled so the long side is about 7.9 in (200 mm). Stations are inset by max(1.5 t, 4% of the short side). Slot width = t − kerf, clamped to ≥ 0.016 in (0.4 mm) and ≤ 80% of spacing. Slot depth = H/2 at the crossing, top-notched on one family and bottom-notched on the other. Defaults: t 0.12 in (3 mm), kerf 0.004 in (0.1 mm), sheet width 23.6 in (600 mm). Parts are nested tallest-first in rows with a 0.24 in (6 mm) gap and no rotation (NFDH). The SVG has hairline cuts and rib labels. No AI.
• The professional method: Slicer for Fusion 360 intersects the real solid at user-set spacing and direction, sizes slots to the stated material with an adjustable offset, nests parts and produces step-by-step assembly. Grasshopper workflows give full control: any rib orientation, rib-to-surface normal offsets, and base rails.
• The gap, specifically:
  • Heightfield input means undercuts disappear, and ribs are always vertical and axis-aligned.
  • Where H → 0 (a dome's rim) ribs taper to slivers, and slots under 0.016 in (0.4 mm) deep are skipped. Rim ribs can be too fragile to cut.
  • There is no base rail, and no tolerance for sheet-thickness variation; plywood and chipboard vary.
  • Nesting uses bounding boxes, so more sheet area is wasted than with true-shape nesting.
  • Only the sheet width is honoured. The SVG grows as tall as the layout needs, and the sheet count is not shown.
• Where ours is as good or better: speed; no install or login; slot arithmetic a student can read and check.
• Code: public/tools/waffle/index.html, public/tools/fabricator/engine/waffle.js, src/app/(app)/tools-3d/waffle/page.tsx

• Our method: The heightfield comes from a parametric form or a raycast STL/OBJ/PLY (first hit, rescaled so the long side is about 7.9 in (200 mm)). The grid is 161 × max(20, 161·D/W). The layer count is round(maxH / t) and levels sit at k·t + 0.001 t. Marching squares uses the 16-case table with linear interpolation, and saddle cases 5 and 10 always separate the inside corners (no asymptotic decider). A −1e9 border sentinel closes loops at the footprint edge. Segments are stitched through an endpoint hash, and loops under 2 cells of area are dropped. Parts are shelf-nested tallest-first (NFDH on bounding boxes, 0.24 in (6 mm) gap), with the next layer dashed on top. Each layer is the plan outline at the bottom of its slab, so the stack encloses the surface (a stepped "outside" model), except that the rounded layer count can stop up to half a layer short of the summit. No AI.
• The professional method: Rhino Contour intersects the exact geometry at a set interval, giving curves with no grid quantisation that can then be offset, filleted or rebuilt. Slicer for Fusion 360 adds dowel holes, true-shape nesting and assembly steps. GIS contouring of a DEM (e.g. GDAL/QGIS Contour) is also a marching-squares-family method, at the DEM's own resolution; smoothing is usually a separate step.
• The gap, specifically:
  • Contours are piecewise-linear at the grid cell, about 0.05 in (1.25 mm) at the default footprint. Sharp ridges and summits between samples are rounded off, and loops under 2 cells of area are dropped.
  • With fixed saddle resolution, two peaks joined by a narrow col can split or merge differently than an exact section would.
  • Undercuts are lost to the heightfield raycast.
  • Bounding-box nesting with no rotation wastes more stock than true-shape nesting. Only the sheet width is honoured.
  • There are no hollowed layers, glue lands or dowels (Relief adds glue lands).
• Where ours is as good or better: the whole pipeline takes seconds; the score line of the next layer is a practical registration aid that Rhino's Contour does not add by itself.
• Code: public/tools/contour-slicer/index.html, public/tools/fabricator/engine/contour.js, src/app/(app)/tools-3d/contour-slicer/page.tsx

• Our method: Equirectangular local projection, then bilinear resampling that never extrapolates past the survey. Samples per side = 2 per source cell, clamped to 33–193. A mesh-density ladder of up to 3 doublings or 4 halvings (never coarser than 9 samples per axis): refine by Lane-Riesenfeld cubic B-spline (Catmull-Clark on a regular grid; masks 1/8[1 6 1], 1/2[1 1]), by the Dyn-Levin-Gregory 4-point interpolating scheme (1/16[−1 9 9 −1], boundary 1/16[5 15 −5 1]), or by midpoint split. Reduce by a tent filter, nearest measured post, or bilinear. The refine cap is 2049 samples per axis (about 4.2 M), and worst/rms disagreement with the measured posts is reported in feet. OSM roads, water and buildings become per-family signed-distance fields, widened to ≥ 2 cells, with priority building > road > water. Groove depth is clamped to keep minimum material. Fabrications: solid-bottom tiles by default (or a hollow shell); the waffle; marching-squares slabs hollowed behind a glue land; and paper strips unfolded triangle by triangle using circle-circle intersection, which preserves 3-D edge lengths. Bed presets include a Bambu P1S at 8.07 in (205 mm) usable. Exports: per-tile STL, a Manifold-unioned watertight STL, DXF, and .3dm with a degree-3 heightfield NURBS interpolating every sample, ruled walls, and buildings as capped Extrusions or meshes. No AI.
• The professional method: TouchTerrain and Terrain2STL also triangulate a regular DEM grid into base-plated STL tiles, which is essentially the same approach. Cadmapper and Grasshopper GIS plugins bring terrain and OSM into Rhino for hand modelling. Civil 3D builds TIN surfaces from surveyed points and breaklines. Pepakura unfolds arbitrary meshes with tabs and optimised part islands.
• The gap, specifically:
  • The lattice is regular with no adaptive/TIN decimation, so files are larger than a curvature-driven remesh at equal fidelity. Coarse settings alias ridges, and the rms error readout is there to show it.
  • Features narrower than 2 cells are widened, so small roads and streams are exaggerated at coarse densities.
  • OSM buildings are flat-roofed prisms at tagged or default heights, seated at the lowest ground under their footprint, so they are buried on the uphill side.
  • The terrain-tile fallback is about 20–50 ft per sample and has no breaklines, so cuts, embankments and curbs are smoothed away.
  • Paper strips are single-row triangle developments, so there are more strips and fold lines than Pepakura's optimised unfold.
• Where ours is as good or better: the end-to-end chain from survey to bed-sized, labelled, watertight tiles in one browser tab; error reporting against the measured posts; an interpolating NURBS surface in the full-size .3dm (not a mesh); four fabrication methods from one lattice that agree with each other.
• Code: src/lib/relief/terrain.ts, src/lib/relief/mesh-density.ts, src/lib/relief/subdivide.ts, src/lib/relief/features.ts, src/lib/relief/shell.ts

• Our method: Parse in the browser. Decimate to a 200,000-triangle budget by grid vertex clustering. Fit the floor with seeded-LCG RANSAC (accepted once ≥ 15% of points are inliers) refined by the smallest covariance eigenvector. Level with a Rodrigues rotation. Scale from the ratio of a typed tape measurement to the probed distance, speaking any disagreement. Crop by window, then keep the largest connected component. Rasterise by barycentric coverage, keeping top and lowest height per post. Posts where the two differ by more than about 2 ft (0.6 m) are grouped by 4-connected flood fill into named overhang regions. Tile with Relief's shell generator, add a D-foot boss and braille atlas ID (BANA-derived 0.063 in (1.6 mm) dome base, 0.031 in (0.8 mm) height, 0.098 in (2.5 mm) dot pitch, 0.244 in (6.2 mm) cell pitch), and write a Grade-1 .brf. No AI.
• The professional method: MeshLab and Rhino offer quadric-error (Garland-Heckbert) decimation, hole filling (Poisson reconstruction, ShrinkWrap), and full 3-D booleans for cropping. CloudCompare's RANSAC shape detection finds multiple planes and primitives. Scan apps fuse LiDAR depth with photos and can export a textured mesh at real scale from ARKit tracking.
• The gap, specifically:
  • The heightfield keeps the top surface only, so trees, canopies and overhangs flatten. The tool names and measures the regions it loses.
  • Vertex-clustering decimation loses sharp edges and thin features faster than quadric collapse at the same count.
  • Crops remove whole triangles rather than cutting a clean boolean edge.
  • It does not fill holes: what the sensor did not see stays empty.
  • The braille dimensions are BANA-derived defaults that have not been checked against the current BANA edition. They sit inside the ADA 2010 §703.3.1 signage ranges (dot base 0.059–0.063 in, dot height 0.025–0.037 in, dot spacing 0.090–0.100 in, cell spacing 0.241–0.300 in). The 0.031 in (0.8 mm) dome is taller than paper braille (about 0.019 in), which suits printing.
• Where ours is as good or better: it is accessible from end to end (spoken reports, braille-labelled pieces, a .brf assembly guide), and no mainstream scan tool does this. It is also explicit about unverified scale and lost undercut.
• Code: src/lib/scan/mesh-report.ts, src/lib/scan/decimate.ts, src/lib/scan/heightfield.ts, src/lib/site-portrait/chunk-deco.ts, src/app/(app)/rap/portrait/PortraitistTool.tsx

• Our method: Margins are sized from the widest UEB numeral at BANA pitch, rounded up to 1/32 in. Polar rings are placed first. Ring i keeps every d-th spoke for the smallest divisor d of S with d·2πr/S ≥ 0.95 × pitch. Square-lattice holes are accepted only if they clear every placed hole by diameter + minimum wall, tested with a grid hash of cell size c = d + wall. Seams go at equal shares moved to hole-free lines. CSG in Manifold 3.5.1: (plate ∪ ticks ∪ lines ∪ domes ∪ mark) − grooves − holes. Grooves are pipes and tori with their axis at depth − r. Holes default to 16 facets, adjustable on a ladder from 6 to 64. The result is accepted only if the status is NoError, there is 1 shell, 0 cavities and genus equals the through-hole count. The STL bytes are re-audited for two-triangles-per-edge. The .3dm is one Extrusion with circular inner profiles; with grooves it is the mesh plus hidden NURBS cutters and a cut script. The lattice tile is a separate module (lattice.ts) transliterated from the generator that emitted the approved print’s toolpath, not a re-derivation: every constant is pinned to the millimetre by a selftest, so drift shows up as a failing test rather than as a board that is subtly not the board. Its marks sit on the wall sub-lattice — inch channels along wall centre lines, square pits at wall intersections — which is what keeps all 4,356 holes clear; an earlier version bored them into the holes and blocked 416. No AI.
• The professional method: In Rhino, the same plate is an array of cylinders BooleanDifferenced from a box, giving an exact NURBS Brep. Braille needs a plugin or hand-placed spheres. Fusion 360 does the same parametrically.
• The gap, specifically:
  • Holes are polygons. The inscribed diameter is d·cos(π/n), about 2% under d at 16 facets, and the tool states this.
  • There is no model of shrinkage, warping, or wire lean in a loose hole. These are covered only by warnings and the fit coupon.
  • A browser cannot boolean NURBS, so grooved plates need Rhino to finish the Brep.
• Where ours is as good or better: hundreds of holes placed under an explicit wall rule; braille rulers generated automatically; a topological check (genus) that hand modelling seldom gets; and every setting read back aloud.
• Code: src/lib/rap/pegboard.ts, src/lib/rap/pegboard-csg.ts, src/lib/rap/pegboard-rhino-script.ts, src/lib/rap/lattice.ts, src/lib/rap/lattice-csg.ts, src/lib/site-portrait/braille-3d.ts, src/app/(app)/rap/pegboard/PegboardTool.tsx, src/app/(app)/rap/pegboard/LatticePlan.tsx

• Our method: The photo is read by MediaPipe Pose Landmarker (full model) in a network-sandboxed Web Worker. The 11 face landmarks are discarded. Scale comes from the median over ten bones, and MediaPipe's depth is kept at λ = 0.35. Limbs with visibility < 0.5 are borrowed from the standing pose. Hand posing uses forward kinematics with Rodrigues rotations. Dragging uses a two-bone IK solved by 40 bisections. Segment lengths are Drillis & Contini fractions (thigh 0.245 H, shank 0.246 H, upper arm 0.186 H, forearm 0.146 H). Sections are ANSUR II means as fractions of stature (4,082 men, 1,986 women), with superellipse lofts. Children follow WHO/UK90 head-circumference and Fredriks sitting-height ratios. The surface is a signed-distance union with polynomial smooth-min at named joints, meshed by marching cubes. Minimum limb is 0.039 in (1.0 mm) on a 0.016 in (0.4 mm) nozzle. The optional reducer is Garland-Heckbert quadric collapse with link-condition and core guards. Scans are thinned past 150,000 triangles, voxelised (≤ 4 M voxels), given a Felzenszwalb-Huttenlocher distance transform and re-meshed. Manifold does the unions and the closed check. Crowd heights use LMS on CDC 2000 with z clamped to ±2. Exports are STL at model scale and a full-size .3dm (feet) with each part as a closed NURBS solid. No language model.
• The professional method: MakeHuman and Character Creator morph a dense, artist-made base mesh with anthropometric targets and rig it for posing. Likeness comes from structured-light or photogrammetry capture followed by retopology and sculpting. Mocap tools estimate 3-D pose from video with temporal smoothing.
• The gap, specifically:
  • Mean body only: no individual shape, clothing, hair, face or fingers (hands are mittens).
  • Single-photo depth is damped to 35%, so twisting poses and limbs pointed at the camera come out flattened.
  • At 1/8″ scale most limbs clamp to the same 0.039 in, so figures read by silhouette, not anatomy.
  • Crowd heights come from CDC 2000, about 0.6–0.8 in taller in the median than 2015–18 US adults (the tool states this).
  • Rhino surfaces sit within about 0.14 in (3.5 mm) of the mesh at full size and are not joined.
• Where ours is as good or better: the output is printable and watertight by construction and sized for the student's nozzle. The photo never leaves the browser. Crowds with realistic variation take seconds. Children and wheelchair users are built in, where commercial scale-figure sets are often limited.
• Code: src/lib/figure/anthropometry.ts, src/lib/figure/shape.ts, src/lib/figure/decimate.ts, src/lib/figure/scan.ts, src/app/(app)/tools-3d/figurant/pose.worker.ts

• Our method: The working canvas is capped at 1000 px on the long side by default (presets 600, 1000, 1600 or 2400 px), with a 150 ms debounce. Optional box pre-blur via an integral image. Luma (77R + 150G + 29B) >> 8. Otsu over 256 bins, or an integral-image local mean with bias. Signed morphological open/close, and despeckle by component area. Outline: directed unit pixel edges linked head to tail (crack following, not marching squares), holes wound opposite. Centreline: Zhang-Suen thinning, then a walk of the skeleton graph. Every chain gets iterative RDP, corner detection by turn angle (default 78°), and Catmull-Rom → cubic Bézier between corners. Colour: median-cut to 2–12 boxes, one mask and one filled layer each, largest first. SVG output in source pixels. DXF output as LWPOLYLINE in mm, with each Bézier flattened to 10 segments. No AI, no server.
• The professional method: Potrace (Selinger 2003) also decomposes pixel-edge paths. It then finds an optimal polygon under a penalty, detects corners with the alphamax parameter, fits Béziers and runs curve optimisation (opttolerance), which gives fewer, smoother curves. Illustrator Image Trace (proprietary) adds greyscale and colour modes with abutting or overlapping shapes, colour-palette control, stroke tracing, and Paths/Corners/Noise controls, followed by full node editing. Inkscape's multi-scan colour and brightness stepping stacks Potrace layers.
• The gap, specifically:
  • RDP plus Catmull-Rom produces more nodes and more small wiggles than Potrace's optimal polygon and curve optimisation on big smooth shapes. Output is usable, but less clean to edit.
  • Median-cut posterise has no shared-edge (abutting) option, so colour layers can gap or overlap slightly at boundaries.
  • Zhang-Suen junctions become small pixel clusters rather than clean nodes.
  • Resolution is capped by the working canvas, so fine detail below one working pixel is lost.
  • The DXF flattens curves to polylines, so there are no true splines in CAD.
• Where ours is as good or better: centreline mode, which Illustrator does only approximately through strokes; adaptive thresholding for unevenly lit scans; DXF in real mm for laser and CAD directly; free and instant.
• Code: src/lib/vectorize/trace.ts, src/lib/vectorize/outline.ts, src/lib/vectorize/centreline.ts, src/lib/vectorize/fit.ts, src/lib/vectorize/dxf.ts

• Our method: Cell centres are placed on a square, brick or hex grid (hex row pitch = c·√3/2, alternate rows offset by half a cell). The distance to the point, or the minimum point-to-segment distance to the path, is divided by half the drawing diagonal, raised to a falloff power (0.2–4, default 1.4), optionally inverted, and mapped between min and max % (defaults 10–95%). Size = scale × (cell − 0.08 in (2 mm)). Cells under 0.008 in (0.2 mm) are dropped. Optional rotation toward the attractor. The DXF is minimal R12: one LINE per polygon edge and CIRCLE for round cells, on one PATTERN layer, Y flipped. No AI.
• The professional method: Grasshopper does the same distance-remap-scale operation but can combine any number of attractors, sample images, map cells onto NURBS surfaces with PanelingTools, and bake closed curves or polysurfaces. It can also feed environmental analysis (Ladybug) to drive the field from sun exposure.
• The gap, specifically:
  • One attractor field, and no image- or analysis-driven input.
  • The DXF writes loose LINEs rather than closed polylines, so laser software may not recognise inside/outside cut order until the lines are joined (Rhino Join, or LightBurn's close/optimise options).
  • "Hex" is an offset-row lattice of the chosen shape, not a hexagonal tiling.
  • There is no minimum web-width check between neighbouring cells. The 0.08 in (2 mm) allowance is guaranteed only for unrotated cells on the square grid at 100%. Diamonds (squares turned 45°), rotated cells and the offset-row "hex" grid (row pitch 0.87 × cell) can bring neighbours closer than that or make them overlap.
• Where ours is as good or better: instant, and requires no Grasshopper knowledge. It is a good first exposure to the attractor idea.
• Code: public/tools/pattern-studio/index.html, src/app/(app)/media-2d/pattern-studio/page.tsx

• Our method: The document model is in inches (default ARCH D 24 × 36 in, 0.75 in margins, 150 DPI). The editor draws at 96 px/in inside a zoomed container. Text blocks have a single style per block (one of four fonts; size in pt, leading, alignment, tracking, bold and italic flags), with greedy word wrap and character-level hard breaks, measured with the same canvas call on screen and at export. Images are embedded as data URLs, downscaled past 4096 px, and fit by stretch, contain or cover. Export rasterises each page at inches × DPI (presets 96, 150, 300, 600). The PDF is jsPDF in inch units with one JPEG page image each, quality 0.92. There is an undo stack of snapshots. No AI.
• The professional method: InDesign sets text with a paragraph composer (multi-line justification and hyphenation), paragraph, character and object styles, master (parent) pages, threaded text frames, linked images, ICC/CMYK output, bleed and slug, live preflight, and vector PDF/X export with embedded fonts.
• The gap, specifically:
  • The PDF is raster. Text and linework are pixels at the chosen DPI, not vectors. At 150 DPI small type and hairlines are visibly soft when plotted, and the text is not selectable or searchable.
  • There are no styles, master pages, threading or inline rich text (one style per block).
  • No CMYK, ICC, bleed or preflight.
  • Large-sheet DPI has no canvas-size guard. ARCH D at 600 DPI is about 311 megapixels, which is likely past some browsers' canvas area limits (unverified per browser). An export at that setting may fail or come out blank.
• Where ours is as good or better: no licence, instant start, true paper sizes by default, and a one-click hand-off to the Tactile tool.
• Code: src/lib/graphics/types.ts, src/lib/graphics/paper.ts, src/lib/graphics/layout.ts, src/lib/graphics/export.ts, src/app/(app)/graphics/GraphicsTool.tsx

• Our method: Frame 0 draws the footprint as a 0.5 ft plate. validateSequence allows only one extrude, which must precede every other move, and allows booleans only while the mass is axis-aligned and rectilinear; refused moves appear as error frames. Geometry uses box, prism and box-from-box subtract. Abutting boundaries are re-meshed so that touching boxes share vertices, with no seams. A twist is a stack of rigid slabs at a set angle per level. One mm-per-metre page transform is solved from the bounding box of all frames plus the site. HLR extracts feature edges (boundary, non-manifold, crease > 28°, silhouette) and samples visibility along each edge at a step of page-diagonal/700 (capped at 256 samples per edge), using a 96 × 96 page-space grid to find occluders. The shuffle is a seeded Fisher-Yates, re-rolled until the order is legal and not the identity. Output is an SVG/PNG/JSON strip. No AI.
• The professional method: Rhino Make2D computes exact analytic hidden lines on NURBS and meshes, in parallel or perspective, and any geometry can be modelled. Designers then compose and annotate by hand.
• The gap, specifically:
  • The move vocabulary is limited: axis-aligned boxes and prisms, stepped (not smooth) twists, and booleans only before any twist.
  • Hidden lines are sampled, not exact. Crossings resolve to about 1/700 of the page diagonal (coarser on edges longer than about a third of it, because of the 256-sample cap), so small hidden/visible glitches can occur at near-tangent edges.
  • Orthographic only.
• Where ours is as good or better: frames are guaranteed to share one projection and scale; arrows are derived from the actual transform; reordering redraws the whole strip; the shuffle test turns "does the order matter" into something you can look at. Doing this by hand in Rhino plus Illustrator is slow and does not keep the frames consistent.
• Code: src/lib/sequence/legality.ts, src/lib/sequence/geometry.ts, src/lib/sequence/build.ts, src/lib/sequence/scene.ts, src/app/(app)/rap/tactile/engine/hlr.ts

• Our method: The working canvas is ≤ 1100 px, and export re-renders at ≤ 4096 px. Contrast is applied with the 259(c+255)/(255(259−c)) lookup. Separation: mono = 1 − Rec.601 luma. Duotone = the same plus an accent plate of 1.04·dk^1.25. "Tritone" = 1 − R, 1 − G, 1 − B as C, M, Y. CMYK = the same, then k = min(c,m,y) × gcr is subtracted from C, M and Y and becomes K. Screening: a rotated lattice per plate, where each dot's density is the summed-area mean over an axis-aligned box around the rotated cell centre, and densities ≤ 0.004 are skipped. Default angles are C 15°, M 75°, Y 0°, K 45°, the classic offset set. The ruling is a cell pitch in working-canvas pixels, not lines per inch. Dot sizing: square half-side = √t · cell/2, which is area-true. Circle r = √t · cell · √2/2, which is π/2 ≈ 1.57× area-true until the dots merge at t = 0.5. Diamond is about 1.54×. Line width is linear in t. Presets set gain to 1.0–1.12. Over-print is multiply at plate opacity, with mis-registration plus mulberry32 jitter and seeded value-noise grain. No AI.
• The professional method: Photoshop separates RGB → CMYK through an ICC profile (for example a GRACoL or SWOP condition), with GCR/UCR, black-generation curves, total ink limit and dot-gain built into the profile. RIPs screen at a set lpi and resolution with rational/irrational or supercell angles to control moiré, or use FM screening. Photoshop's Duotone mode drives each ink from greyscale through separate editable curves. Riso drivers apply their own screening at the device's resolution.
• The gap, specifically:
  • The separation ignores ink hue and paper. 1 − R treats a Riso ink as ideal cyan, so real Riso inks (fluorescent pink, blue) will not reproduce the source colours; the error is large and hue-dependent.
  • Circle, ellipse and diamond dots are not area-true. Midtones render darker than the density asks (a 25% tone draws about 39% coverage with round dots), stacking on top of any real press dot gain. The square shape is the exception.
  • "Tritone" here means CMY process colour, not Photoshop's greyscale tritone.
  • The ruling is in screen pixels, so the physical lpi depends on export size. There is no lpi or DPI control for a known print size.
  • Dot density uses an axis-aligned box average under a rotated cell, a slight blur at non-zero angles.
• Where ours is as good or better: live, readable over-print simulation with Riso inks and paper colours; plate masters that are ink-only; true vector dot SVG for plotters and lasers, which Photoshop does not output directly.
• Code: src/app/(app)/media-2d/halftone-riso/engine.ts, src/app/(app)/media-2d/halftone-riso/presets.ts, src/app/(app)/media-2d/halftone-riso/voices.ts, src/app/(app)/rap/dither-camera/engine.ts

• Our method: solar() runs the NOAA spreadsheet chain: Julian day and century from Date.UTC, geometric mean longitude and anomaly, equation of centre, apparent longitude with the nutation term (ω = 125.04 − 1934.136T), corrected obliquity, declination, equation of time, true solar time, hour angle, then altitude and azimuth. The year is fixed at 2025. Latitude, longitude and UTC offset are typed by hand, with no DST and no timezone lookup. The light sits 300 units out along the sun vector. Shadows come from a 2048×2048 PCFSoft shadow map through an orthographic camera spanning ±160 units (near 1, far 900). A hemisphere light and an ambient light fill in the rest; they are not a sky model. The sun-path arc samples every 8 min. Sunrise and sunset come from a 10-minute scan for the altitude crossing zero. Imported STL, OBJ, PLY or 3DM files are scaled so the footprint is 60 units wide.
• The professional method: Ladybug's sun path also uses the NOAA equations. NREL's SPA (quoted at ±0.0003°) is the reference where precision matters. For shadows, Ladybug and Forma ray-cast every hour against a real context model and report sunlight or shadow hours per test point. Radiance adds sky and reflections.
• The gap, specifically:
  • No atmospheric refraction. NOAA's spreadsheet applies a refraction correction; this port does not. Altitude reads up to about 0.5° low near the horizon and about 0.02° low at 45°.
  • Sunrise is reported late. The code finds the crossing at geometric altitude 0°, not the almanac's −0.833°, and reports the first 10-minute sample after it. Sunrise therefore reads about 4–16 min late at mid-latitudes. Sunset reads anywhere from about 6 min early to 6 min late.
  • No context, terrain or diffuse light, and nothing outside the ±160-unit frustum casts or receives a shadow. With no neighbours there is no shadow-on-neighbour answer at all.
  • Imported models lose their real size. The shadow shape stays correct because it depends only on angles, but the ground grid and the "m" readout no longer mean anything.
  • The date picker uses irregular month lengths. Feb 29 is selectable even though the year is fixed at 2025, which is not a leap year, and it becomes Mar 1. Aug 31 and Oct 31 cannot be picked. "Sep 31" and "Nov 31" can be, and roll over to Oct 1 and Dec 1.
• Where ours is as good or better: The sun-position maths is the same as Ladybug's and runs instantly in a browser with nothing to install. The animation is a good way to teach sun-path intuition.
• Code: public/tools/sun-study/index.html, src/app/(app)/tools-3d/sun-study/page.tsx

• Our method: solar() is the same NOAA chain as Sun & Shadow, evaluated at longitude 0 and UTC offset 0. The window hours are therefore local mean solar time, with the equation of time applied. Samples run every 15 min from start to end, and any with altitude ≤ 3° are dropped. Each sample gives a shadow direction (opposite the sun's bearing) and tan(altitude). For each grid cell (N from the resolution slider, M scaled to site depth), exitDist() finds the distance to the rectangle's edge along the shadow direction. Height = min over samples of distance × tan(alt), then capped. Season presets are single days: Dec 21, Mar 20 and Jun 21. OBJ export writes the three.js mesh.
• The professional method: Knowles' envelope is bounded by shadow fences (a permitted shadow height on each neighbouring lot, often non-zero across a street) and by a time window that often spans more than one date (for example both solstices, or a season), not one day. Grasshopper implementations intersect the solar fans of each boundary segment. Real zoning then adds setbacks, height limits and street-wall rules.
• The gap, specifically:
  • Zero-height shadow fence. No shadow may leave the site, even across a street. This is stricter than Knowles' usual practice, so the envelope comes out lower than a real envelope that tolerates shadows across a right-of-way.
  • One day only. For the winter window, Dec 21 is the limiting day, so the result is close for a Nov–Feb protection period. For a summer-only window, days either side of the solstice have lower sun and would cut deeper, so the result is too generous.
  • Mean solar time, not clock time. The window shifts by the equation of time: about −7 min at the March equinox and about +2 min at the December solstice.
  • The site cannot be shaped. It is flat, rectangular and cardinal-aligned, with no rotation, terrain or irregular lot.
  • Smooth mode is not the exact envelope. It averages each vertex from four cells.
• Where ours is as good or better: The construction is transparent: each cell is a one-line min over sun samples, which is easy to teach. Results are instant.
• Code: public/tools/solar-envelope/index.html, src/app/(app)/tools-3d/solar-envelope/page.tsx

• Our method: allSegs() collects the boundary edges, wall segments and rectangle edges. allVerts() removes duplicate corners at 0.01 px. computeIsovist() casts three rays per corner (±0.0001 rad), and rayHit() solves the exact 2×2 parametric intersection, keeping the nearest hit with t > 10⁻⁶. Hits are sorted by angle and merged when closer than 0.5 px. The metrics are: shoelace area; perimeter; area centroid; compactness 4πA/P² clamped to [0,1]; maximum viewpoint-to-vertex distance; and drift (viewpoint-to-centroid distance). They are converted from pixels by a scale field that defaults to 50 px = 1 m. The room is a fixed 760×520 px rectangle.
• The professional method: depthmapX computes the same exact isovist polygon for a point. Its main use is VGA: it lays a grid over the plan, computes inter-visibility between all cells, and derives connectivity, visual integration, clustering coefficient and mean depth. Grasshopper isovist tools usually cast a fixed fan of rays, which approximates the exact polygon at a set angular resolution.
• The gap, specifically:
  • One point, no field. There are no VGA or space-syntax graph measures, so the tool cannot answer how integrated one space is relative to another.
  • Straight, full-height, opaque walls only. Walls are zero-thickness lines and obstacles are axis-aligned rectangles. There are no curves, doors, glazing or partial-height partitions, and no eye height.
  • Metric units. Readouts are in m and m² from a px/m scale, and the scale does not rescale the drawing.
• Where ours is as good or better: The polygon is exact, with no angular-resolution error, which is better than fixed-fan ray casting. It is instant, it exports true vector SVG, and the method is described on the page.
• Code: public/tools/isovist/index.html, src/app/(app)/tools-3d/isovist/page.tsx

• Units: The chart and its readouts are in °C and g/kg (grams of water per kilogram of dry air); there is no °F view.
• Our method: P is fixed at 101,325 Pa. Psat = 610.94·exp(17.625T/(T+243.04)) Pa. These are the Alduchov–Eskridge (1996) Magnus coefficients. W = 0.62198·Pw/(P−Pw). h = 1.006T + W(2501 + 1.86T) kJ/kg. Dew point inverts Magnus. Wet-bulb is 50 bisection steps on ASHRAE Fundamentals Ch. 1's thermodynamic wet-bulb relation W = ((2501 − 2.326t*)Ws* − 1.006(t − t*))/(2501 + 1.86t − 4.186t*). Zones are polygons in (T, W) space:
  • Comfort: 68–81°F (20–27°C), 20–80% RH, W ≤ 12 g/kg.
  • Below 68°F (20°C): heating.
  • Inside the comfort temperature band but outside the RH band (or above 12 g/kg): humidify or dehumidify.
  • Above 81°F (27°C), split only by humidity-ratio bands: evaporative (< 7 g/kg), thermal mass + night vent (7–13), natural ventilation (13–18), A/C (≥ 18).
• The professional method: The ASHRAE Handbook, and PsychroLib, compute saturation pressure with the Hyland–Wexler (1983) formulation and take pressure from altitude. Climate Consultant offers ASHRAE 55 PMV, the adaptive model, the California Energy Code and ASHRAE Handbook 2005 comfort models. Its strategy zones (after Givoni and Milne) are parameterised: evaporative cooling follows wet-bulb lines, natural ventilation extends comfort by an assumed air speed, and thermal mass is bounded by a diurnal swing. Ladybug derives its strategy polygons from PMV plus set parameters (fan speed, night-flush temperature drop, and so on).
• The gap, specifically:
  • The Magnus form versus Hyland–Wexler. The difference is small, roughly within 0.4% on saturation pressure over the chart's range. Readouts agree with ASHRAE to about 0.1 g/kg and 0.2°F.
  • Sea-level pressure only. At 5,000 ft (1,524 m) the pressure is about 84 kPa, so W is about 20% higher for the same RH and dry-bulb, so every W, h and zone position is off at altitude.
  • The zones are not Givoni's. They are rectangles that do not overlap, and above 81°F they are split only by humidity ratio. Real strategy regions overlap and slope along wet-bulb and enthalpy lines. Two examples:
    • Hot, dry air at 104°F (40°C) and 8 g/kg is classed as "thermal mass", but Givoni and Climate Consultant would also admit evaporative cooling.
    • Natural ventilation is cut off at 18 g/kg, where real charts extend it.
  • No comfort model. There is no clo, met, air speed or mean radiant temperature, so "comfort" is a fixed box, not PMV or adaptive.
  • One point at a time, not a climate year.
• Where ours is as good or better: The equations are exact and shown on the page, the tool is instant, and SVG export uses the same geometry as the screen. It works as a legible first chart before Climate Consultant.
• Code: public/tools/psychrometric/index.html, src/app/(app)/tools-3d/psychrometric/page.tsx

• Our method: Declination uses Cooper's equation (23.45·sin(2π(284+n)/365)) on the mid-month days [15, 45, …, 349]. Solar position comes from sunDirection() in lib/crucible/solar-field.ts: hour angle 15°·(h−12) in local solar time, with no equation of time and no longitude. HSA = azimuth − facade azimuth. tan(profile) = tan(alt)/cos(HSA). Per blade, the band height is d·(sin β + cos β·tan φ), offset by the stand-off × tan φ. Bands are unioned (coveredLength) and clipped to the window height, and fins are treated the same way across the width. The eggcrate is 1 − (1−L)(1−F).
  • The metrics are unweighted means over half-hour samples, 5 am to 7 pm, on the facing hours of Nov–Mar (heating) and May–Sep (cooling). The seasons flip in the southern hemisphere.
  • "Cutoff" = cooling months whose 11 am–1 pm mean shading is at least 85%.
  • "Openness" = 1 − shading at altitude 0°, straight ahead.
• The professional method: The Olgyay mask is the same geometry drawn on a sun-path protractor. Ladybug's LB Thermal Shade Benefit weights each blocked sun vector by how far that hour's temperature sits above or below comfort thresholds (degree-days), LB Shade Benefit counts blocked sun hours, and a Benefit Sky Matrix fed to Incident Radiation weights radiation by a balance temperature; all work on arbitrary 3-D shade geometry. Radiance and EnergyPlus add diffuse sky, reflections, angle-dependent glazing SHGC and the room response.
• The gap, specifically:
  • Time-weighted, not energy-weighted. A 7 am sample at 10° altitude counts the same as solar noon. On south facades this over-weights low-sun hours that carry little beam on the glass. On east and west it under-states how much the unshaded low sun matters.
  • Direct beam only. On a well-shaded window, diffuse sky and ground light become most of the remaining solar gain (unverified share), so a device that reads "100% summer cut" still passes real diffuse gain.
  • Solar time with no equation of time, and one declination per month.
  • Infinitely long blades and full-height fins, zero thickness, no reflection off the blades. Real louver soffits reflect light onto the glass.
  • Heating and cooling seasons are fixed month lists, not derived from the site's climate.
• Where ours is as good or better: The per-blade band union is exact for its geometry, and it correctly handles a single overhang and the window edges that the textbook periodic formula d·sin(β+φ)/(s·cos φ) gets wrong. The heatmap, mask chart and 3-D shadow come from one function, so they cannot disagree. The laser cut sheet in true millimetres is something the pro tools do not produce.
• Code: src/lib/brise/mask.ts, src/lib/brise/metrics.ts, src/lib/brise/sun.ts, src/lib/crucible/solar-field.ts, src/lib/brise/cutsheet.ts

• Our method: The six octave bands run from 125 Hz to 4 kHz.
  • Absorption and RT60. Sabins = Σ area × α per band. Air absorption follows ISO 9613-1 at your temperature and humidity and enters as a 4mV term. Sabine is k·V/(A+4mV) and Eyring uses −S·ln(1−ᾱ), with k = 24·ln10/c and c = 331.3·√(1+T/273.15). Arau-Puchades is the product of per-axis RTs, each raised to that axis's area share. The headline RT is Arau when one surface carries more than 50% of the mid-band absorption; otherwise it is the mean of Sabine and Eyring. There is no Millington or Fitzroy formula.
  • Modes and flutter. Modes are the analytic rigid-box frequencies up to max(300 Hz, 2·f_s). For an imported mesh they come from its bounding box.
  • Materials. The library has 27 materials with per-octave α (after Vorländer 2008 and handbook tables, cf. the pyroomacoustics DB). Each carries one mid-band scattering coefficient, which is applied to every band.
  • Ray-trace set-up. The trace clusters the mesh into at most 48 planes. It computes image sources to order 2 (draft) or 3 (standard and high), each one validated backwards from the receiver and occlusion-tested.
  • Rays. It then fires 30,000, 80,000 or 200,000 seeded rays from an omnidirectional source. The receiver is a 16 in (0.4 m) sphere. Energy is multiplied by (1−α) at each hit, and each reflection scatters diffusely (Lambert) with the scattering probability, specularly otherwise. Rays run to at most 400 bounces, with Russian roulette below 1e-4. Energy lands in 1 ms bins, and a path is not counted while it is still purely specular within the image-source order, so nothing is counted twice.
  • Impulse response and metrics. The tail is built from Gaussian noise matched to the energy histogram and band-passed per octave (RBJ, Q 1.414). Schroeder backward integration then gives EDT, T20, T30, C50, C80, D50 and Ts.
  • Auralization. Mono convolution of a clap or a dry speech clip, with either the simulated IR or a parametric IR built purely from RT.
  • AI. The assistant (Claude Haiku 4.5 on Fast, Sonnet 5 on Deep) sees a summary only. Any treatment it proposes is parsed and whitelisted against real surface and material ids, then re-run through the engines.
• The professional method:
  • ODEON: a hybrid of early image sources (to a transition order) and ray or "secondary source" radiation for the late part. Scattering is frequency-dependent, with Lambert or vector-based models and edge diffraction. It uses measured loudspeaker and talker directivity (CLF/GLL), and auralizes binaurally through HRTFs.
  • CATT-Acoustic: cone tracing, originally randomized tail-corrected cone tracing (RTC) and now TUCT (The Universal Cone Tracer), with similar inputs.
  • Treble: adds a wave solver below the transition frequency, which our tool leaves to an analytic box model.
• The gap, specifically:
  • Scattering: ours is one value per material for all bands. Real scattering rises with frequency, so our high bands are too specular. Expect T30 and C80 at 2–4 kHz to be less reliable than at mid-band, and flutter or focusing to look stronger at high frequencies than it is.
  • No diffraction: there is no edge diffraction and nothing for sound going around a balcony front or a portal lip. This overstates shadowing behind obstacles.
  • No directivity: the source is omnidirectional and the receiver is mono, so there is no binaural or lateral-energy measure (LF, IACC). That is a real omission for concert-hall work.
  • Low frequencies: there is no wave solution below 2·f_s. The modes panel treats walls as perfectly rigid and the room as a box, so it cannot predict how modes are actually damped or distributed in a non-rectangular room.
  • Material data: α values are generic lab rows (±0.05–0.15 between lab and field). One row, for example, stands in for all "gypsum board", where a real project would use the datasheet for the specific product.
  • Free-standing absorbers: in the trace these become a uniform α increase on every surface, not an object with its own position and edges.
  • STI: it comes from the RT-based MTF plus a single S/N value. It is not the octave-band STI (IEC 60268-16) that EASE or ODEON compute.
• Where ours is as good or better: The RT60 arithmetic is exactly the hand method a consultant uses first. The ray tracer is real geometrical acoustics on your actual triangles, and it is reproducible because it is seeded. It runs in a browser in seconds, needs no licence, and shows its constants.
• Code: src/lib/acoustic/rt60.ts, src/lib/acoustic/analyze.ts, src/lib/acoustic/geometric/raytrace.ts, src/lib/acoustic/geometric/ism.ts, src/lib/acoustic/materials.ts