R&D LAB Computational Design Shipped Drawing instrument
Patient Art
Pattern studio, four hundred and eighty families, one file
480 pattern families across 28 categories, each parametric, each reproducible per seed, each drawn stroke by stroke in front of you.
- 480pattern families
- 28categories
- 9sheet shapes
- 1file, no dependencies
Category Hand, family Ridges, from an empty sheet to a full field. The sheet is made in real time: drawing time is a slider, pause holds it, and what gets exported is exactly what is on screen.
Why this is published
Four hundred and eighty generators in one file, all sharing a renderer, a palette layer and a mask, is not an art project: it is the evidence that we can build a large parametric family so that an addition does not break it and a correction applies everywhere at once. A product configurator, a facade grid or a nesting problem asks for exactly that.
Most generative tools hand you a finished picture. Patient Art hands you the drawing: every sheet is built as a sequence of individual strokes, over whatever time you give it, and can be stopped halfway and exported exactly as it stands at that moment. Behind it are four hundred and eighty generators, one shared renderer, a mask system that cuts any family into any shape, and a single HTML file with no dependencies, no build and no network.
The contact sheet
Every tile is drawn exactly once and afterwards only shown or hidden. Filtering and searching therefore recompute nothing, and a tile is painted only when an observer sees it enter the visible area.
The tiles deliberately ignore sheet shape, ink routing and the shape effect. The library is meant to stay a neutral index of the families rather than a picture of the current colour state, otherwise nothing in it would be comparable.
Patience
Time is a constraint, not an effect
The name is meant literally. A sheet is not output, it is drawn: over the time the slider gives it, stroke by stroke, in the order a hand would take. Stop it and you watch a field come into being instead of only receiving its result.
This is not an animation played in front of a finished picture. A family returns no graphic at all. It returns strokes: lists of points with a colour index. The renderer decides how many of them have fallen by this instant. That is why the export has a scope: whole sheet finishes the drawing and exports the finished sheet, as drawn exports exactly the strokes that are there now. A half-finished sheet is a result, not an intermediate state. Both paths give PNG or SVG, and the SVG carries paths rather than embedded images.
The constraint reaches down into the mark-making. The renderer carries one pen weight per stroke and nothing more. A line whose weight, opacity or ink changes along its length therefore has to be many short strokes. That is precisely what the families that draw the hand rather than a motif hang on: ink flow, nib split, pen pressure, tremor, fatigue, metronome.
And it forces frugality. A slider at its maximum has already produced a division by zero in this program and killed the tab, which is why every count derived from a divisible parameter now runs through one shared counting function with a cap. Two families with cost outliers at extreme parameters were bounded at the source rather than hidden in the interface: one with a fixed spiral budget, one with a ceiling on recursive growth.
To watch something come into being, the data has to be built so that there is an order at all.
One mask, four hundred and eighty families
The mask sits on the finished stroke data, not on the picture. Dots that fall outside are dropped, lines are cut into the sections that lie inside. No family writes a line for it, and the shape still applies to all of them.
The buffer holds not one bit but a value from 0 to 255. That is why clipping is only one of ten effects: the same shape can drive pen weight, opacity, density or ink, it can displace strokes, and with feathering a hard silhouette becomes a gradient. Tiling stamps it as a grid, which turns any silhouette into a motif.
The sheet shape is a different thing and stays a hard cut in the same pass: nine shapes, analytic as a predicate, an edge and a path rather than a bitmap. That is why the edge survives into the SVG export, and why the plate's shadow follows the alpha instead of a rectangle.
One renderer, very different intentions
Five families from three categories
Hand: scriptWriting with no language left in it. The parameters are line height, glyph width, word length and the ragged right edge.
Hand: samplerA grid of motifs, each stitched on its own. The same category as the ridgelines, and with them one of 52 Hand families: an entirely different hand, the same renderer.
Tiling: quasicrystalA tiling that never repeats and still closes everywhere. It comes out of a rule, not out of a tile template.
Tiling: ApollonianCircles falling into the gaps left by their own predecessors, on a round sheet. The sheet shape is a predicate, not a bitmap.
Code: hexdumpTwenty families in the Code category set text as pattern. Up close you read addresses and bytes, from a distance it is texture, and both are intended.
Text, set as pattern
The twenty families in the Code category set something written: a hexdump, a terminal, a commit graph, a syntax tree, a test report. Up close it reads, from a distance it is texture.
While it is being drawn this shows more clearly than in the finished sheet, because one line falls after another, the way a terminal would emit them. It is the same mechanism as a tendril pattern, except that here the strokes are letters.
How a sheet is made
Strokes at the centre, everything else is a layer on top
- Familyone of 480
- Parametersits own language per family
- Seedsame value, same sheet
- Mask and shapea predicate, not a bitmap
- Palette37, one of them your own
- Progressive drawingtime as a slider
- ExportPNG or SVG, whole or as drawn
Because what sits at the centre is stroke data and not a picture, every layer applies to all four hundred and eighty families. The mask needs to know nothing about patterns, the export nothing about families, and a new family needs to know nothing about any of the layers.
What the rule delivers, and what it does not
Generated
- Four hundred and eighty families out of one shared core: a new one inherits paper grain, hand wobble, pen weight, palettes, sheet format, sheet shape, masking, progressive drawing and export, without a line written for any of it.
- Family, parameters and seed determine the sheet completely. The same seed gives the same sheet, and the seed is in the address.
- A correction to one layer takes effect in all four hundred and eighty sheets at once.
- A check run drives every family with no browser and no canvas: 1,459 runs, 0 malformed geometry, 0 invalid colour indices.
Decided by hand
- No judgement. The project keeps an open list of families that are visually weak at their defaults, and that list is maintained by hand.
- No fidelity to a source. A family draws in the spirit of its name, and whether it matches a tradition or a construction has not been checked by anybody.
- No selection. Which five of four hundred and eighty sheets appear on this page is an editorial decision, not an output of the program.
- No randomness standing in for intent. The seed button produces variants, and which of them is any good is still decided by somebody looking at them.
A closer look
Where this fits
- Configurators where hundreds of variants have to come out of one shared core and a correction has to apply everywhere.
- Facades, textiles, packaging and surfaces that should exist as a rule rather than as a file.
- Anything that will actually be plotted or cut afterwards: the SVG export is paths, not embedded images.
- Tools that have to run on a machine with no installation, no network and no approval process.
Image credits: every image on this page is a screen capture of our own application, taken on 5 September 2026 through a capture harness inside the project itself. No third-party imagery appears in any of them.
Why this is published
What this means for your project
More from the lab
Method Event Scout A language model reads the event pages; everything else is fixed code. What remains is a short list of where a day in person is worth it. 
Applied Research Vellum Edges, perspective, light and text are all worked out on the phone. A document leaves the device only when someone sends it. 
Computational Design Atlas EV1 Twelve chapters take an electric car apart, down to a single cell. No model files, no textures: 327 parts generated from one dimension table. Need hundreds of variants out of one rule rather than hundreds of files? We can build that.
Get in touch