#### <sup>[Ollin](../index.md) → Documentation</sup>

---

## Ollin API

This is the reference for Ollin's drawing surface and helpers. The bare calls you write in `draw()` forward to an internal `Drawer` (see [How it works](../about.md#how-it-works)). Everything on these pages is callable bare inside a `Sketch`.

The [Ollin quick reference](quickreference.md) is the whole framework in one read: how a sketch runs, what the calls are called, the units they take, the command line, and the mistakes that fail with no error. If you are new to Swift, start with the [Swift quick reference](swift.md). It covers just enough of the language to be productive in `draw()`. If you come from p5.js or Processing, [Appendix C of the Guide](../guide/c-comingfromp5.md) maps the API you already know onto Ollin. [Appendix E](../guide/e-comingfromopenframeworksandopenrndr.md) does the same for openFrameworks and OPENRNDR.

### The catalog

Everything below ships in this repository, listed by what it is for. Each row links to the reference page for its area, and the two largest areas are listed in full under the table. The groups after it list every page by area, with one line on each.

| Area | What's in it |
| --- | --- |
| [**Shapes & geometry**](drawing/drawing.md) | About thirty analytic shapes, from circles to stars to hearts, curved paths, concave and holed fills, variable-width strokes that taper and turn like a pen nib, [marks](drawing/marks.md) whose width and opacity follow how fast and how hard you drew them, [booleans and offsets](drawing/geometry.md#shape-booleans), [outlines you can ask questions of](drawing/geometry.md#contour-questions) (the nearest point, the way a line runs there, where two lines cross, a lighter copy of a dense trace, rounded or cut corners), [segments, arcs, and ellipses as values](drawing/geometry.md#plane-curves) that know where they cross one another, [spatial queries](drawing/spatialindex.md) over a point set (which point is nearest, which points are within a distance, which points are inside a box), [fitting](drawing/fitting.md) a smooth field through values known at a few scattered points (and the warp that fit makes), or fitting a few parameters to a target, [gradient paint](drawing/color.md#gradient) and [a shader as paint](drawing/color.md#shader-paint) on every shape, blend modes, clipping, [SVG import](drawing/svg.md), `noClear()` [accumulation](drawing/accumulation.md) for long-exposure looks plus an `Accumulator` whose running mean converges, [depth of field from light](drawing/depthoffield.md) (lines drawn as millions of scattered points through a lens), and [retained batches](drawing/batches.md) for when static content gets heavy |
| [**Text & color**](drawing/text.md) | Bitmap, outline, and single-line plotter fonts through one `drawText`, text in [any script](drawing/text.md#scripts) (right-to-left, Devanagari, Thai, Japanese, emoji), set [down the page in columns](drawing/text.md#vertical) as well as across it, [justified](drawing/text.md#justify) to a measure with its [punctuation hung](drawing/text.md#hanging) outside the margin, run [along a path](drawing/text.md#onpath), moved along a [variable font's](drawing/text.md#variable) own axes, or taken as vector `Shape`s that also [extrude into 3D solids](3d/3d.md#solid-type). For color: [OKLab mixing](drawing/color.md), [spectral color and paint mixing](drawing/spectrum.md) (pigments that mix to green, thin-film and diffraction filters), palette import and extraction, colormaps, gradients, [color vision simulation](helpers/accessibility.md) so you can see a palette as a colorblind person does, `describe` so a sketch can tell a screen reader what it shows, [wide-gamut and HDR output](drawing/coloroutput.md) (Display P3 on screen, highlights brighter than white, HDR10 video, and stills that keep those highlights in a gain map), and [images](drawing/images.md) with pixel access, twenty bundled [sample photographs](drawing/samplephotos.md) to try things on, dithering, [pixel sorting](drawing/pixelsorting.md), [seam carving](drawing/seamcarving.md), [halftone screens](drawing/halftone.md), [glyph mosaics](drawing/glyphmosaic.md), [photo mosaics](drawing/photomosaic.md), and [autostereograms](drawing/autostereogram.md) |
| [**Shapes that merge**](drawing/combinators.md) | SDF combinators: smooth union, subtract, morph, machined joints, carpentry detailing, and domain mirror/tile/radial, reached through `drawSDF`, a scoped `smoothUnion { }` block, or the clay-like `sculpt { }` block. They work in 2D and in raymarched 3D, where the same fields can also twist, bend, and take surface displacement |
| [**Generative technique**](generators/index.md) | Seventy-three techniques, [listed in full below](#generative-technique). They cover scatter and sampling, growth, rules and agents, grids and tilings and ornament, chaos and fractals, curves and figures, one-line renderings, fields and level sets, meshes and surfaces, and texture and terrain |
| [**Layered effects**](drawing/effects.md) | Off-screen layers with more than fifty GPU filters, two-layer combines (mask, displace, seamless clone, depth of field, ambient occlusion, screen-space reflections), diffusion curves, feedback layers, and GPU simulation fields. One of the filters is [post-process anti-aliasing](drawing/effects.md#filter), which smooths the stair-step edges of a layer that a shader wrote, because such a layer carries no coverage of its own. Another applies [a look from a `.cube` file](drawing/looks.md), the table a grading tool exports. Two more give a frame the texture of film, [halation and grain](drawing/effects.md#filter). Six give a layer [an edge of its own](drawing/layerstyles.md): an outline, a drop or inner shadow, an outer or inner glow, or a bevel. [A caption or a readout](drawing/effects.md#withoverlay) drawn over the finished frame stays sharp whatever the frame's passes do under it. All of them can be declared as one `compose { }` block |
| [**Measured distance fields**](drawing/distancefields.md) | Measure a distance field from any drawn layer: how far each pixel is from the nearest edge, and in which direction. Read it back as contour bands, as shapes grown or shrunk by a distance, as outlines at any offset, or as a Voronoi diagram built from the picture itself |
| [**Light in a flat sketch**](drawing/light.md) | Draw a scene in one layer and the lights in another, and Ollin computes the light that reaches every pixel. That gives you shadows that are sharp at the shape and soften with distance, falloff, beams through a gap, and color from a red wall spilling onto the floor beside it, without drawing any of it by hand |
| [**The frequency domain**](drawing/fourier.md) | Read a picture on the GPU as a sum of waves instead of a grid of pixels. Filtering by *scale* then becomes a shape drawn over the spectrum. If you keep the middle, the picture comes back soft. If you keep the outside, only its edges come back. A whole field can also be built from nothing but a description of its energy, which is how [the ocean](3d/ocean.md) is made |
| [**Local averages**](drawing/localaverages.md) | The average of the square around every pixel, at a cost that does not depend on the square's size, over a summed-area table. That gives a box blur whose cost does not grow with its radius, and an adaptive threshold that cuts a picture to two tones by comparing each pixel with its own surroundings, so a page lit from one side is still readable |
| [**Your own shaders**](shaders/shaders.md) | Write a `shade(uv, info)` fragment function inline or in a `.metal` file that hot-reloads. Compile errors are reported at your own line numbers, and a [built-in helper library](shaders/shaderlibrary.md) is spliced in. The same shader is [paint](drawing/color.md#shader-paint): `fill(shader)` runs it per pixel inside any shape, in the shape's own coordinates. Or skip Metal and chain instead: [`Visual`](shaders/visuals.md) composes oscillators, noise, shapes, and layers through warps, blends, and modulations, and runs them in one GPU pass however deep the chain grows. If you already have a GLSL shader, [`ollin new --from-shader`](tools/shaderimport.md) translates it to Metal and writes the project around it. A shader can [pull in another file](shaders/shaders.md#pulling-in-another-file), and [`ollin check`](tools/shadercheck.md) compiles one on the GPU from the command line and reports what it found The library's `complex` module gives a `float2` the arithmetic of a complex number, mirrored on the CPU by [`Complex`](helpers/complex.md). |
| [**GPU compute**](shaders/compute.md) | A million particles updated and drawn each frame without touching the CPU, a cooperative neighbor-search primitive that [artificial life](simulation/artificiallife.md) and SPH fluids are built on, and ping-pong texture simulations drawn as images |
| [**Simulation & physics**](simulation/physics.md) | A stepped `World` with Verlet particles and springs for soft bodies, and with Box2D bodies and joints for rigid ones, [3D rigid bodies](simulation/physics3d.md) that stack, tumble, and swing inside the 3D scene (backed by Jolt, with compound bodies, heightfield-terrain and `Scene` colliders, motored and limited joints, contacts and sensors, walking characters, driveable vehicles, ragdolls built from a skinned figure, soft-body cloth and pressurized shapes, ropes where every segment carries an orientation, [tensegrities](generators/tensegrity.md) that stand on their own cables, buoyancy and swell, ray/sweep/overlap queries, collision groups, and mouse grabbing), plus [SPH fluids and soft bodies](simulation/fluids.md), [steering crowds at GPU scale](simulation/swarm.md), [crowds that make room for each other](simulation/crowds.md) and never walk through a wall, [a million particles moving along a strange attractor](drawing/attractors.md#flow), [populations that evolve](simulation/evolution.md) toward a target or by your own choice, [matter that organizes itself and rules that spread by contact](simulation/artificiallife.md), reaction-diffusion, Lenia, Game of Life, water-surface ripples, multi-scale Turing patterns, the Abelian sandpile, real-time fluid, a [wet-paint watercolor wash](simulation/watercolor.md) with real pigments and optical glazing on the GPU, [articulated and chaotic motion](simulation/motion.md) for IK chains, pendulums, and n-body gravity, and [coupled oscillators](simulation/oscillators.md) that fall into step |
| [**3D**](3d/index.md) (opt-in) | Cameras and whole imported scenes, [lines between points in space](3d/lines.md), [solids drawn in ink along their edges](3d/hiddenlines.md), geometry drawn at scale (instanced meshes, GPU-culled worlds, half a million blades of grass, an ocean), physically based materials and the full map set, area lights and image-based lighting, ray-traced reflections, caustics, and global illumination, and effects on the frame itself: anti-aliasing over time, depth of field through the camera's lens, motion blur, lens flare, and atmosphere. A scene can also be written down as [line work a plotter can follow](3d/linedrawing.md) rather than drawn as a picture. [Listed in full below](#the-3d-layer). A 2D sketch never pays any cost for it |
| [**Perception**](vision/vision.md) | Nineteen on-device trackers that run over the Mac's camera or any [video](video/video.md): face, hand, and body pose in 2D and 3D, segmentation (automatic or from a click), contours, optical flow, OCR, saliency, typed phrases scored against the picture, depth from a video model that holds still between frames, and custom Core ML models. An [iPhone](3d/phone.md) adds LiDAR depth clouds, the reconstructed room as a labeled surface with its flat planes, the room's own light, ARKit body and face capture, hand skeletons and readable text placed in metric 3D, the pictures and objects it recognizes, how its own picture is moving as a flow field, device motion, and the phone itself held as a pointer you aim at your sketch. All of that arrives over USB, live or from [recorded clips](3d/record3d.md), as metric [RGBD frames](3d/rgbd.md) |
| [**Data as material**](helpers/data.md) | `loadTable` reads a CSV or TSV file, with typed reads by column name. `loadJSON` reads a document you walk through by name and index. [SVG import](drawing/svg.md) brings in vector artwork. A [live feed](helpers/livedata.md) reads one address again and again in the background, so a sketch can draw what is true right now. A [weather](helpers/weather.md) reads the sky over a place in plain units and puts the sun where the clock says. All of them let a file or the world drive a drawing instead of hard-coded numbers |
| [**Sound**](helpers/audio.md) | FFT analysis with band and beat detection and [the note being sung](helpers/audio.md#pitch) (its pitch, its name and cents, the twelve pitch classes), [listening](helpers/listening.md) for words and for named sounds (speech as a live caption, a clap or a bark as a trigger), and a [synthesizer](helpers/synthesis.md) that the sketch itself plays. The synthesizer has voice presets over a shaped and filtered oscillator, [physical models](helpers/synthesis.md#physical-models) of a plucked string, a struck shape, a bowed string, and a blown tube, [sampled instruments](helpers/synthesis.md#sampled-instruments), a [room of your own](helpers/synthesis.md#a-room-of-your-own) as a convolution reverb, a [wavetable](helpers/synthesis.md#wavetables) that a note reads by position and moves through as it sounds, [grains](helpers/synthesis.md#grains) cut out of a sound and piled back up, so a moment can be held and dragged through while the note keeps going, an instrument [patched together](helpers/synthesis.md#patch) from parts instead of picked from a list, an [effects chain](helpers/synthesis.md#effects) on the way out, and a [place in the 3D scene](helpers/synthesis.md#placing-a-sound) for a sound to come from. All of that sound is carried into an exported video with no recording step. [Algorithmic composition](helpers/composition.md) works out what to play (Euclidean rhythms, scales and chords, arpeggios, Markov sequences, a [step sequencer](helpers/composition.md#stepsequencer) with swing and an [arpeggiator](helpers/composition.md#arpeggiator) over held notes), and [sonification](helpers/sonification.md) plays a table column or a terrain profile as notes. A piece travels in and out as a [MIDI file](helpers/midifiles.md), read into notes a sketch plays or draws and written back out, so a phrase a sketch worked out opens in a sequencer |
| [**Control surfaces**](integration/index.md) | [MIDI](integration/midi.md) and [OSC](integration/osc.md) in and out, bindable to `@Param` properties; the parameters published as an [OSCQuery](integration/oscquery.md) namespace a control app browses and builds its own controls from; a [tangible surface](integration/tuio.md) of touches, tagged pieces, and shapes read from a marker table or a touch wall; [game controllers](integration/controller.md) read in `draw()` (sticks, triggers, buttons, and motion and a touchpad where the hardware has them, with several players at once); a [serial port](integration/serial.md) for the classic microcontroller loop (sensor lines read in `draw()` or bound to parameters, lines written back to drive servos and LEDs, with reconnection built in); the same loop [without the wire](integration/bluetooth.md) over Bluetooth Low Energy (a heart rate strap, a weather sensor, a board of your own, plus every device in range drawn by signal strength); a [remote surface](integration/remote.md) that serves the sketch's `@Param` properties to a phone on the same Wi-Fi as touch controls; tempo sync so a set runs on the DJ's clock, over MIDI clock or a [network tempo session](integration/link.md) shared with every Link-enabled app in the room; and the [message bus a building speaks](integration/mqtt.md), so a sketch reads the sensors in a house and drives the lamps and machines on the same bus |
| [**Plays in your rig**](integration/index.md) | [Syphon](integration/syphon.md) out and in, a system-wide [virtual camera](integration/virtualcamera.md) that any webcam app can read, [screen and window capture](integration/screencapture.md) that takes any app on the Mac as live material whether or not that app cooperates, [DMX lighting](integration/dmx.md) driven from `draw()` over Art-Net or sACN (and a lighting console can drive the sketch back), [LED strips and matrices](integration/dmx.md#ledmap) lit from the canvas's own pixels, sampled on the GPU each frame, [show lasers](integration/laser.md) drawn from `draw()` as an optimized point stream sent to a network DAC or written to an ILDA file, [video playback](video/video.md) as live GPU textures, [slit-scan time displacement](video/slitscan.md) over any frame history, [haptics](integration/haptics.md) so a sketch can also play a designed pattern of taps and hums under the hand, and a [room](integration/room.md) that several machines join by name alone, with no server, so they draw one work on one clock with one seat each |

#### Generative technique

Each one has its own reference page.

- **Scatter & sampling:** [Voronoi and Delaunay](drawing/voronoi.md) (plus weighted power diagrams), [breaking a shape or a solid into pieces](generators/fracture.md), [Poisson-disk scatter](generators/bluenoise.md), [low-discrepancy sampling](generators/lowdiscrepancy.md), [points scattered over a mesh surface](generators/surfacesampling.md), [circle](generators/packing.md), [shape](generators/shapepacking.md), and [rectangle packing](generators/rectanglepacking.md), [stippling](generators/stippling.md)
- **Growth:** [L-systems](generators/lsystem.md) (symbolic and parametric), [shape grammars](generators/shapegrammar.md) (ice-ray lattices, building fronts, nested figures), [differential growth](generators/differentialgrowth.md), [space colonization](generators/spacecolonization.md), [diffusion-limited aggregation](generators/diffusionlimitedaggregation.md), [dielectric breakdown](generators/dielectricbreakdown.md), [crack growth](generators/crackgrowth.md), [meander migration](generators/meander.md)
- **Rules & agents:** [Wave Function Collapse](generators/wavefunctioncollapse.md) (from declared tiles or learned from an example picture), [flow fields](generators/flowfield.md), [boids](generators/boids.md) and [steering](generators/steering.md), [pursuit curves](generators/pursuit.md), [force-directed graph layout](generators/forcelayout.md), [random walks](generators/walks.md)
- **Grids, tilings & ornament:** [Truchet](drawing/truchet.md), [hitomezashi stitching](drawing/hitomezashi.md), [mazes of diagonals](drawing/tenprint.md), [the Ulam spiral](generators/ulamspiral.md), [Ford circles](generators/fordcircles.md), [de Bruijn sequences](generators/debruijn.md), [kolam and sona](drawing/kolam.md), [Celtic knotwork](drawing/knotwork.md), [crease patterns](drawing/creasepattern.md) (the Miura fold and rotating-squares kirigami), [polyominoes](generators/polyominoes.md) (the pentomino set and an exact-cover fit), [hex and triangle grids](drawing/tiling.md), subdivision, mazes, the Apollonian gasket, [aperiodic tilings](drawing/aperiodictilings.md) (Penrose, Wang, girih star patterns, the spectre), [hyperbolic tilings](drawing/hyperbolictiling.md) (any {p,q} in the Poincaré disk), [parquet deformations](drawing/parquetdeformation.md) (a tiling whose tile changes shape as you read across it)
- **Chaos & fractals:** [strange attractors](drawing/attractors.md), [billiards](generators/billiards.md) (a ball bouncing in a circle, ellipse, polygon, or stadium), [chaotic maps and bifurcation diagrams](generators/bifurcation.md), [fractals](generators/fractals.md) (IFS, flames, inversion and Kleinian limit sets), [cellular automata](generators/cellularautomata.md)
- **Curves & figures:** [classic curves](drawing/curves.md) (including spirolaterals), [a turtle you drive](generators/turtle.md), [envelopes and caustics](drawing/envelopes.md), [clothoids](drawing/clothoid.md) (the Euler spiral, easements, and corners a vehicle could take), [anamorphosis](drawing/anamorphosis.md) (a flat plate that only looks right reflected in a mirrored cylinder), [Fourier epicycles](drawing/epicycles.md), [shape morphing](drawing/morphing.md)
- **One-line renderings:** [single-line TSP renderings](generators/singleline.md), [points sorted along a Hilbert curve](generators/hilbertorder.md), [ant-colony tours](generators/antcolony.md), [spanning-tree renderings](generators/spanningtree.md), [string-art windings](generators/stringart.md)
- **Fields & level sets:** [percolation clusters](generators/percolation.md), [isolines](generators/isolines.md) (marching squares), [isosurfaces and metaballs](generators/isosurface.md) (marching cubes, or dual contouring for a field with corners to keep)
- **Meshes & surfaces:** [cutting solids into each other](3d/3d.md#booleans) (union, intersection, difference on a `Mesh`), [sweeps, lofts, and strips](3d/sweeps.md) (a shape carried along a 3D path whose frames never twist, a surface lofted through several shapes placed along it, a ribbon between two lines, and an even pace along a curve), [shadow art](generators/shadowart.md), [subdivision surfaces](generators/subdivisionsurfaces.md) (Catmull-Clark and Loop), [mesh growth](generators/meshgrowth.md) (differential growth and reaction-diffusion over a surface), [surface reconstruction](generators/surfacereconstruction.md) (a point cloud or scan back to a mesh, and particle skinning), [concave hulls and alpha shapes](generators/hulls.md), [medial-axis skeletons](generators/medialaxis.md), [straight skeletons and mitered insets](generators/straightskeleton.md)
- **Texture, terrain & chance:** [paper marbling](generators/marbling.md), [generative watercolor](generators/watercolor.md), [Chladni figures](generators/chladni.md), [terrain and erosion](generators/terrain.md), [river networks and basins](generators/drainage.md), and seedable [randomness](generators/random.md)

#### The 3D layer

All of it is opt-in, and a 2D sketch never pays any cost for it.

- **Cameras & scenes:** orbit and [cinematic cameras](3d/camera.md), a catalog of solid primitives, meshes from file (OBJ, glTF, USDZ), and [whole scenes](3d/scenes.md) (glTF, USD) imported with their named nodes, authored cameras, lights, and keyframe animations that play on the sketch's clock (or, with [`ollin new --from-scene`](tools/sceneimport.md), written out as the placement calls that draw them)
- **Drawn at scale:** point clouds, [instanced meshes and GPU-culled fields](3d/instancing.md) (one mesh drawn thousands of times in one call, with each copy placed on the GPU, even from a compute kernel; a retained `MeshField` draws a whole world with one call and culls each copy against the camera), [strand fields](3d/strands.md) (grass grown inside the draw call itself: half a million bending blades with no geometry buffers, culled against the camera and graded by distance), and [an ocean](3d/ocean.md) (a wave spectrum inverse-transformed into a moving sea, drawn as water with no geometry either, with its wave height set as a measurement in world units rather than as a dial)
- **Materials & maps:** stylized and physically based materials, with [an ink line](3d/3d.md#outlines) around any of them (the cartoon's outline), including [glass](3d/3d.md#glass) (transmission, refraction, absorption) and [thin-film color](3d/3d.md#thin-film) (the interference colors of a soap bubble, set by a thickness in nanometers), and the full texture-map set, with [projected decals](3d/3d.md#decals) (pictures stamped onto whatever surfaces a box touches) and [detail maps](3d/3d.md#detail-maps) (texture that stays sharp under a close look)
- **Light:** area lights (glowing panels, disks, and tubes), [a light that follows the camera](3d/3d.md#camera-relative) (a headlight, or a whole rig that holds its look under an orbit), light shaping with IES photometric profiles and projected cookies, image-based lighting from bundled HDRIs, a procedural sky with [its own sun as a light](3d/3d.md#sky-sun) (which can carry raymarched volumetric cloudscapes), or [a live camera feed](3d/3d.md#live-environment) (the real room lights the scene, as in AR), and soft shadows
- **Ray-traced looks:** ray-traced reflections (spread by the surface's own roughness, so satin shows a blurred room rather than a blurred sky) and refractions, [the scene showing through glass](3d/3d.md#scene-through-glass) on any GPU (a second pass is drawn with the glass removed and read along each body's own refracted exit ray, so a solid ball works as a lens), [caustics](3d/caustics.md) (photon-traced light focused through glass and off polished metal, with prism dispersion), and [real-time global illumination](3d/3d.md#global-illumination) (bounce light through a probe field that is retraced live) on ray-tracing GPUs
- **The frame:** [temporal anti-aliasing](3d/3d.md#temporal-antialiasing) (jittered accumulation that refines edges past what MSAA gives, on any GPU), [depth of field](3d/3d.md#depth-of-field) through the camera's own lens (highlights opening into the iris's shape, a blurred foreground as a veil), cinematic [motion blur](3d/3d.md#motion-blur) (per-object and camera streaks with a photographic shutter dial, deterministic in exports), [lens flare](3d/lensflare.md) (the ghosts a real lens prescription throws from a bright source, plus the star on the source itself, both shaped by the iris blades and fading as something covers the source), and [atmosphere](3d/atmosphere.md): height fog, aerial perspective (far geometry fading into a blue haze tinted toward the sky's own sun), and volumetric light beams, and [volumes](3d/volumes.md) (smoke, cloud, fire, or ink drawn from a box of density samples, lit and shadowed by the scene, with solids sitting inside)

Five more 3D pages round this out. [Lines in 3D](3d/lines.md) draws a line between points in space with the 2D stroke's look, a depth at every point, and a weight on screen or in the world, plus axes and a grid built from it. [Hidden-line solids](3d/hiddenlines.md) draws a mesh's faces with only its creases and silhouette in ink, ten thousand copies in one draw. [The Hopf fibration](3d/hopffibration.md) draws a whole sphere of interlocking circles, and no two of them meet. [Depth compositing](3d/depthcompositing.md) lets drawing in 2D sit inside the depth buffer. [Combining 3D features](3d/combining.md) covers how the pieces fit together.

### Concepts

Each concept page is one screen on an idea that the reference pages below assume. Read one when you want the reason behind an API rather than its signature.

- [`The frame`](concepts/frame.md) - what a drawing call does, and what happens between `draw()` and the picture
- [`Where a point is`](concepts/coordinates.md) - the canvas coordinates and their units, and the other coordinate frames a sketch meets
- [`Layers`](concepts/layers.md) - what an off-screen layer is, what it costs, and when you need one
- [`What survives a frame`](concepts/persistence.md) - what Ollin keeps between frames and what it drops: state, the canvas, layers, batches, saved values
- [`Why a run repeats`](concepts/determinism.md) - the seed and the clock, and what makes a sketch draw the same picture twice
- [`Light and color`](concepts/light.md) - why color mixes in linear light, and what the last pass of a frame does
- [`Values and bare calls`](concepts/values.md) - the typed values under `drawCircle(x, y, r)`, and when to use them

### Core

- [`Sketch`](core/sketch.md) - the lifecycle (`setup`/`draw`), the clock values (`time`, `frameCount`, …), loop control with `redraw()`, and `isExporting`
- [`Canvas`](core/canvas.md) - `scale`, the `canvasSize` export presets, and the preview window (`windowMode`)
- [`Variations`](core/variations.md) - `variation`, the seed a run starts from. Step, roll, and jump through a sketch's variation space in the inspector. Proof a range as a contact sheet (`--export-grid`), and render the one you want to keep again with `--seed`.
- [`Replay`](core/replay.md) - record a run's seed, clock, inputs, and parameter changes as a take (`--record-take`). Play it back exactly (`--replay`, with transport keys), scrub through it, and render the performance again through any export flag.
- [`Automation`](core/automation.md) - keyframed parameters. A parameter's values are written down over time (`automate`) and joined by named or Bezier curves. The result loops, plays at any speed, reads from a file (`--automation`), and renders exactly in any export.

### Drawing

- [`Drawing`](drawing/drawing.md) - `background`, `fill`/`stroke`, the shapes, the transform stack, and the views over it (`withClip`, `withViewBox`, `viewControl`)
- [`Accumulation`](drawing/accumulation.md) - `noClear` keeps the canvas across frames, so drawing builds up (long exposures, paint on canvas). `Accumulator` is a layer that keeps the running mean, so a picture built from faint samples converges.
- [`Depth of field from light`](drawing/depthoffield.md) - `LineSpray` and `Bokeh`. Lines are drawn as millions of scattered points through a lens and added into a running mean until bokeh appears. The `.light` particle style and the `develop` print filter are the parts underneath.
- [`HDR & tone mapping`](drawing/hdr.md) - `toneMap` rolls bright, out-of-range light off instead of clipping it. The page also covers the linear-float pipeline behind every frame, and the glow/bloom and sandpainting looks built on it.
- [`Wide gamut & HDR output`](drawing/coloroutput.md) - `colorOutput` to present through Display P3 and keep highlights brighter than white, `Color(displayP3:)` for colors outside sRGB, and HDR10 video export
- [`Retained batches`](drawing/batches.md) - `makeBatch` records heavy static drawing once, and `drawBatch` replays it each frame from the GPU at almost no cost. The transform in force at draw time places or stamps the whole recording.
- [`Layered effects`](drawing/effects.md) - `renderTarget`/`withTarget` draw into off-screen layers. `filtered`/`postProcess` run GPU filters over them (blur, bloom, halation, film grain, color grade, gradient map, edges, halftone, …), and the result composites back with blend modes. `combined` joins two layers (mask, displace, mix, depth-of-field defocus). `generate` makes procedural pattern sources, `feedback` makes trails and tunnels, and `simField` runs the stateful sims (reaction-diffusion, Game of Life, fluid, the self-warp motion feedback, …). `compose { }` (with `aside` helper layers) declares a stack of layers as one block.
- [`Looks`](drawing/looks.md) - `ColorLUT` reads a `.cube` file, the color table a grading tool exports, and `Filter.lut` applies it to a layer or the whole frame, a cube by tetrahedral interpolation. A look can also be built in code and written out as a `.cube`.
- [`Marks`](drawing/marks.md) - `StrokeMark`/`drawMark` and `StrokeDynamics`. Width and opacity follow how a mark is being made, rather than where you are along the path. That means how fast the pointer moves and how hard it is pressed.
- [`Text`](drawing/text.md) - `drawText` with bitmap, outline (`.ttf`/`.otf`), and stroke (single-line / plotter) fonts, plus `textToShapes` (text as geometry) and text in any script (right-to-left, Devanagari, Thai, Japanese, emoji)
- [`Images`](drawing/images.md) - `loadImage`, `drawImage`, `tint`, and pixel access. Load or build a raster image, draw it scaled or transformed, and recolor it.
- [`Sample photographs`](drawing/samplephotos.md) - `SamplePhoto`, twenty bundled photographs with their credits, one import away, for trying an image technique or a filter on a real picture.
- [`Glyph mosaic`](drawing/glyphmosaic.md) - `drawGlyphMosaic` rebuilds an image as a grid of text glyphs. Each cell's character is chosen by its measured ink in the active font.
- [`Halftone`](drawing/halftone.md) - `drawHalftone` rebuilds an image as the classic print dot screen: area-exact dots on a rotated grid, drawn as real circles for the plotter path.
- [`Autostereogram`](drawing/autostereogram.md) - `Image.autostereogram` hides a depth map in a repeating pattern. When the eyes pair the repeats, a surface that was never drawn stands out of the page.
- [`Photo mosaic`](drawing/photomosaic.md) - `Image.mosaic` + `averageColor` + `drawMosaic` rebuild a picture out of many smaller pictures. Each cell takes the picture whose average color is nearest, measured in linear light.
- [`Pixel sorting`](drawing/pixelsorting.md) - `Image.pixelSorted` reorders runs of an image's own pixels along rows or columns, with each run bounded by brightness (the classic glitch melt).
- [`Seam carving`](drawing/seamcarving.md) - `Image.seamCarved` and `SeamMap` resize a picture by removing the paths through it that matter least, so what matters keeps its shape. Masks can hold something still or remove it.
- [`Color`](drawing/color.md) - the `Color` type, the OKLab family and mixing, `CIELab`, how far apart two colors look and an image's histogram, `Ramp`s and `Palette`s (loaded from a file, extracted from an image, or shaded with a drifting hue), dithering an image down to a palette, and perceptual `Colormap`s
- [`Spectral color`](drawing/spectrum.md) - `Spectrum`, the reflectance curve behind a color. It covers `.paint` mixing (Kubelka-Munk, with pigments meeting in green), filtering light by multiplication, `Color(wavelength:)` and blackbody glow, and the spectral GPU effects (`.thinFilm`, `.diffraction`, `.paintMix`).
- [`Geometry`](drawing/geometry.md) - the `Vector2`, `Vector3` (sharing one `Vector` surface), `Rotation3D`, `Ray3`, `Rectangle`, `Circle`, `LineSegment`, `Arc`, `Ellipse`, `Grid`, `Shape`/`Contour`, `Path`, and `HobbySpline` value types (including the `Grid` layout helper, curved outlines, the questions a contour answers about itself, where any two curves cross through `PlaneCurve`, shape booleans, and offsetting)
- [`SVG import`](drawing/svg.md) - `loadSVG`/`drawSVG` read vector artwork into `Shape`s and `Contour`s: paths with curves and arcs, the basic shapes, groups and transforms, fills and strokes. The result is ready for booleans, offsets, hatching, and re-export.
- [`Fourier epicycles`](drawing/epicycles.md) - `Epicycles` + `drawEpicycles` rebuild any closed outline as a chain of spinning circles. A term-count dial runs from a soft approximation to an exact trace.
- [`Envelopes & caustics`](drawing/envelopes.md) - `envelope` + `caustic`. An envelope is the curve a family of lines is tangent to, and a caustic is the bright curve where reflected or bent light gathers.
- [`Classic curves`](drawing/curves.md) - the classic closed-form curves as geometry builders: `phyllotaxis`, `lissajous`, `rose`, `superellipse`, `supershape`, `hypotrochoid`/`epitrochoid` (the spirograph gears), `guilloche` (the twisted, cam-shaped rings of a rose engine), the damped-pendulum `Harmonograph`, `spirolateral` (a walk of growing steps repeated until it returns to its start), Chaikin `smoothed(iterations:)` corner cutting, and `smoothed(neighbors:)`, the moving average that keeps every point
- [`Anamorphosis`](drawing/anamorphosis.md) - `Anamorphosis`, a plate that reads correctly only in a mirrored cylinder standing on the page, seen from one viewing spot. It covers the wrap at true size, the map for points, contours, and shapes, the part of a cylinder an eye can see, and the search that reads a plate back.
- [`Clothoid`](drawing/clothoid.md) - the curve whose bend grows at a steady rate (the Euler or Cornu spiral). It gives the easement that joins a straight run to a turn with no kink, and the single curve that fits two points and two headings. It also gives a smooth path through waypoints, and polyline corners a vehicle could drive.
- [`Shape morphing`](drawing/morphing.md) - `ShapeMorph` tweens one `Shape` into another, and every in-between is a real vector shape (contour pairing, corner-keeping correspondence, holes that grow in and out). `Shape` is `Tweenable`, so a `Timeline` can sequence geometry.
- [`Voronoi & Delaunay`](drawing/voronoi.md) - tessellate points into vector geometry: Voronoi cells (the "crystallization" look) and the dual Delaunay triangle mesh, with Lloyd relaxation and weighted power diagrams
- [`Spatial index`](drawing/spatialindex.md) - `SpatialIndex`, the structure that answers what is near a point without reading every point. It finds the nearest point, the k nearest, everything within a radius, and everything inside a box, over a uniform grid or a k-d tree.
- [`Fitting`](drawing/fitting.md) - `RadialBasis`, a smooth field of numbers, vectors, or colors fitted through values you know at a few scattered places (a field of vectors also works as a warp), with its exact slope. `Fit.minimize` walks a few parameters downhill against a cost function you write.
- [`Truchet tiling`](drawing/truchet.md) - one tile per grid cell, turned to a random orientation, so identical parts join into flowing loops (`.arcs`) or a maze (`.diagonals`)
- [`Hitomezashi stitching`](drawing/hitomezashi.md) - one bit per grid line sets the phase of its dashes, and the shifted lines weave into staircases, loops, and a two-tone cloth
- [`Ten print`](drawing/tenprint.md) - `tenPrint`, one of two diagonals per cell chosen by a coin flip, joined into the long connected paths the picture is known for
- [`Kolam and sona`](drawing/kolam.md) - one line launched between a field of dots and bounced off the edges until it closes. The result is gcd(rows, columns) loops, and walls can steer the line.
- [`Celtic knotwork`](drawing/knotwork.md) - the same line given width and an alternating over-under rule, returned already broken where each cord passes under another
- [`Crease patterns`](drawing/creasepattern.md) - the flat sheet a folded or cut object comes from: the Miura fold with its rigid folding in three dimensions, rotating-squares kirigami, and Kawasaki's and Maekawa's laws, which say whether a sheet can fold flat
- [`Tiling & layout`](drawing/tiling.md) - the other ways to divide a canvas: `HexGrid`/`TriangleGrid` (the hex and triangle tilings, with hex distance, neighbors, and exact picking), `subdivide` (recursive panels, binary or quadtree), `Maze` (three carving algorithms, walls as clean line work, solution and longest paths), and `apollonianGasket` (the packing of kissing circles, each touching its neighbors)
- [`Aperiodic tilings`](drawing/aperiodictilings.md) - the tilings that never repeat: `penroseTiling` (kites and darts, rhombs, with the matching-rule arcs), `wangTiling` (edge-matching squares as one connected quilt), `girihPattern` (Islamic star patterns over any polygons, plus the five girih tiles), and `spectreTiling` (the einstein tile, straight or strictly chiral curved)
- [`Parquet deformations`](drawing/parquetdeformation.md) - `parquetDeformation` draws a tiling whose tile changes shape as you read across it. The geometry lives on the lattice's shared edges, so a square becomes an interlocking key with nothing coming apart on the way.
- [`Hyperbolic tiling`](drawing/hyperbolictiling.md) - regular tilings of the hyperbolic plane in the Poincaré disk. `hyperbolicTiling` takes any {p,q} with (p-2)(q-2) > 4 and returns typed tiles with depth and a two-coloring parity, and a `viewpoint` pans across the endless tiling.
- [`Strange attractors`](drawing/attractors.md) - chaotic systems as points. Continuous 3D orbits (Lorenz, Rössler, Aizawa, …) are integrated with Runge-Kutta and orbited by the camera. Iterated 2D maps (Clifford, de Jong, Hénon, Gumowski-Mira, Ikeda, hopalong) accumulate into density fields, and `AttractorFlow` moves a million GPU particles through one field at once.
- [`SDF combinators`](drawing/combinators.md) - compose signed-distance fields so shapes *merge* instead of stacking: smooth union/subtract/intersect and morph, round/onion, and domain mirror/tile. The `SDF` value type + `drawSDF` and a scoped `smoothUnion { }` block do this in 2D, and `SDF3D` + `drawSDF3D` do it in a raymarched 3D form.
- [`Measured distance fields`](drawing/distancefields.md) - measure a distance field back out of a drawn layer with `Filter.distanceField`: how far every pixel is from the nearest edge, and in which direction. `Filter.fieldMap` reads it back as contours, grown and shrunk shapes, and outlines, or a shader reads it as a Voronoi keyed to the picture.
- [`Layer styles`](drawing/layerstyles.md) - a layer given an edge of its own, read from its alpha: `.outline` inside, outside, or centered on the edge, `.dropShadow` and `.innerShadow`, `.outerGlow` and `.innerGlow` that follow the measured distance, and a lit `.bevel`. Each is one filter, and they stack in the order they are chained.
- [`The frequency domain`](drawing/fourier.md) - a picture read as a sum of waves instead of a grid of pixels. `Filter.fourier` writes the spectrum on the GPU and `.inverseFourier` reads it back. Filtering by *scale* is then a shape drawn over the spectrum, and a field can be built from nothing but a description of its energy.
- [`Light in a flat sketch`](drawing/light.md) - `Combine.light` computes the light that reaches every pixel of a flat scene. Draw the scene in one layer and the lights in another. One measurement (radiance cascades) then gives you shadows that soften with distance, falloff, light through a gap, and the color a lit wall gives back.
- [`Local averages`](drawing/localaverages.md) - the average of the neighborhood around every pixel at a fixed cost, over a summed-area table. `Filter.boxBlur` costs the same at any radius, and `Filter.adaptiveThreshold` cuts a picture to two tones against each pixel's own surroundings, so uneven light no longer matters.

### Shaders

These pages cover writing GPU code yourself. They describe fragment shaders that run through the effect graph, compute kernels over buffers and textures, and the helper library that both draw from.

- [`Shaders`](shaders/shaders.md) - write your own fragment shader (`Shader` + a `shade(uv, info)` function) and run it through the effect graph as a generator, filter, or combine, or as the paint a shape is filled or stroked with. A built-in shader library and line-accurate compile errors come with it.
- [`Visuals`](shaders/visuals.md) - compose animated imagery by chaining a `Visual`: sources (oscillator, noise, voronoi, shape) pass through warps, color moves, blends, and modulations. The whole chain compiles into a single GPU pass, and every number in it can animate at no extra cost.
- [`Shader library`](shaders/shaderlibrary.md) - reference for the helper functions a fragment shader or compute kernel can call: color/OKLab, hashes, value/gradient/curl noise, the 2D signed-distance catalog (`smin`, `sdEllipse`, `sdHeart`, …), and the repeat/mirror/polar domain operators
- [`Compute & GPU particles`](shaders/compute.md) - GPU compute over buffers and textures. `Particles` updates and draws a million particles on the GPU each frame (the "sandpainting" engine), and `Simulation` runs reaction-diffusion, cellular automata, and other ping-pong texture sims. Both sit over the `ComputeKernel`/`ComputeBuffer`/`ComputeTexture` core, and the shared shader library is spliced into every kernel.

### 3D

- [`3D`](3d/3d.md) - opt into a 3D camera and depth buffer. Orbit a `Camera3D` (perspective or orthographic) and draw `PointCloud`s as instanced disc splats. There is a catalog of solid primitives (box, sphere, capsule, the Platonic solids, …), plus parametric and profile shapes (supershape, extrude, lathe). Meshes load from file (`.obj`, `.usdz`/`.stl`/`.ply`, `.gltf`/`.glb`). Two solids cut each other four ways (`union`, `intersection`, `subtracting`, `symmetricDifference`), so a bored, rounded or carved shape comes back as a mesh like any other. They can be textured and surface-mapped with normal, metallic-roughness, occlusion, emissive, and height maps. A height map gives parallax occlusion and real displacement. Triplanar projection covers meshes with no uvs, and detail maps add close-up texture. Projected decals stamp across every surface a box touches, and a live webcam depth cloud is included.
- [`Scenes`](3d/scenes.md) - `loadScene` keeps a glTF or USD file's *structure* instead of merging it. You get a tree of named nodes, drawn in place with `drawScene` and reached by name to animate (`scene["lamp"]`). The file's authored camera and punctual lights come out as ready `Camera3D`/`Light` values, and `apply(_:at:)` plays the file's authored keyframe animations on the sketch clock.
- [`Instanced meshes`](3d/instancing.md) - draw one mesh thousands of times in one call. `drawMesh(_:instances:)` takes a list of `MeshInstance` placements (position, rotation, scale, tint) that the GPU applies per copy. It can also take a `ComputeBuffer` that a kernel writes, so a simulation moves the copies without the CPU. Copies shade like solid meshes and cast into the shadow maps. A retained `MeshField` scales this to a whole world drawn by one call, with each copy GPU-culled against the camera.
- [`The Hopf fibration`](3d/hopffibration.md) - a sphere's worth of circles, where no two circles meet and every two are linked exactly once. `hopfFibers` returns them as `[Vector3]` paths for `drawTube`, and `hopfBases` supplies the structured base sets (rings of latitude, or a spiral) that make the linking easy to see.
- [`Sweeps and strips`](3d/sweeps.md) - `Mesh.sweep` carries a `Shape` along a `Curve3D`, a path through space whose frames turn with it and never twist about it, sizing and turning the shape on the way, and `Mesh.loft` carries several shapes placed along it and blends the surface from each to the next. `Mesh.strip` is the ribbon between two lines, and `Pace` walks a curve given as a function at one speed, or a strip at one rate of area.
- [`Lines in 3D`](3d/lines.md) - `drawLine` and `drawPolyline` over `Vector3` draw a line between points in space through the camera, with the 2D stroke's weight, joins, caps, and soft edge, and a color per point if you like. Every point keeps its depth, so solids hide the line and the line hides what lies behind it. `strokeWeight(_:in:)` measures the weight on screen or in world units, and `drawAxes`/`drawGrid` are built from the same lines.
- [`Hidden-line solids`](3d/hiddenlines.md) - `featureEdges(creaseAngle:)` draws a mesh's faces in the fill and over them only its creases, its boundary, and its silhouette in the stroke, at `strokeWeight` in canvas points. Near solids hide the edges of far ones, and copies drawn with `drawMesh(_:instances:)` take their edges in one more GPU draw. `noFeatureEdges()` turns it off.
- [`Strand fields`](3d/strands.md) - grass that a mesh pipeline grows inside the draw call itself. `StrandField` + `drawStrands` draw half a million bending, swaying blades with no vertex or instance buffer anywhere. The blades are tile-culled by the camera, detail-graded by distance, and shaded and shadow-receiving on the solid lit path.
- [`The ocean`](3d/ocean.md) - a sea built the way the ocean is measured. `makeOceanField` writes a wave spectrum, and one inverse Fourier transform turns it into the moving surface. `drawOcean` draws it as water with no geometry anywhere, and `waveHeight` is a measurement in world units rather than a dial.
- [`Combining 3D features`](3d/combining.md) - the practical map of what works with what: which geometry takes lights, materials, matcaps, and environment light; what casts, receives, and appears in shadows and reflections; when to use screen-space reflections and when ray-traced ones; and a step-by-step recipe for the most realistic scene
- [`Camera control`](3d/camera.md) - move the camera by hand (`cameraControl()`: drag to orbit, scroll to dolly, right-drag or modifier-drag to pan, all damped) or play a ready-made cinematic move (`cameraMove(_:)`: turntable, push-in, tilt, orbit-and-rise, reveal, handheld). Both are opt-in over the orbit pose.
- [`Caustics`](3d/caustics.md) - the light that glass and metal focus. `caustics()` photon-traces the caster light through every transmissive and mirror-polished surface and draws where it lands. As a result, a glass sphere throws its bright spot into its own shadow, a chrome ring folds light beside itself, and `dispersion:` fans out a prism's rainbow. It needs a ray-tracing GPU.
- [`Lens flare`](3d/lensflare.md) - the light the camera itself adds to a picture. `lensFlare()` works out the ghosts a real lens prescription makes of each bright source. It places and sizes them, shapes them by the iris blades, colors them by the anti-reflective coating, and softens them by the size of the source. The star on the source itself has as many arms as those blades, frayed by the wear on them. Two lenses are bundled. All of it fades as something covers the source, rather than switching off.
- [`Line drawing`](3d/linedrawing.md) - a 3D scene written down as 2D line work, with everything the surfaces hide taken out, so a pen plotter, a laser, or a vector file can have the scene the way only a picture could before.
- [`Atmosphere`](3d/atmosphere.md) - the air between the camera and the scene. `fog` fades surfaces with distance and pools low with a height falloff (exact closed-form transmittance). `aerialPerspective` splits the fade by wavelength and lights it with the sun, so far ridges turn blue and fade into the sky. `volumetricLight` marches the air, so spot cones, cookies, IES profiles, and cast shadows become visible beams and crepuscular shafts.
- [`Volumes`](3d/volumes.md) - a cloud placed in the scene. A `Volume` is a box of density samples, built from a function of position, from a list, or from noise filled across every core. `drawVolume` marches it through the scene's depth with the `Medium` it is made of: how thickly it blocks light, the color it scatters the lights in, and its own glow. Solids sit inside it, the medium shades itself, and a solid's shadow falls through it.
- [`Depth compositing`](3d/depthcompositing.md) - place 2D drawing *inside* a 3D scene, so it occludes the geometry and is occluded by it: `depth(at:)`, `project`, and `withBillboard` (a 2D label hidden when it swings behind the cloud)
- [`Record3D`](3d/record3d.md) - `import OllinRecord3D` turns an iPhone's color-plus-depth into a 3D point cloud, from a recorded `.r3d` file or a tethered phone's live USB stream
- [`RGBD`](3d/rgbd.md) - the one `RGBDFrame` (color + depth + intrinsics) that any depth source produces. Unproject it to a point cloud, lift a single image point to metric 3D, or lift a 2D body pose into space (`Body.lifted(through:)`).
- [`Phone`](3d/phone.md) - `import OllinPhone` reads a tethered iPhone's live on-device ARKit sensor stream from Ollin's own capture app, over the USB cable. The stream carries a 3D body skeleton, a face mesh with expression blendshapes, and the hands in view as 21-joint skeletons lifted to metric 3D. It also carries the recognized text lines with their corners lifted to 3D, world-facing rear-LiDAR depth (a metric point cloud with the camera's 6DoF pose), the reconstructed room as a labeled surface, a person matte, how the picture is moving as a motion field, and device motion. A sketch on the Mac can also put itself on the phone's screen, sent down the cable as video, with the finger on the glass as its pointer.

### Generators

- [`Random`](generators/random.md) - `random`, `randomGaussian`, and the `randomVector`/`ring` scatter helpers
- [`Noise`](generators/noise.md) - Perlin `noise` / `signedNoise`, seamlessly looping `noise(loop:)`, layered `fbm`, and `curlNoise` flow fields
- [`Blue noise`](generators/bluenoise.md) - `poissonDisk`, an even but organic scatter with no clumps or gaps (Poisson-disk sampling), over a rectangle or inside a `Shape`
- [`Low-discrepancy sampling`](generators/lowdiscrepancy.md) - `haltonPoints` / `sobolPoints`, even coverage as an ordered stream: growing the count only adds points and never moves them
- [`Points on a surface`](generators/surfacesampling.md) - `surfacePoints`, points scattered over a mesh's surface rather than its vertex list. They are evenly spaced by default, and each carries the normal, texture coordinate, and triangle it landed on.
- [`Stippling`](generators/stippling.md) - `stipple`, dots packed to reproduce an image's tone (weighted-Voronoi stippling) or any density function
- [`De Bruijn sequences`](generators/debruijn.md) - `deBruijnSequence` + `DeBruijnCode`, a cyclic sequence that holds every window of a given length exactly once, so a glimpse of a few symbols tells you where it came from
- [`Ford circles`](generators/fordcircles.md) - `fordCircles`, a circle for every fraction, each touching its neighbors and overlapping nothing, built over `fareySequence` and the exact `Fraction` type
- [`Shadow art`](generators/shadowart.md) - `shadowArt`, a solid carved so that it throws the silhouettes you ask for, with the shadows it really casts so you can compare them
- [`Polyominoes`](generators/polyominoes.md) - `Polyomino` + `tilePolyominoes`, the twelve pentominoes and an exact-cover search that fits a bag of pieces into a region, or reports that no fit exists
- [`Ulam spiral`](generators/ulamspiral.md) - `ulamSpiral`, the whole numbers written in a square spiral, so a test on them becomes a picture. The primes fall on diagonals.
- [`Fractals`](generators/fractals.md) - `IFS` chaos games, `FractalFlame` renders, circle-inversion limit sets, and Kleinian limit-set curves, plus the `fitted` placement helper
- [`Chaotic maps & bifurcation`](generators/bifurcation.md) - `IteratedMap`, the one-dimensional route to chaos: the logistic, sine, tent, and Gauss families, orbits and cobweb staircases, the bifurcation diagram as dots or a density image, and Lyapunov exponents
- [`Single line`](generators/singleline.md) - `singleLine`, one continuous tour through an image's stipple (TSP art), returned as a plotter-friendly `Contour`
- [`Hilbert order`](generators/hilbertorder.md) - `hilbertOrder` / `hilbertSorted` / `hilbertIndex`, points sorted by their place along a space-filling curve: one line through a stipple by a single sort, the local relative of the tour
- [`Ant colony`](generators/antcolony.md) - `AntColony`, a colony that lays pheromone trails and narrows a web of possible routes down to a short tour. The search itself is what you draw.
- [`Spanning tree`](generators/spanningtree.md) - `spanningTree`, the minimum spanning tree of an image's stipple: the branching, vein-like relative of the single line
- [`String art`](generators/stringart.md) - `StringArt`, one continuous thread wound over rim pins until the crossings reproduce a picture (a stateful stepper)
- [`Percolation`](generators/percolation.md) - `Percolation`, site-percolation clusters over a seeded grid: largest-first labeling, the spanning cluster, cell rectangles, and traced boundary loops
- [`Isolines`](generators/isolines.md) - `isolines`, level curves of any scalar field or of an image's tone, by marching squares: from metaball outlines to contour maps
- [`Isosurfaces`](generators/isosurface.md) - `isosurface` / `Metaballs`, the surface where a field over space crosses a level, marched into a `Mesh` (dual contouring where the field has corners to keep): soft spheres that fuse, noise volumes, gyroids
- [`Subdivision surfaces`](generators/subdivisionsurfaces.md) - `mesh.subdivided`, a low-poly control cage refined into a smooth solid by the Catmull-Clark or Loop rules, with welding and open-edge handling built in
- [`Mesh growth`](generators/meshgrowth.md) - `MeshGrowth` / `MeshReactionDiffusion`, a surface that grows more area than it has room for and folds: brain coral, branching coral, a ruffled leaf margin
- [`Surface reconstruction`](generators/surfacereconstruction.md) - `reconstructSurface` / `particleSurface`, from points back to a `Mesh`. Rebuild a scanned room or object with its holes kept, or skin a particle set as one blended body.
- [`Fracture`](generators/fracture.md) - `fractured`, breaking a `Shape` or a `Mesh` into pieces that fit back together with no gap and no overlap, evenly or crowded around a blow; plus `convexHull` in space and the measurements a piece answers
- [`Hulls`](generators/hulls.md) - `concaveHull` / `alphaShape`, two tighter answers to "what shape are these points?": one simple polygon that follows the gulfs, or the scatter's true footprint with islands and holes
- [`Medial axis`](generators/medialaxis.md) - `medialAxis`, a shape reduced to its skeleton, with every point carrying its inscribed-disk radius
- [`Straight skeleton`](generators/straightskeleton.md) - `straightSkeleton`, the ridge network a shrinking boundary traces, with faces and exact mitered insets (`inset(by:)`). One build gives every topographic contour at once.
- [`Force-directed layout`](generators/forcelayout.md) - `ForceLayout`, a graph that untangles itself: repulsion between all nodes, attraction along edges, and cooling into an even web you can grow, pin, and drag
- [`Tensegrity`](generators/tensegrity.md) - `Tensegrity` / `addTensegrity`, struts held apart by cables: the prism, the six-strut icosahedron, and a stacked mast, each in its balanced shape, with `imbalance` to check a form of your own and a `World3D` build that lands and stands
- [`Marbling`](generators/marbling.md) - `Marbling` / `drawMarbling`, paper marbling in closed form: drops, tines, combs, and swirls rake vector ink outlines into feathered papers
- [`Watercolor shapes`](generators/watercolor.md) - `Watercolor` / `drawWatercolor`, watercolor pigment from recursively deformed polygons stacked as translucent layers
- [`Chladni figures`](generators/chladni.md) - `chladni`, a ringing plate's standing-wave field in closed form, plus the `.chladni` generator's sand and wave readings and the mode-by-pitch join to audio
- [`Billiards`](generators/billiards.md) - `Billiard`, a ball that bounces forever in a circle, an ellipse, a polygon, or a stadium, with posts standing in it. The path comes back as geometry, and the shape of the room decides whether it draws a pattern or fills the floor.
- [`Drainage`](generators/drainage.md) - `Drainage`, rivers computed from a `Heightfield` rather than drawn. Hollows are filled so water always has a way out, and you get flow per cell, the network above a threshold as strokable reaches, Strahler ordering, and basins.
- [`Terrain`](generators/terrain.md) - `Heightfield`, landscapes from noise or `diamondSquare`, weathered by droplet hydraulic and thermal erosion, and emitted as terrain meshes, heightmaps, and contours
- [`Random walks`](generators/walks.md) - `randomWalk` / `levyFlight` / `selfAvoidingWalk`, paths built one random step at a time: the local tangle, the cluster-and-leap, and the single stroke that never crosses itself
- [`Circle packing`](generators/packing.md) - `packCircles` and `relaxCircles`, filling a region with non-overlapping circles that grow until they touch
- [`Shape grammars`](generators/shapegrammar.md) - `ShapeGrammar`, a design written as rules over labeled shapes: the balanced cut behind the ice-ray lattices, splits for a building front, insets that become bars, and nested turned copies
- [`Turtle`](generators/turtle.md) - `Turtle`, a pen you drive from code: forward, back, left, right, pen up and down, and a remembered pose for branches, every run an ordinary contour
- [`L-systems`](generators/lsystem.md) - `drawLSystem` and a preset catalog: a rewriting grammar that a turtle walks into fractal curves and branching plants, symbolic or parametric (symbols carry numbers, for fractional lengths, delays, and tapering width)
- [`Differential growth`](generators/differentialgrowth.md) - `DifferentialGrowth`, a line of nodes that grows and folds into an organic, brain-coral structure (a stateful stepper)
- [`Meander`](generators/meander.md) - `Meander`, a river centerline that migrates by curvature, cutting off oxbow lakes and recording scars (a stateful stepper)
- [`Wave Function Collapse`](generators/wavefunctioncollapse.md) - `wfc` fills a grid so every neighbor is legal, from a tileset you declare or from the patches of an example picture (constraint-solved tile layouts, texture synthesis)
- [`Cellular automata`](generators/cellularautomata.md) - `elementaryCA`/`totalisticCA` row stacks chosen by rule number, and `Turmite` walkers (Langton's ant and its relatives) painting a wrapped grid
- [`Shape packing`](generators/shapepacking.md) - `packShapes` and `ContinuousPacking`, filling a region with non-overlapping shapes grown against each other's outlines
- [`Rectangle packing`](generators/rectanglepacking.md) - `packRectangles` and `RectanglePacking`, fitting rectangles of given sizes into one bin at their own sizes for a contact sheet, a collage, or an atlas
- [`Flow fields`](generators/flowfield.md) - `FlowField`, streamlines traced through a direction field (the flow-field look) and particles advected along it
- [`Flocking`](generators/boids.md) - `Boids`, a flock that steers by separation, alignment, and cohesion into emergent flocking motion
- [`Pursuit`](generators/pursuit.md) - `Pursuit`, runners that head straight at each other and leave logarithmic spirals: the ring of mice, and a quarry that runs straight (a stateful stepper)
- [`Steering`](generators/steering.md) - `Vehicle`, a creature moved by composable steering forces (seek, flee, arrive, pursue, wander, follow a path or flow field)
- [`Space colonization`](generators/spacecolonization.md) - `SpaceColonization`, branching growth (veins, roots, trees) toward scattered attraction points (a stateful stepper)
- [`Diffusion-limited aggregation`](generators/diffusionlimitedaggregation.md) - `DiffusionLimitedAggregation`, branching clusters frozen out of random walkers (frost and coral; a stateful stepper)
- [`Dielectric breakdown`](generators/dielectricbreakdown.md) - `DielectricBreakdown`, lightning grown where the solved electric field is strongest. The `eta` exponent sweeps the result from a furry bush to a sparse Lichtenberg arc.
- [`Crack growth`](generators/crackgrowth.md) - `CrackGrowth`, perpendicular cracks that subdivide the plane into city-block cells, each dragging a one-sided watercolor wash (a stateful stepper)

### Helpers

- [`Math`](helpers/math.md) - `map`, `dist`, `lerp`, the shaping scalars (`clamp`/`fract`/`step`/`smoothstep`), `polar` and `spherical`, `derivative` and `gradient`, and `Double.tau`
- [`Complex`](helpers/complex.md) - `Complex`, a point of the plane that multiplies: literals and `Numeric`, the polar form, `exp`/`log`/`pow`/`sqrt` and the trigonometric functions on the principal branch, the `Vector2` bridge, `ComplexPlane` (the framing every picture of the plane shares, converting between its numbers and canvas points; a generator's `plane`), and the shader library's `complex` module as its twin on the GPU
- [`Animation`](helpers/animation.md) - looping progress (`loopProgress`/`pingPong`), the timers (`every`/`after`/`everyFrames`), `sway` (a value that travels between two ends and back, over five shapes), the `Easing` curves, `@Eased` (ease toward a target), `@Smoothed` (smooth a noisy signal), `@Sprung` (spring toward a target with momentum), and the `Timeline` keyframe sequencer
- [`Formula`](helpers/formula.md) - a number written as a rule and read from text: `drive($radius, "190 + sin(time) * 80")`. The page covers the arithmetic a formula understands, the clock, canvas, pointer, and other parameters it can name, and the errors it reports rather than throws.
- [`Parameters`](helpers/parameters.md) - `@Param` tunable parameters: typed inspector controls (from sliders and toggles to menus, color wells, text, and geometry fields) in grouped cards (with `.folded` sections that start closed), value scrubbing, optional smoothing, and binding from OSC or MIDI
- [`Cues`](helpers/cues.md) - looks you can call back: `saveCue` stores every parameter's value under a name, `cue(_:over:)` brings them back at once or over a fade, the inspector's Cues card lists and saves them, a MIDI program change or `/ollin/cue` calls one in the performance host, `Sketch.cues.json` keeps them beside the sketch, and `--cue` renders an export at one
- [`Input`](helpers/input.md) - mouse and keyboard, files dropped or picked through the open panel, and the pointer's shape
- [`Accessibility`](helpers/accessibility.md) - see your colors as the three kinds of color vision see them, check whether a palette's colors stay apart, and read the system's reduce-motion setting
- [`Data`](helpers/data.md) - `loadTable` for CSV and TSV files (typed reads by column name) and `loadJSON` for documents you reach into by name and index
- [`LiveData`](helpers/livedata.md) - `DataFeed`, one address read over and over on a background queue, so a sketch draws what is true now. It covers conditional polling, backoff, and one fixed answer in an export.
- [`Weather`](helpers/weather.md) - `Weather`, the sky over a place or a name as plain readings (temperature, clouds, wind, rain, the condition in a word), and `Place.sun(at:)` for where the sun is, with no network
- [`Audio`](helpers/audio.md) - `import OllinAudio` for microphone, file, and oscillator sources, analyzed into `amplitude`/`spectrum`/band values, beats, and the note heard (`pitch`, `chroma`) you read in `draw()`
- [`Listening`](helpers/listening.md) - speech as a caption you can draw and phrases you can act on, plus about 300 everyday sounds named as they happen, over any audio source
- [`Synthesis`](helpers/synthesis.md) - `Synth`, the instrument a sketch plays: notes by name or number, `Voice` presets over a shaped and filtered oscillator, a wavetable read by position, a grain cloud cut out of a sound, delay and reverb, a room of your own as a convolution reverb, and a pitch shift and a freeze that take the sound apart into its partials first
- [`Composition`](helpers/composition.md) - working out what to play: Euclidean rhythms, scales and chords, arpeggios, and Markov sequences, as pure values of a step number, plus a step sequencer with swing, chance, and ratchets and an arpeggiator over held notes, both reading the beat you hand them
- [`MIDIFiles`](helpers/midifiles.md) - a piece as a Standard MIDI File, read into notes a sketch plays or draws and written back out, with the tempo map that turns its beats into seconds, and a take recorded off a live `Synth`
- [`Sonification`](helpers/sonification.md) - numbers played as notes: a table column, a terrain profile, or a picture row, spread over a range of pitch and snapped to a scale

### Simulation

- [`Physics`](simulation/physics.md) - `import OllinPhysics` for a `World` you step each frame, so motion comes from simulation. It has a soft Verlet side (particles, springs, disk collisions) and a rigid side (bodies, colliders, joints, backed by Box2D).
- [`Physics3D`](simulation/physics3d.md) - rigid bodies inside the 3D scene. A `World3D` holds stacking, tumbling, swinging `Body3D`s (backed by Jolt), with joints, contacts and sensors, walking characters, driveable vehicles, ragdolls built from a skinned `Scene`, cloth and ropes, mouse grabbing through the camera, and `withBody` drawing.
- [`Swarm`](simulation/swarm.md) - the steering behaviors at GPU scale: separation, alignment, cohesion, seek, flee, arrive, wander, and flow following, as weights over tens or hundreds of thousands of agents
- [`Artificial life`](simulation/artificiallife.md) - three emergent-behavior systems on the GPU: `ParticleLife`, the `PPS` turning rule, and `Physarum` slime mold. The first two run over a GPU `SpatialHash` neighbor search, which you can also build your own sims on.
- [`Evolution`](simulation/evolution.md) - populations that get better at something. `Evolution` breeds tens of thousands of GPU flights toward a target past obstacles by tournament selection, and `Population` breeds a handful of genomes that a person picks by eye.
- [`Fluids & soft bodies`](simulation/fluids.md) - GPU particle dynamics: `ParticleFluid` (smoothed-particle hydrodynamics) and `SoftBodies` (shape-matched jelly blobs), both in a walled box you can splash and knead with the mouse
- [`Watercolor simulation`](simulation/watercolor.md) - wet paint on rough paper: a three-layer wash simulation (`watercolor(pigments:)`) with real pigment behavior and Kubelka-Munk glazing. Paint with any drawing call, call `dry()` between washes, and call `blot()` for backrun blooms.
- [`Articulated & chaotic motion`](simulation/motion.md) - CPU motion systems you step each frame: `IKChain` (inverse-kinematics tentacles and limbs), `DoublePendulum` (the classic chaos machine), and `NBody` (quadtree gravity for orbits, galaxies, and collisions)
- [`Crowds`](simulation/crowds.md) - `Crowd`, walkers that avoid each other by reciprocal velocity obstacles on the CPU: no overlap while every walker finds a safe velocity, obstacles and walls that hold even in a jam, `isJammed`, goals or a `preferredVelocity` rule
- [`Coupled oscillators`](simulation/oscillators.md) - `Kuramoto`, a crowd of oscillators each pulled toward the phase of the others, on the CPU: the order parameter `coherence`, the critical coupling where a locked group forms, and local coupling on a ring, a square or hex lattice, or a graph of your own, with `localCoherence` for where the crowd has locked

### Integration

- [`OSC`](integration/osc.md) - `import OllinOSC` to send and receive OSC messages over UDP (to and from TouchOSC, Max/MSP, TouchDesigner, …), read in `draw()` or bound to a `@Param`
- [`OSCQuery`](integration/oscquery.md) - `import OllinOSC` to publish the sketch's `@Param` parameters as a namespace a control app finds on the network and builds its own controls from, the values coming back over OSC at the same port number
- [`TUIO`](integration/tuio.md) - `import OllinOSC` to read a tangible surface: touches, tagged pieces, and shapes from a marker table, a touch wall, or a phone app, each keeping its id while it stays on the surface
- [`MIDI`](integration/midi.md) - `import OllinMIDI` to read from and send to MIDI controllers and keyboards over Core MIDI, read in `draw()` or bound to a `@Param`
- [`Link`](integration/link.md) - `import OllinLink` to join the local network's shared tempo-and-phase session (the Link protocol most music apps support). A sketch then moves on the same beat and lands on the same downbeat as the whole rig, with no cabling or setup.
- [`Serial`](integration/serial.md) - `import OllinSerial` to read a USB microcontroller's sensor lines in `draw()` (or bound to a `@Param`) and write lines back to drive servos and LEDs. It covers IOKit discovery, automatic reconnection, and the classic physical-computing loop.
- [`Bluetooth`](integration/bluetooth.md) - `import OllinBluetooth` to read a Bluetooth Low Energy sensor in `draw()` (or bound to a `@Param`) and write back to it. It covers the devices in range, a connection that waits and returns by itself, the standard's own values already named, and the permission the first run has to get past.
- [`MQTT`](integration/mqtt.md) - `import OllinMQTT` to join the message bus a building speaks. A sketch subscribes to the topics a house publishes on and reads them in `draw()` (or bound to a `@Param`), and publishes back to drive the lamps and machines. It covers topics and their wildcards, what the devices actually write in a payload, the two service levels, retained values, the last will, and a connection that comes back on its own.
- [`Remote`](integration/remote.md) - `import OllinRemote` to serve the sketch's `@Param` parameters to a phone or a second machine on the local network: a touch surface in any browser, live in both directions, for tuning an installation from in front of it
- [`Room`](integration/room.md) - `import OllinRoom` to let several machines on one network draw one work. They find each other by the room's name, with no server, and trade values and `@Param` parameters. They agree on one clock so motion stays in step, and each takes a seat when the work is split across screens.
- [`DMX`](integration/dmx.md) - `import OllinDMX` to drive stage lights and dimmers from `draw()` over Art-Net or sACN (a `DMXUniverse` of 512 channels, with a named-fixture shorthand). It also sends the canvas's own pixels to LED strips and matrices (`LEDMap`, sampled on the GPU each frame). A lighting console can drive a sketch too, with channels read in `draw()` or bound to a `@Param`.
- [`Laser`](integration/laser.md) - `import OllinLaser` to draw with a show laser from `draw()`. Line work is optimized into the point stream a projector scans (spacing, corner and blanking dwell, path order, the point budget). An arm gate and a stopped-beam rule guard the output, which is streamed to a network DAC or written as an ILDA file.
- [`Syphon`](integration/syphon.md) - `import OllinSyphon` to share live visuals with other Mac apps (openFrameworks, Resolume, MadMapper, VDMX, …): publish a sketch's frames as a Syphon source, and draw an incoming Syphon feed as an `Image`
- [`Virtual camera`](integration/virtualcamera.md) - `import OllinCamera` to feed a sketch's frames to the Ollin Camera system camera, so webcam apps and browser tools (Zoom, OBS, Hydra via `getUserMedia`, …) read the sketch as a live camera
- [`Game controllers`](integration/controller.md) - `import OllinController` to read a game controller in `draw()`: sticks, triggers, and buttons on any pad, plus motion and a touchpad on hardware that has them, with several players at once
- [`Haptics`](integration/haptics.md) - `import OllinHaptics` to add touch feedback beside the picture. A pattern of taps and hums is composed like a phrase and played from `draw()`. It is translated for the trackpad's three feelings and one strength, and played as written where a full haptic engine exists.
- [`Screen capture`](integration/screencapture.md) - `import OllinScreen` to take any display, app, or window on the Mac as a live GPU-textured frame source, drawn and filtered like any image and read by the vision trackers. It is the counterpart to Syphon for apps that do not publish their frames. It also includes the feedback tunnel you get when a sketch captures the screen it is drawn on.

### Vision

- [`Vision`](vision/vision.md) - `import OllinVision` for the Mac's camera (built-in, Continuity, or external) plus Apple's on-device perception, returned as typed results you read in `draw()`. Nineteen trackers cover detection (rectangles, barcodes/QR, text/OCR, contours into vector `Shape`s), tracking (a patch you point at, parabolic trajectories, dense optical flow), and segmentation (person, subject, and point-prompted mattes and cutouts). They also cover pose (face landmarks, hand and body skeletons, the 3D body in meters), classification, saliency, typed phrases scored against the picture, and depth that holds still from a video model, plus any custom Core ML model.

### Video

- [`Video`](video/video.md) - `import OllinVideo` to play a video file into a sketch as a live image. Each decoded frame arrives as a GPU texture you draw with `drawImage`, and a CPU `snapshot()` gives you pixel reads and analysis.
- [`Slit scan`](video/slitscan.md) - `SlitScan`, a rolling frame history read back through a per-pixel time delay: the classic scan, time ripples, displacement maps

### Output

- [`Export`](output/export.md) - save frames as raster (PNG, sequences), motion (video, animated GIF), vector (SVG for pen plotters, PDF for print), or linear EXR with depth, for a compositor
- [`Web page`](output/web.md) - `--export-web` records what a sketch draws and writes a page that plays it back in a browser, as one self-contained file or as a fragment for a page of your own
- [`Path-traced export`](output/pathtraced.md) - `--path-traced` renders the same 3D scene offline by tracing light paths, for soft shadows, color bleed, mirror-in-mirror reflections, and a real lens
- [`Recording`](output/recording.md) - record a live run as it happens, with the picture and the sketch's own sound (or the room's sound) in one movie, in real time, or copy one frame to the clipboard
- [`Fabrication`](output/fabrication.md) - write a `Mesh` as STL, OBJ, or 3MF for 3D printing, with real units and a printability check
- [`G-code`](output/gcode.md) - write a frame's line work as a program that a pen plotter, laser cutter, or CNC router runs directly
- [`DXF`](output/dxf.md) - write a frame as a DXF drawing a CAD program or a laser cutter's software opens: lines, polylines, and true circles in millimeters, each color on its own layer
- [`Embroidery`](output/embroidery.md) - write a frame as the stitches an embroidery machine sews, a `.dst` file with strokes as running stitch, fills as rows, and each color as its own thread
- [`Installation`](output/installation.md) - leave a sketch running for days: full screen, no pointer, a clock that survives a week, a watch that restarts it, and the building's hours
- [`A sketch as an app`](output/app.md) - wrap a finished sketch as a signed, double-clickable Mac app that runs without the toolchain, with a frame of itself as its icon
- [`Screen saver`](output/screensaver.md) - wrap a sketch as the machine's screen saver: one command writes the project, one script installs it, and the sketch stays an ordinary sketch
- [`Wallpaper`](output/wallpaper.md) - run a sketch as the desktop wallpaper: one window per display at desktop level, behind the icons, with a menu-bar item to quit it
- [`Menu bar`](output/menubar.md) - run a sketch as a small live strip among the menu bar's status items, drawn at a rate an all-day surface can afford
- [`Widget`](output/widget.md) - show a sketch as a widget on the desktop, drawn one picture per moment, so the sketch changes through the day rather than moving
- [`Print separations`](output/printseparations.md) - split a sketch into per-ink grayscale masters for risograph and screen printing, with an overprint preview and registration marks
- [`Print color`](output/printcolor.md) - soft-proof a canvas against a press profile, flag the colors ink cannot reach, and split it into process-color plates with their total-ink figures
- [`Spatial`](output/spatial.md) - write a 3D frame or a `Scene` as USDZ, so the work opens in Quick Look, sends in a message, and stands on a real table through AR. Write the motion as spatial video, a stereo pair per frame, for a headset.

### Tools

- [`Project generator`](tools/projectgenerator.md) - `ollin new` and `ollin generate`: a ready-to-run sketch folder from a few questions, with templates you can watch running before you pick one
- [`Single-file sketches`](tools/singlefile.md) - the `ollin` command: run one `.swift` file as a sketch from anywhere, no package needed, or a package's sketch with every file of it reloading
- [`The sketch on the phone`](tools/onthephone.md) - `ollin phone`: the sketch on a paired iPhone or iPad. It is installed again on every save, with its clock and parameters carried across, and the parameters stay live on the Mac. Or it stays on the Mac and shows on the phone's screen, with nothing installed.
- [`Live coding`](tools/livecoding.md) - the OllinLiveCoding performance host: write and evaluate sketch code live, with the code shown over the visuals
- [`Bringing a shader over`](tools/shaderimport.md) - `ollin new --from-shader`: translate a GLSL fragment shader into Metal and get a project around it
- [`Checking the machine`](tools/doctor.md) - `ollin doctor`: what this machine can run, with the line that fixes each answer; shell completions, and `--list-params` for what a sketch declares
- [`Checking a shader`](tools/shadercheck.md) - `ollin check`: compile a `.metal` file on this machine's GPU and see the errors at your own line numbers, what kind of shader it is, and the parameters it reads
- [`Bringing a scene over`](tools/sceneimport.md) - `ollin new --from-scene`: a glTF or USD scene written out as the camera, lights and placement calls that draw it
- [`Writing an extension`](tools/extensions.md) - `ollin new --kind extension`: a library other sketches import, the `ollinx-` naming convention, and the seams to build on
- [`Dragging a shape`](tools/dragtoedit.md) - Command-drag a shape in the live window, or on the performance stage, to move it, drag a corner to resize it, or drag the knob above it to turn it. The numbers in your own code change, with your spacing and comments untouched.
- [`The parameter timeline`](tools/timeline.md) - OllinLive's timeline panel: a lane per automated parameter, keys placed from the inspector's diamonds and dragged by hand, a playhead over the sketch clock, and a round trip to the automation file
- [`The reference offline`](tools/reference.md) - `ollin docs`, `ollin examples`, `ollin api`, and `ollin site`: these pages, every example sketch, and every public name, read in the terminal or written out as a website. They come from the checkout you build against, and a search covers the whole reference
- [`Profiling`](tools/profiling.md) - the inspector's cost row: CPU against GPU on one scale, the draw and pass counts, and a frame handed to Xcode

Coordinates use a **top-left origin with y increasing downward**, the same as p5, Processing, and OPENRNDR. The [Where a point is](concepts/coordinates.md) page covers this in one screen, including the units.