RAP Studio
Design a building without needing to see it. The Radical Accessibility Project (RAP) is a way for blind and low-vision students to author architecture alongside sighted classmates — and this page is a hands-on demo of it, running right in your browser. No account or install needed to try it.
You lay out a plan by typing plain-English requests, short commands, or filling in form fields. The studio keeps your whole design as a single text file and shows it back to you several ways at once — a 3D model, a touch-readable plan, a written description, and Braille — plus downloads for a swell-paper tactile print and a 3D print. The 3D view is only an aid for sighted testing; nothing here needs sight to use. When you’re ready, the same design can be sent to Rhino, the 3D CAD software architects design in.
Loaded with a sample model — one building described at three phases (Massing → Structure → Plan), the same building at rising resolution. Use the phase rail below to focus one phase and author it cleanly (the others show as a dashed reference ghost), or pick Composite to see the whole building together. The Assistant is the main way to author: describe what you want in plain language and it writes the Controller commands for you — the same way a designer directs Claude Code in a terminal. Every change is read back in all channels (plan, 3D, text, Braille, state tree). Prefer to type commands yourself? Switch to the Console. Use Load starter to begin from an empty model, a bay grid, a massing diagram, a single floor plate, or the sample.
New geometry lands in the focused phase; other phases show as a dashed reference ghost (a finger reads hollow context vs. solid figure — except columns, which always print solid as registration marks). The focused phase's lens — structural bays, massing, or floor-plan layout — scopes the Console, Assistant, and Forms.
Author
Type help for the full command list · ↑ / ↓ for history.
Model — visual test
The 3D view is an orthographic (parallel) black-and-white aid for sighted testing — hidden from screen readers. Solid black edges are visible; dotted black edges are hidden lines. The model is fully readable in the tactile plan, the read-back text, and the state tree.
Canonical state.json
state {15}
phases [3]
0 {7}
1 {7}
2 {7}
meta {3}
site {4}
origin [2]
boundary [5]
0 [2]
1 [2]
2 [2]
3 [2]
4 [2]
style {9}
layers {5}
Default {3}
massing {3}
structure {3}
slab {3}
walls {3}
bays {1}
A {17}
origin [2]
bays [2]
spacing [2]
corridor {5}
walls {2}
apertures [0]
walls [5]
0 {7}
a [2]
b [2]
1 {7}
a [2]
b [2]
2 {7}
a [2]
b [2]
3 {7}
a [2]
b [2]
4 {7}
a [2]
b [2]
regions [5]
0 {9}
origin [2]
size [2]
1 {9}
origin [2]
size [2]
2 {9}
origin [2]
size [2]
3 {9}
origin [2]
size [2]
4 {9}
origin [2]
size [2]
columns [0]
openings [3]
0 {6}
1 {6}
2 {6}
levels [2]
0 {3}
1 {3}
tactile3d {6}
Read-back — the non-visual model
FOCUS — Structure (think in a column grid), refining Massing. Other phases read hollow for reference — except columns, which always print solid. OVERVIEW — An irregular infill lot (5-sided, within 100×100 ft); 2 levels. Holds 1 structural bay, 3 floor plates, 2 extruded boxes, 5 free walls, 0 columns, across 3 phases on 5 layers. LAYERS — Default (solid, 0.25 mm); massing (solid, 0.35 mm); structure (solid, 0.35 mm); slab (solid, 0.25 mm); walls (solid, 0.25 mm). PHASES (3) — • Massing (massing): 2 elements, 60×40 ft [reference] • Structure (bays): 1 element, 60×40 ft, from Massing [focused] • Plan (floorplan): 8 elements, 60×40 ft, from Structure [reference] LEVEL 0 — Ground (z=0 ft): • bay Bay A: 3×2 grid @ 20×20 ft, origin (18,12) LEVEL 1 — Level 2 (z=12 ft): • (nothing from the focused phase on this level) NOT SHOWN IN DETAIL — 10 element(s) in other phases (counted in PHASES above).
Drive Rhino — talk to state.json + the Watcher
How it works: your model is one state.json file. A small Watcher running inside Rhino rebuilds the geometry every time that file changes. So the whole job is getting state.json into the folder the Watcher is watching — three ways below, simplest first. (Set up the Watcher in Rhino once; see the last card.)
Surfaces vs. mesh: driving Rhino this way rebuilds your model as native Rhino solids — plates and boxes become real surfaces you keep editing, which is Rhino’s default working mode. The Export STL button instead writes a fixed mesh(a triangle skin) for printing or hand-off — not surface-editable. Same model, two representations: know which one you’re holding. (The Export .3dm button in the toolbar above makes the same choice explicit — native surfaces by default, mesh with its “as mesh” toggle.)
state.json into the folder by hand or by connecting it. The live link (Option C) pushes it straight from this page the moment you change anything — so Rhino rebuilds as you work.Studio-native elements: 5 geometric regions, 5 free walls, 3 wall openings travel in the file under web_* keys. The Watcher below (v3, “web edition”) rebuilds all of them in Rhino — plates and boxes as solids, free walls with their openings, the irregular site boundary as a real polyline, and your design phases as toggleable sublayers. An older desktop Watcher rebuilds only the bays/apertures/levels core and skips the rest — if that’s what you have, grab the new one below.
Option A · Download the file (any browser, no setup)
Save it into your Rhino project folder — the one the Watcher is watching. It is the same file as Export → state.json at the top of the page; write it again whenever you want Rhino to rebuild.
Option B · Auto-write to that folder (Chrome or Edge)
This browser can’t write files directly — use Chrome or Edge, or use Option C below.
Option C · Live bridge (any browser)
For any browser, or a live link to Rhino: a tiny helper runs on your machine and this page pushes to it. Set it up once:
- Download the helper and save it next to your Rhino project folder:
- In a terminal, run it pointed at that folder:
python3 rap_bridge.py --folder /path/to/your/rap-project
- It prints a URL and a token — paste them here and test:
- Push the model — now, or automatically on every change:
In Rhino (once)
Download the RAP Watcher, open it in Rhino’s ScriptEditor (type ScriptEditor, open the file, press play), and set its STATE_FILE to the state.json in your project folder. It rebuilds the whole model whenever that file changes — bays, corridors and apertures, plus the studio’s floor plates, extruded boxes, free walls with their openings, columns, the irregular site boundary, and your design phases as toggleable sublayers.
How to use this — instructions & tips
The idea
There is one canonical model (the state.json above). Every way of building — the Assistant, the Console, and the Forms — writes the same commands to it, and every view — the tactile plan, the 3D aid, the read-back text, the Braille key, and the state tree — reads from that one model. Change it once, and it's correct in every channel at the same time. That parity is the whole point: a designer using a screen reader and a designer looking at the plan are working on the identical building.
Getting started
- Read the sample model in the views to see what a finished model looks like.
- Use Load starter → Empty to start from an empty model (or → Sample model to bring the example back).
- In the Assistant, describe a move — e.g. “add a 36 by 20 floor plate on a new slab layer.”
- Watch the commands it ran, and confirm the change in the read-back and the plan.
- Keep going one move at a time; export when you're ready to drive Rhino.
Tips
- Assistant is fastest for whole moves; Console gives you exact control — type
helpfor every command. - In the Assistant, press Enter to send (Shift+Enter for a new line).
- Made a wrong move? Undo / Redo step through your whole history (loading a starter is undoable too).
- Turn on Speak confirmations to hear every change announced aloud.
- Use the level selector on the model to view and export one floor at a time.
- The 3D view is only a sighted aid — it's hidden from screen readers. The plan, read-back, and Braille are the real model.
- Exports — state.json, PIAF PNG (tactile print), STL (3D print), and the command log — all match what's on screen.