← labopen fab →

17 October: pattern table and outfits

Construction now lives on the table: tap a piece on the paper to pick it (a tap on the paper round it, the whole pattern again), and drag its lit edges. The drawer speaks as it always did for the skirt's paper: what's picked and what it is in its header, with undo and redo; then, expanded, each edge it offers and what dragging it does, what each is set to, and its own choices (a neck, a collar, its sleeves; a sleeve's head; a skirt's tiers) as words to tap. A skirt panel tapped is the skirt's paper, with its cut, fold and gather tools. A versioned journal in recipe.journal records construction and material deltas with semantic targets, undo and redo; legacy recipe.moves remains the skirt compiler input. This is replayable parameter editing, not yet an arbitrary cut grammar for bodices or trousers.

At the rails, with something already on the figure, the card asks whether to put the next one on instead or as well. With more than one on, a tap on a garment on the figure is the one worked; the drawer lists what's worn, and takes the one in hand off. Outfits and operation histories persist locally, including reloads of the active design URL. Saving to a rail remains explicit. Ordered inter-garment contacts keep outer vertices off nearby inner surfaces; this is discrete contact, not continuous collision detection, and does not guarantee every possible outfit is intersection-free.

Cloth changes: 16 substeps, interleaved stretch/bending/seam constraints, mass-weighted tethers, velocity-aware body collision checks, and velocity-preserving warm starts matched by piece name. Print and colour edits no longer rebuild cloth. Large topology changes still resew.

Validation against the preceding build: pattern and garment checks pass; all 27 workshop garments still sew up; the stricter soundness count improves from 12/27 to 14/27. Maximum Cusick drape discrepancy falls from 0.27 to 0.15, still above the 0.10 acceptance target. Physics is improved, not declared settled. These are numerical harness results, not an iPhone performance or visual approval. Multiple garments increase simulation and contact cost.

Regression sources: devtools/fab-operations.test.ts, devtools/fab-ui.test.cjs, devtools/fab-evidence.ts. The UI harness uses jsdom with mocked canvas/WebGL; it checks interaction/state transitions and actual local-storage reload, not rendering quality.


Fab

A dressmaking workbench for children. A little wooden figure stands on a turned stand, mounted on a chromed pole up into its pelvis, and beside it lies a garment's paper pattern: a skirt, a top, a dress, trousers or a jumpsuit. Nothing is chosen from a list. A child decides what a dressmaker decides, the pattern that follows is drafted to the figure, and the cut cloth is sewn up round it and falls as that cloth falls.

The aim is for a child to find out that clothes are made, and can be reasoned about, constructed and transformed.

This page sets out what Fab claims, how it's built, and the evidence for and against it. The evidence comes from the evidence bench (?bench=evidence), which runs the same tests in the page as it does headless.

One garment family, deep, then five

The first Fab tried to dress the figure in a skirt, a top and a cape, each with the same six dials. The skirt worked. The top's sleeves never sat properly. Its pieces weren't real pattern pieces:

so no simulation could have made a garment of them. And dials like silhouette and drape claimed to set what should only ever be found.

So Fab went deep into one family first: the skirt. It's the simplest thing that's truly made: flat pieces cut, joined round a body and hung from one line, the waist. Nearly every move a dressmaker has shows in it:

With the skirt sound, the same grammar now makes four more families. It follows GarmentCode (Korosteleva & Sorkine-Hornung 2023): a garment is components drafted to the body's measurements and sewn edge to edge by length. The first Fab's failures are now checks every pattern has to pass:

The skirt's made by hand, on its paper, at the cutting table. The others are decided at the figure, in its drawer, with choices and dials. Moves on their paper are next (see Known limitations).

The cutting table: a grammar of moves

A skirt is a waistband and n panels round it, each sewn to the next, every panel cut the same. A panel isn't chosen from a family of shapes. It's the dressmaker's straight skirt block, drafted to the figure, plus the moves made on its paper, in order (cut.ts).

The block

Straight down from the hips. Its side seams curve in toward the waist as far as a seam can (2 cm). Darts take in the rest, as many as it needs, none deeper than 3 cm. Fewer panels means fewer seams, so more darts: a straight skirt in one piece needs darts all round.

The moves

movewhat a cutter doesgesture on the paper
spreadslash from the hem up to the waist, leaving a hinge, and open the hemslash: touch the hem, drag sideways
pleatslash down from the waist, spread it parallel, fold the new cloth into a knife pleat, stitched 5 cm downfold: touch the waist, drag sideways
gatherslash and spread parallel, and ease the new width into the band where it was addedgather: touch the waist, drag sideways
close a dartpivot the cloth beside it about its point until its legs meet: the waist's taken in the same, the hem below openshand: tap the dart
release a dartdon't sew it; gather its width into the band insteadhand: tap it again (a third tap sews it again)

The rest are parameters on the same paper:

Every move is a chip in the history under the paper. Tap one to take it back: the rest are made again, in order, and a move that now does nothing is struck through and says so. undo takes back the last.

The moves don't commute, and that's the point. A pleat folded and then slashed through opens toward the hem with the flare. Slashed first and then pleated, it hangs straight. Closing a dart first and then spreading isn't the same as the other way round. Positions are on the paper as it is when the move is made. Even the shortcuts below have to account for that: placing three pleats "a third of the way along each" bunched them up, because each one lengthens the waist the next is measured on.

How a panel is represented

A panel is a row of ribs: lines from waist to hem, bent once, at the hips at its sides or at a dart's point. Between the ribs are strips: cloth, a wedge someone spread, a pleat, a dart, or eased width. Moves insert ribs, and turn or slide everything to one side of them, so a strip is always exactly the paper it was. Each strip records the move that made it, so the history is the pattern's provenance.

What's sewn, and how the waist meets the band, follow from the strips:

Paper that's one piece (cloth, and what's been slashed and spread or a dart closed into it: a cutter tapes these back into one) is meshed as a single region, with rulings evenly spaced along the waist and the hem. Folds and darts still sewn keep their own columns, so their edges can be sewn.

What we took from GarmentCode, and what we didn't

GarmentCode (Korosteleva & Sorkine-Hornung 2023) programs parametric sewing patterns as panels of edges joined by stitches between named interfaces.

Taken:

Not taken: its sampling of designs for datasets, its 3D placement, and its edges shared by reference between edits. That last is fragile under sequences of edits, as its own code comments note.

Where Fab goes beyond it, because the gestures need it:

The dials, kept as shortcuts (and as the comparison)

The first Fab's controls are still there (?ui=dials): length, fullness, flared/gathered/pleated, panels, grain. They no longer draw anything themselves; they write moves:

The workshop's rail and the evidence bench go through the same shortcuts, so they exercise the same cutting. The dials stay as the other half of the comparison the next step needs: do children who make a skirt on the paper understand it better than children who turn dials?

What's never set (outcomes)

Silhouette, how many folds and how deep, whether the hem is level, how far it swings out in a twirl. These are what the simulated cloth does with the cut.

The other families

Every family is drafted from the figure itself, measured from its own shapes in body.ts, and every one passes the same checks: seams meet, pieces lie flat, pieces fit on the cloth. Each also has checks of its own.

Tops (bodice.ts)

A front and a back, each half the chest's round and its ease. The ease runs from snug (4 cm) to roomy (16 cm).

controlwhat it is
lengthcm below the waist; less than 0 is cropped above it
roomwearing ease round the chest
sleevescm down the arm, 0 for sleeveless; plain, puff or bell
neckround, V, square, boat or scoop, and how much lower or higher than usual
swinghow much wider the hem is than the chest
collarnone, Peter Pan, band or frill

What follows from those choices:

Dresses

A bodice cut to the waist, with a skirt sewn round its hem. The skirt is cut at the table like any skirt, but to the bodice's hem instead of a waistband: its recipe carries that round (band), so its paper, its dials and the dress all cut the same skirt. Its darts, pleats or gathers close into the hem: each point of the skirt's waist is sewn to its own place round it.

Trousers (trousers.ts)

Four panels, after GarmentCode's PantPanel: a front and a back for each leg.

controlwhat it is
legscm of leg below the crotch: shorts (5) to full length (33)
widthroom in the leg, slim to wide (culottes, palazzos)
flarethe hem over the knee: tapered, straight, flared

What follows from those choices:

Jumpsuits

A bodice to the waist, with trousers gathered onto its hem.

Tiers

Any skirt or dress can have two or three tiers. Each is a ring of straight panels 1.5 times the round of the hem above, gathered onto it, as GarmentCode's SkirtLevels are. The first tier still comes past the hips.

How it's represented

GarmentCode's edges are lines, circle arcs and Béziers whose control points are relative to their chord (edges.ts), so a curve keeps its shape whatever its ends do.

A piece is four runs of edges round it, with its cloth's grid laid over them as a Coons patch. Every corner between two edges falls on a grid point. So a bodice with its armholes and neckline, a sleeve with its head and a trouser leg with its crotch curve are all grids, as a skirt's panel is. (A skirt's panel is meshed as ruled regions from its paper's strips: see How a panel is represented. A piece cut from curves is a Coons patch.) The cloth needed only one new thing.

A seam sews two runs by length, as GarmentCode's stitches do. Every point of each run is sewn to the place the same fraction along the other: between two of its points, by a new interpolated XPBD stitch constraint in cloth.ts. Two runs of different lengths gather the longer onto the shorter. Gathered waists, puffed sleeve heads, tiers and frills are all that one rule.

The grid runs down each piece, so no edge along a piece's top or side may run in the grid's own direction. That would crush the cells. So:

Under an arm or a leg the difference is a few millimetres. The pieces lie flat check catches any grid that crushes.

The figure. Its torso is lathed through ellipses from between its legs up to its neck, and closes smoothly between its thighs where the pole goes in (it used to sit on a ball there, which stood out at the front as a bulge). The trousers' rise is still drafted for that fuller seat, so their patterns are unchanged and sit with a little ease. It's jointed at the waist: the chest, and the arms, neck and head with it, bends and turns over the hips, up to about 35°, taken gradually through the waist. Everything laid round the torso and held on it (a bodice's shoulders, a waistband) is placed on the figure as it's drafted and then bent with it; the cloth meets the torso in its own unbent frame.

It's posed for what it wears. Its arms stay up in a dancer's curve for skirts and trousers. For anything with a bodice they come down to 45° below its shoulders, as GarmentCode's bodies stand.

Pieces start laid out as GarmentCodeData lays its panels:

The sewing and the shoulders' holds then draw them round. Tops hang from the tops of their shoulders. Pieces that aren't held, like sleeves, a dress's skirt and collars, are tethered to what they're sewn to.

The physical representation

Each piece is a grid over its flat shape, at about 2 cm, coarser for big skirts so the cloth stays near 1,800 points. The cloth is simulated with XPBD (extended position-based dynamics), in its "small steps" form: 8 substeps a frame. All units are centimetres, grams and seconds.

Assembly is shown, not hidden: pinned, then sewn. Each piece is first put round the figure as it stands, not as it would stand: the bodice and skirt round the torso on a surface of revolution where nothing is stretched (its round at each depth is the panels' width there), each sleeve round its own arm and each trouser leg round its own leg, along the bones wherever they've been posed. So an arm raised over the head still goes through its armhole, and a leg lifted at the knee through its leg. Nine pins (the coloured heads) hold each piece where it's placed, weightless, while the seams are drawn closed and the waist into the band; at 1.1 s the pins come out over half a second and the cloth falls. Press pin and sew it on again (in the pose's or the tug's drawer) to watch it again. (A garment changed in place, by a dial or a move, carries its cloth on unpinned.)

Why XPBD, and what else was considered

approachfits Fab becauseagainst
XPBD, small steps (chosen)stiffness in real units (compliance), unconditionally stable, cheap, deterministic, easy collisions and seamsstiff materials under-converge at few substeps: measured below
plain PBD (the first Fab)simpleststiffness depends on iteration count, so it can't be calibrated to a swatch
implicit mass-spring / Baraff–Witkin (the CLO and Browzwear lineage)large stable steps, mature for garmentsa sparse linear solve each step; heavy for a phone in JS
projective dynamicsfast, stable, prefactored systemrefactor on every re-cut; collisions awkward
FEM shells (StVK / discrete shells, ARCSim)the most faithful anisotropy and bendingfar too slow for real time on a phone
GPU XPBD (WebGPU)10–100× the points: finer foldsnot yet on every phone; the next step if folds need it

GarmentCode (Korosteleva & Sorkine-Hornung 2023) programs parametric sewing patterns as components with interfaces. It's the closest relative of the grammar here. Fab takes its "pattern first, simulate second" stance at a scale a child can turn by hand.

Evidence

Each test states a narrow claim and, as plainly, what it doesn't establish. A verdict covers only its claim. None of the tests yet compares with real cloth, real sewn skirts or children. Run them at ?bench=evidence (&converged re-measures the slow converged drape references). The numbers below are from a headless run on the cutting engine.

testclaimresultdoesn't establish
1 pattern1,120 designs (every corner of the space, plus 400 at random), 6,824 checks: seams match, the waist fits its band, hips cleared with 4 cm of ease, pieces fit across the cloth, darts sewable, paper doesn't overlap itself, every move madeholds: all passmakeability: no seam allowances, notches, opening or fastening, or order of construction; not cut and sewn by a dressmaker
2a cantileverthe cloth reproduces each swatch's bending lengthholds: converged within 10%, at the figure's settings within 18%that the swatches' figures describe real silk or felt (they're representative); bending is one stiffness every way
2b Cusickthe model drapes in the order, and over the range, drape testers findholds: converged 0.29–0.94, ordered by stiffness; folds 12 → 5agreement with the same specimens measured
2b′ real timethe cloth on the figure drapes as its converged self, within 0.10fails: gap up to 0.27 (lawn 0.35 vs 0.57)how much that gap matters to a child's predictions
2c biaswoven cloth stretches more on the bias than on the grainholds: 2–3.5× more; felt the same either waythe size of real bias growth (creep isn't modelled)
3a/3b expressivenessone cut in four cloths, and one cloth in five cuts, are measurably distinct, and soundholds: nearest pairs ≥ 1.02 apart; all soundthat a child sees them as different, or that they match real skirts
4 speedthe cloth step under 12 ms, the same every timefails here: 11–13 ms on this container's CPU; deterministicthe whole frame on a phone: use ?perf on the phone

"Sound" now means more than not exploding:

On the cutting engine the worst sound skirt (pleated) has 11% stretch at the 99th percentile and a 4.6 mm seam gap.

One construction (flared, 4 panels, 2.2× full) in contrasting cloths:

clothhem outfold depthfoldshem level (sd)swing
chiffon14.2 cm2.2160.75+12.2
cotton lawn15.12.4130.85+11.8
linen16.44.171.50+12.2
felt14.35.141.31+14.3

One cloth (cotton lawn) in contrasting constructions:

constructionhem outfold depthfoldsswing
straight (the block, darted)12.21.33+0.5
flared (darts closed, slashed and spread)15.12.413+11.8
gathered (darts released, width added)17.52.213+10.9
pleated15.92.811+12.8
one piece, bias16.03.59+11.0

Building the cutting engine, the bench caught:

Children: paper or dials?

Not yet tested; it can't be tested here. The protocol is unchanged (predict, then try; explain; intention; observe), now as a comparison. Half the children use the paper (the default), half ?ui=dials, with the same skirts and questions.

The hypothesis to test: children who slash, fold and close darts on the paper predict and explain better (naming a construction, not a look) than children who turn dials to the same skirts.

Every garment

testclaimresultdoesn't establish
5 garments752 garments (every neckline × sleeve length × sleeve × collar of a top, a dress and a jumpsuit at both ends of their room and length; trousers' corners; tiered skirts and dresses; 300 at random), 4,308 checks: seams meet as they're meant to (eased, or gathered by as much as meant), pieces cut from curves lie flat, fit across the cloth, clear the body, go on (over the head, past the hand, past the foot)holds: all passmakeability, as test 1; that a sleeve set in this way hangs as a dressmaker's would
6 sewnevery garment the workshop makes sews up on the figure: seams to within 2.5 cm (0.25 on average), finite, nothing inside itholds: all 27that it's sound (6′)
6′ soundthe same garments, by the skirt's bar for "sound" (above)fails: 12 of 27 (every plain skirt; 4 of 5 trousers)how much the stretch under a bodice matters to how it looks or to a child

Under a bodice, under tiers and where gathers crowd the cloth it stretches more: 13–33% at the 99th percentile, seams within 1.1 cm rather than 5 mm. Building the families, the checks caught:

Known limitations

The rails

Fab opens on the workshop's wall: a row of clothes rails, each hung with garments on hangers. The figure itself only turns when it's turned (by a drag, a flick, or a double tap); it doesn't drift round on its own.

Using the rails:

Saving:

Every skirt on a rail is the real thing. Its pattern is drafted from its design, a little coarser than at the bench (about 650 points). It's sewn and let fall from the hanger's two clips, which hold its waistband flat, by the same cloth simulation. Each one settles once, a few at a time, nearest first. After that it hangs still, and only its swing moves it.

The rails live in this browser (localStorage), so a rail is a person on this device: a family's tablet, or a classroom's. Nothing leaves the device. Sharing rails between devices would need storage behind the cell, which this static lab cell doesn't have.

The room

The workshop is one room, closed on all four sides. Each wall faces in and is drawn only from inside, so wherever the view goes, even out past a wall, nothing stands between it and what's in the room.

The light comes in through windows. Tall frosted windows in painted frames, with sills, are set in the back wall (behind the rails, the figure and the cutting table) and the right wall. They glow with the daylight through them. The key light, the one that casts shadows, comes from windows behind the viewer, high and to the left. It falls as those windows' shape, panes and glazing bars and all, with the wall's shade between them. So there are patches of window light across the floor, the rug, the figure and the paper. (windowLight in render.ts: the key light's shadow map times the windows' pattern, laid out across the light's own direction, a window centred on the figure.) The walls and windows cast no shadow of their own, so the light comes in where the windows are.

A little furniture, for context:

The furniture casts shadows and catches the light like everything else.

Three places in one room

The workshop is one room, and the camera walks between three places in it. They're the three buttons along the top (rails · figure · table), and the one you're at is dark. What can be done there sits in a row under them.

placewhereits draweralong the top
the railsalong the wall, to the leftthe rails' name tags; put a skirt on the figure
the figureon its stand, in the middlewhat it is (make: skirt, top, dress, trousers, jumpsuit; tiers), the bodice (neckline, sleeves, collar; length, room, swing) and the legs, when it has them; fabric, print and colourthe tools down the right (hand, pose, tug), each with its own drawer; save to rail
the cutting tableto one side, facing the figurethe tool in hand: what it does, the gestures it answers to, what it's set to; panels, tiers, undo, the history (the tools themselves are a palette down the right). A top's or trousers' whole pattern lies there to be looked at, without toolscloth (an icon), save to rail

The drawer has three states, each the one before with more below it:

Its handle is tactile. The drawer follows a finger on its handle, so what's below comes into view before it's let go, and it gives a little past either end. When it's let go it settles, sliding there: dragged a quarter of the way to the next state it goes there (and on, past each further quarter); flicked, it goes one further the way it was flicked; short of a quarter, it springs back. A tap steps it: closed → focused → expanded → focused. (⚙ by the tabs expands the section in focus, and closes it again.)

The room never moves with it. The drawer lies over the room rather than taking space from it, and each place keeps the bottom of the screen for its drawer whatever state it's in, the scene drawn centred above that by moving the lens. Opening, closing or dragging the drawer doesn't move or resize the scene.

Expanded, a section is made your own. What's changed is kept with the skirt (on its recipe, so it's on the rail with it, and in the link):

At the figure, the Bodice and Legs tabs work the same way: focused, their picks (neck, sleeve, collar; the legs' length, width and shape: shorts · cropped · full, slim · straight · wide, tapered · straight · flared); expanded, their dials, exactly. The notes line over the figure is one line; the whole of it is in the expanded drawer.

as it was puts the section back as its swatch has it, and choosing another swatch starts afresh from that one.

At the figure, a drag on it spins it; a drag off it goes round it. Spinning is the same as from the table: its front follows the finger, and a flick runs down on its own. A pinch, or scrolling, comes close or goes well back.

Every place can be reached by tapping it. From any of the three, tap another where it stands in the room (a rail, the figure, the cutting table) and the camera walks there. It's one list in the code (PLACES in main.ts): each place says how a touch finds it (a box round each rail and what hangs on it; the figure out to its arms and the reach of its skirt; the tabletop), and the nearest one along the touch wins, so whatever's in front hides what's behind it. A tap the place you're at uses itself (a garment on the rails, the paper's piece at the table) is never passed on. A new place in the room is one more entry.

The pattern is pinned up beside the figure, bottom right. It's a little note with the pieces drawn on it, what the skirt is, how long, and how far round its hem is. Tap it, or tap the cutting table itself where it stands in the room, to go to the table. It's redrawn with every change, and stays by the figure.

At the table, the figure's still across the room. Tap it to go over to it. Drag across it to spin it on its stand: its front follows your finger, and a flick runs down on its own.

The paper is plain by default. A piece is drawn as pattern tissue, so its marks (slashes, folds, darts, gathers) stand out. The cloth icon lays the chosen cloth and print on it, running with the grain, as it'll be cut. The note by the figure follows the same choice. (?cloth starts with it on.)

At the table, the pattern lies on it at true size. A centimetre of the paper is a centimetre on the figure, so a piece that's spread grows on the table. The figure stands across the room behind it, wearing each move as it's made.

A touch on the screen is cast down onto the tabletop and lands on the paper. Every gesture works on the paper there, and a fingertip is a fingertip's size wherever the paper is seen from.

The paper shows what the tool in hand can do. The edge it works lights up: the hem for the hand and the scissors, the waist for fold and gather. The hand also gets a tab on the hem to drag, a ring at the foot of the grain arrow to turn it, and a badge on each dart to tap (white while it's sewn, rose once it's flared or gathered). The moment a cut or fold is touched, a dashed ghost shows where it'll go. While a finger's on the paper, a label beside it says how much ("+4.5 cm", "37 cm (+3)", "22°"), and the drawer keeps up with it.

Each move is marked as a dressmaker marks it:

A top, trousers, a dress or a jumpsuit at the table. The pattern is laid out whole; a tap on a piece picks it, and it's drawn alone, larger, its edges lit: a hem to drag longer or shorter (a top's, a sleeve's, a leg's), a side to drag roomier or slimmer, a neck deeper, a hem's corner out to swing or flare it, the grain arrow round to bias. Each is the design's own dial, so the figure wears it as it's dragged, and the amount is by the finger. The drawer says what's picked; expanded, it lists each edge and what it does, each value with a step either way, and the piece's own choices as words (a front's neck, collar and sleeves; a sleeve's head; a tier's count). A tap on the paper round it, or anywhere off it, is the whole pattern again. A dress's skirt panel tapped is the skirt's paper, with its tools.

Only the piece takes the tools. A touch on the pattern (or within a fingertip of its edge) cuts, folds, gathers or pulls. A touch anywhere else (empty paper, the tabletop, the room) moves the eye:

It goes further than over the piece both ways: down close to the paper (to a third of the distance), and back past the figure to see the room round it.

The room's walls are one-sided (see The room).

Looking past halfway, the paper is just part of the view, and a touch on it moves the eye too. Come back down to cut.

The paper stays where it was laid. The piece is only moved, and the sheet re-cut, when it no longer fits on its sheet or has shrunk into a corner of it. That never happens while a finger is on it. The camera follows the piece smoothly, so nothing jumps between one gesture and the next.

Using it

Before a deploy

node cells/lab/devtools/fab-smoke.mjs opens each family at the figure (in frame above the drawer, nothing thrown), the cutting table (the piece in frame, a hem drag that lengthens it; a top's and trousers' hems dragged and slashed), and the rails (a garment in front), and fails on anything wrong. Run it, and node cells/lab/devtools/fab.test.mjs --quick, before every deploy: two sessions deploy this cell, and a regression shipped once that this would have caught.

How it's built

The pictures are made, not taken. Every one in this page is made by driving the page as a child would, and the whole set is made again with one command: node cells/lab/views.mjs fab (name some, or a group, to make only those; --list for what's registered). Each view is registered in client/fab/views.mjs: a name, a group, a title and caption, the page's query, and the steps that drive it (pick up a tool, touch the hem, drag), the shot taken at the right moment, often with the finger still down. They're static/fab/v-<name>.jpg, committed and deployed with the page. The whole set is under pictures at the top of this page, apart from the prose (and static/fab/views.md on GitHub); here, a view goes where it's talked about.

All of it is in client/fab/:

filewhat it does
garment.tsevery garment from one design: its family, its components, how they're sewn together, the shared checks
edges.tsthe geometry: lines, arcs, Béziers (chord-relative), Coons-patch pieces, sewing runs by length
shared.tswhat every garment's cut shares: the figure measured, waistbands, holds, hangers, the shared checks
bodice.tstops: bodice, necklines, sleeves, collars
trousers.tstrousers
cut.tsthe cutting table: the block, and the moves made on it
pattern.tsfrom a recipe (block + moves) to what's sewn and held, and the pattern's checks; the dials' shortcuts
paper.tsthe paper on the cutting table: its sheet, tools and gestures
fabric.tsthe swatches
cloth.tsthe XPBD cloth
body.tsthe figure and its distance field
render.tsWebGL2, shadow-mapped, the print laid on the flat pieces along the grain
sheet.tsthe pattern, drawn as a dressmaker would
rails.tsthe rails: the carousel, the swing, hanging skirts settled on their hangers
store.tsthe rails kept in this browser, and the workshop's own skirts
evidence.tsthe evidence bench

URL parameters

parametervalues
famskirt, top, dress, trousers or jumpsuit
lena skirt's length, cm
mthe moves, e.g. c0_s500.150_p250.15 (close dart 0; spread at 0.5 of the hem by 15.0 cm; pleat at 0.25 of the waist, 1.5 cm deep)
full, cutan older link's fullness and flare, gather or pleat: written as moves
uidials: the dials instead of the paper
attable: start at the cutting table
perfthe frame readout
panelsnumber of panels
graindegrees
tiers1–3
blen, ease, swinga top's length below the waist, its room round the chest (cm), its swing
neck, ndepthround, v, square, boat or scoop; cm lower (or higher, below 0)
slen, sleevesleeve length (cm; 0 sleeveless); plain, puff or bell
collarnone, peterpan, band or frill
llen, lwidth, flaretrousers' leg below the crotch (cm), room (1–2), hem over knee (0.8–1.8)
fabricchiffon, satin, lawn, jersey, linen, flannel, organza or felt
print0–5
colour0–4
settleframes run before the first draw
twirlspin the figure on load
sheetopen the pattern on load
previewno controls
railsstart at the rails (a design in the query starts at the bench)
warmsettle the rails' skirts before the first frame
benchevidence opens the evidence bench

Sources

Every picture (40)

The room

The drawer

What can be made

The hand

Slash

Fold

Gather

Cloth