Computationally Yours · Handbook
Handbook · 08 · Week 2 clinics · Srishti Manipal Interim 2026

Six ways to make rules

The computational techniques behind the Week 2 clinics. Each comes with a small live sketch, its parameters, what it's good for, and the look you'll need to get past.

seed techniques · depth 6
Clinics
Days 6–7 · 30 Nov – 1 Dec
Techniques
Six
Each has
A live sketch
You choose
One, or two together
Recorded in
System worksheet, C
—

How to choose

Start from your metaphor, not from a look you like. The technique should do what the identity believes.

If your metaphor is about…Try
drift, current, weather, erosion, wind, the movement of water01 Noise and flow fields
growth, branching, lineage, bureaucracy, things inside things02 Recursion and L-systems
crowds, migration, foraging, labour, many small decisions03 Agents and simulation
spread, contagion, settlement, rumour, neighbours shaping neighbours04 Cellular automata
records, measurement, evidence, what was counted and what wasn't05 Data as material
order, the grid, property, the survey, rules breaking down06 Geometry and tiling

The sketches below are small on purpose: a few dozen lines each. Change the slider, press New seed, and watch which parts stay the same. Those are the rules. New to how computers draw? Start with Foundations.

01

Noise and flow fields

Smooth randomness: values that change gradually across space, so neighbouring points agree. Turn those values into directions and you have a field that lines can follow.

How it works

  1. Make a noise field over the page.
  2. At each point, read the noise as an angle.
  3. Drop particles and move each a short step along its angle, again and again.
  4. Draw the path each particle leaves.

Parameters

scale
how quickly the field changes
count
how many lines
steps
how long each line runs
step
how far each move goes

Good for

Anything that moves continuously: water, air, sediment, crowds at a distance, a slow change over time.

The default to avoid

Evenly spaced, smooth hair-like curves in a pastel palette. Let data, a boundary or a rule from the manifesto shape the field.

PlotNatural fit: every line is a pen stroke. Limit overlap or the paper soaks.
ResinSweep lines into tubes, or use the field as a height map.
PrintFine for dense, layered fields with tone that a pen can't give.

Look at: Tyler Hobbs's essay on flow fields; Manolo Gamboa Naon; Ken Perlin's original noise (1985).

Codex · collaborator
You're my collaborator. Read system.md. Build the smallest flow-field sketch that follows my rules: a seeded noise field, particles that move along it, and lines exported as SVG. Every value in one config. Explain each step before you write it.
02

Recursion and L-systems

A rule that applies to its own result. Rewrite a short string of symbols a few times, then read it as drawing instructions, and branching structures grow.

How it works

  1. Start with a short string, the axiom.
  2. Replace every symbol by its rule, all at once. Repeat for each generation.
  3. Read the result: F draws forward, + and − turn, [ and ] save and return to a position.

Parameters

rules
what each symbol becomes
generations
how many rewrites
angle
how sharply it turns
length
how far F moves, and how it shrinks

Good for

Growth and inheritance: plants, rivers, family trees, institutions that copy themselves, a document that cites a document.

The default to avoid

The textbook fern or tree. Write rules from your identity's condition, and decide what happens when growth is blocked.

PlotExcellent: clean strokes, and depth shows in line weight or pen.
ResinBranches become printable forms if you give them thickness.
PrintWorks; consider whether the line needs the pen.

Look at: Aristid Lindenmayer, who devised L-systems (1968); Prusinkiewicz and Lindenmayer, The Algorithmic Beauty of Plants (1990).

Codex · collaborator
You're my collaborator. Read system.md. Build a minimal L-system: an axiom, rules I define in the config, a turtle that draws them, and SVG export. Keep randomness seeded and optional. Show me the rewritten string for the first two generations so I can check it by hand.
03

Agents and simulation

Many small actors, each following simple local rules. No one draws the whole picture; it emerges from their decisions.

How it works

  1. Place agents, each with a position and a heading.
  2. Every step, each agent looks around and decides: turn, slow down, follow, avoid.
  3. Move them all, and record the trails.

Parameters

count
how many agents
turn
how freely they change direction
sense
how far they look
rules
what attracts or repels them

Good for

Behaviour: migration, work, foraging, traffic, people moving through a city, or anything shaped by many decisions.

The default to avoid

Flocking "boids" with nothing at stake. Give the agents a reason to move that comes from the condition: water, a wage, a border.

PlotTrails plot well; cap the number of steps so lines don't pile up.
ResinStack trails over time as layers to make a form.
PrintGood for density maps and many thousands of agents.

Look at: Craig Reynolds's Boids (1986); Casey Reas's Process series.

Codex · collaborator
You're my collaborator. Read system.md. Build a minimal agent simulation: agents with a position and heading, one rule at a time from my list, trails recorded and exported as SVG. Seeded. Start with one agent so I can see a single trail, then scale up.
04

Cellular automata

A grid of cells, each on or off. At every step a cell changes according to its neighbours. Simple rules can make order, chaos or something between.

How it works

  1. Start with a row of cells, some on.
  2. For each cell, look at it and its two neighbours: eight possible patterns.
  3. The rule says which patterns turn the cell on in the next row.
  4. Draw each new row under the last.

Parameters

rule
which of the 256 rules
start
one cell, or a random row
size
cell size and grid width
steps
how many generations

Good for

Spread and neighbourhood: settlement, infection, rumour, land use, a decision that passes from house to house.

The default to avoid

Rule 30 or the Game of Life shown for their own sake. Seed the grid from real data, or let the identity's rules decide what a neighbour is.

PlotCells become hatched squares or marks; plot time grows with cell count.
ResinEach generation becomes a layer: the automaton grows a solid.
PrintNatural for large grids and fine cells.

Look at: John Conway's Game of Life (1970); Stephen Wolfram's elementary automata, including Rule 30 (1983).

Codex · collaborator
You're my collaborator. Read system.md. Build a minimal one-dimensional cellular automaton: a rule number and starting row in the config, each generation drawn below the last, SVG export. Then show me how to start it from a row of real data instead of random cells.
05

Data as material

Real records from the condition drive the form. The choices are what to measure, how to map a value to a mark, and what the mapping leaves out.

The values here are illustrative, generated from the seed. In your work, use real records and cite them.

How it works

  1. Find and clean the records: one row per thing measured.
  2. Choose which column drives which visual quality: length, weight, spacing, angle, density.
  3. Decide the mapping: straight, squared, inverted, stepped.
  4. Draw, then label the source.

Parameters

range
which years, places or rows
mapping
how a value becomes a mark
emphasis
how strongly differences show
gaps
how missing values are drawn

Good for

Evidence and testimony: anything your identity measures, counts, or knows has gone uncounted.

The default to avoid

A chart with the axes taken off. Make the mapping a position: say why this quality, and draw what's missing as well as what's there.

PlotStrong: repeated passes or pen weight make quantity physical.
ResinValues become heights, thicknesses or a stacked form you can hold.
PrintBest for many fine values and tone.

Look at: Giorgia Lupi and Stefanie Posavec, Dear Data; Ryoji Ikeda's data works.

Codex · collaborator
You're my collaborator. Read system.md and data/[file]. First, describe the data back to me: columns, ranges, missing values. Don't draw anything yet. Then build a minimal sketch that maps [column] to [visual quality] using the mapping in my config, and draws missing values in a way I choose.
06

Geometry and tiling

Grids, subdivisions and repeated shapes, and the rules for how they bend. The handbook's own Mondrian mark is one: a rectangle split again and again.

How it works

  1. Lay down a structure: a grid, a tiling, a subdivision.
  2. Decide what each cell holds.
  3. Add a rule that changes cells by position, time or data.
  4. Draw, keeping the structure visible.

Parameters

cells
rows and columns
split
how cells divide
disorder
how far each cell may move
gradient
where the rule is strongest

Good for

Order and its failure: property, planning, the survey grid, bureaucracy, a system breaking down at its edges.

The default to avoid

Decorative pattern. The grid should mean something: whose order is it, and where does it give way?

PlotThe classic plotter subject; crisp and fast to draw.
ResinExtrude cells to different heights for relief.
PrintGood where fills and colour carry meaning.

Look at: Georg Nees, Schotter (1968), which this sketch nods to; Vera Molnár; Manfred Mohr; Sol LeWitt's wall drawings.

Codex · collaborator
You're my collaborator. Read system.md. Build a minimal grid sketch: rows and columns in the config, one rule that changes each cell by its position, seeded randomness, SVG export. Then add a second rule from my list, and show me the two side by side.
—

Combining

Two techniques can work together when each does a different job, such as a grid for order and data for what fills it. More than two usually means the rules aren't settled yet.

Record your choice and your reasons in the system worksheet, Part C, and use the researcher prompts to find more on your technique.