# Gallery (scene) Every installed style block in its own bay: a row of identical bays (sphere, box, column, thin rail, checker tile, back wall) with a sign naming the block, its slot and what it does. The scene's StyleStack holds one entry per block, each limited to its bay by a world sphere mask, so every block is driven the same way and seen side by side; the Line boil bay adds a depth line to show the boil. Players spawn at the first bay and walk along the row. Blocks from packages installed later get bays when the scene is built again.

The full-frame pass of the cardSurface style block.

# Matte card (styleBlock, Surface) Makes every surface read as matte coloured card: shine and hot highlights are taken off, light is softened and a faint card fibre sits on each surface, like a cut paper or papercraft diorama. Settings: `matte` (0.85), `soften` (0.3), `fibre` (0.25), `fibreSize` (60 per metre), `card` (warm white tint). It works out how much light reached each pixel by dividing the rendered colour by the surface's base colour (which the stack copies from the deferred renderer), caps that light so nothing shines, and puts the base colour back under the softened light. ## What it gives up in motion Specular glints and moving reflections are removed, so a turning metal object loses the cue that it is turning. The fibre sits on surfaces, so it does not slide when the camera moves; on a moving skinned character it is taken from world position and slides across the body. ## How it treats content - Opaque things: become matte card in their own colour. - Transparent things (glass, water): the base colour behind them is used, so glass loses its tint and reads as the card behind it, softly lit. - Particles and smoke: additive particles over a surface are capped with the light and dim; smoke over a surface is treated like the surface's light. - Sky: only softened, no fibre. - Fog: fog brightens the light estimate, so fogged surfaces read as paler card. - Skinned characters: become matte card; fibre slides on the moving body. - Foliage: matte card leaves. - World text: emissive or bright text is capped like any highlight and can lose punch; exclude labels. - Black stays black: it rescales light that is there, it adds none.

The full-frame pass of the Chunky pixels style block.

# Chunky pixels (styleBlock, Raster) Samples the picture on a coarse grid of big square pixels, like a low resolution game or a retro screen. Settings: `size` (5 reference px), `levels` (0, off), `edge` (0). Its grid belongs to the screen on purpose: this block's medium is a screen. ## What it gives up in motion The grid is fixed to the screen, so as things move their edges crawl from big pixel to big pixel, and a slow pan steps instead of gliding: that is what a low resolution screen does. Thin things narrower than a big pixel blink in and out. Keep it after the Line and Ground slots (the slot order does this) so lines and paper are pixelated with everything else. ## How it treats content - Opaque things: sampled at each big pixel's centre. - Transparent things (glass, water): sampled as they appear. - Particles and smoke: small particles blink as they cross pixel centres. - Sky: becomes flat blocks; gradients step. - Fog: sampled like everything else. - Skinned characters: crawl in big pixel steps as they move. - Foliage: leaves flicker between pixels when they sway. - World text: small text becomes unreadable at large sizes; exclude labels or keep `size` small. - Black stays black: it resamples the picture and adds no light.

The full-frame pass of the Dark board style block.

# Dark board (styleBlock, Ground) Draws the picture in chalk on a dark board: dark areas are the board, light areas are chalk that catches on the board's tooth, for a blackboard or night sketch look. Settings: `board` (dark green-grey), `chalk` (warm white), `keepColour` (0.45), `tooth` (0.5), `grainSize` (30 per metre), `contrast` (1.3), `coverage` (0.65: how much of the board the brightest areas cover with chalk, so the board always shows). As the stack's first Ground block it also publishes the shared ground (board colour and tooth) for washes and lines to read. Swap it for Plain paper and nothing else changes. ## What it gives up in motion Mid tones become broken chalk, so small and dim details break into specks that change as their brightness changes. The tooth sits on surfaces, so it does not slide with the camera; on a moving skinned character it is taken from world position and slides across the body. ## How it treats content - Opaque things: drawn in chalk by brightness. - Transparent things (glass, water): drawn as they appear; the tooth is the surface behind. - Particles and smoke: bright particles become chalk marks; dark smoke disappears into the board. - Sky: a bright sky becomes a chalked area; a night sky stays board. - Fog: bright fog chalks over the distance, which reads like a smudged board. - Skinned characters: chalked; tooth slides on the moving body. - Foliage: becomes chalk speckle. - World text: light text stays readable as chalk; dark text on light becomes board-coloured letters; exclude labels that must stay exact. - Black stays black: with no light at all the frame stays black, not board coloured.

The field pass of the Dark board block: publishes the board colour and tooth as the shared ground.

The full-frame pass of the Flat wash style block.

# Flat wash (styleBlock, Fill) Lays each area of colour as one flat, transparent wash with darker pooled edges and pigment that settles into the paper grain, the base of a watercolour or gouache look. Settings: `flatten` (0.75), `reach` (5 reference px), `edgeDarken` (0.35), `granulation` (0.4), `lighten` (0.15), `wobble` (1). Low quality looks one ring out instead of two. It reads the shared ground: pigment granulates where the ground's grain is low, so the paper shows through the wash, and it reads the shared wobble, so with a Time block its edges tremble on the same held clock as an ink line. A Ground block later in the stack multiplies the wash onto the paper. ## What it gives up in motion Fine detail inside an area of colour (texture, small highlights) is smoothed away. The wash is found again every frame from the picture, so a flickering texture still flickers a little through the wash; pooled edges follow silhouettes and colour borders as they move, and slide along with them. The grain it settles into stays on surfaces (it comes from the Ground block). ## How it treats content - Opaque things: flattened into washes with pooled edges where colours and depths meet. - Transparent things (glass, water): flattened together with what is behind them. - Particles and smoke: soft particles blend into the wash; small sparks are smoothed away. - Sky: a sky gradient becomes a soft wash; no depth borders there. - Fog: fog flattens with the colour it covers, which reads as a wet-in-wet distance. - Skinned characters: washed like any surface; the depth border keeps their silhouette. - Foliage: leaves merge into a mass of colour, which suits painted foliage. - World text: small text is smoothed and can become hard to read; exclude labels. - Black stays black: it averages the light that is there and adds none.

# bandedToon (material) A warm terracotta material on the bandedToon shader: three light bands from the Stepped light block's shared banding, for objects that should be banded in their own material.

Banded toon: a surface shader that steps sun, point, spot and ambient light into bands with the same sbl_bands the Stepped light block uses.

# bands (shader module) `sbl_bands(light, bands, soft, lift)`: steps an amount of light into a few bands with soft edges, keeping `lift` of the light in the darkest band and none where no light arrives. The Stepped light block uses it over the whole frame and the `bandedToon` shader uses it inside a material, so a chosen set of objects can be banded in their own material and the rest of the frame by the block. Include it with `#include "~starterBlocks.blocks.lightBands.bands"`.

The full-frame pass of the lightBands style block.

# Stepped light (styleBlock, Light) Steps the light on every surface into a few flat bands, cel shading for the whole frame with no material edits, or inside a material for chosen objects. Settings: `bands` (3), `softness` (0.08), `shadowLift` (0.35), `highlight` (1.0). Two ways to use it, sharing one banding (`sbl_bands` in the `bands` shader module): - **Whole frame:** add the block. It divides the rendered colour by each surface's base colour (copied from the deferred renderer) to find the light that arrived, steps it and puts the base colour back. No material is touched. - **Inside a material:** give chosen objects the `bandedToon` material (or any material on the `bandedToon` shader, or your own shader that includes `bands`). They are banded by their own lighting, which is exact rather than estimated, and they look the same as the full-frame version. Use the block's group mask to keep the full-frame pass off them. ## What it gives up in motion A slow light change, or a light moving past an object, makes band edges sweep across surfaces in steps instead of fading. Noisy light (soft shadows, ambient occlusion) can flicker at band edges; raise `softness`. ## How it treats content - Opaque things: banded by the light that reached them. - Transparent things (glass, water): the base colour behind them is used, so glass is banded as if it were the surface behind. - Particles and smoke: additive particles count as light and push a surface up a band. - Sky: untouched. - Fog: fog adds light, so fogged surfaces step up toward the top band. - Skinned characters: banded like any surface. - Foliage: banded; leaf shading turns into flat patches. - World text: emissive text counts as bright light and lands in the top band. - Black stays black: no light arrives, the band is 0.

# Line boil (styleBlock, Time) Makes every line and wash edge tremble together, redrawn on each step of the held clock, like hand-drawn animation where each frame is traced again. Settings: `amount` (1.6 reference px), `size` (1.5 cells per metre), `calm` (0.5). It draws nothing itself: it publishes the stack's shared wobble, and every block that reads the wobble (the depth line, the sketch line, the flat wash) offsets its edges by it, so a wash and its ink line boil together on one clock. The stack's `holdRate` sets how often it is redrawn (8 steps a second by default). ## What it gives up in motion Edges move a little on every held step even when the world stands still. That is the point of the block, and it never runs faster than the held clock, so it reads as drawn animation rather than as noise. Where one cell of its pattern would cover fewer than about 8 drawn pixels (far ground near the horizon, and more of the picture on the half-resolution low tier) the wobble fades out, full from 8 pixels a cell and none under 3, so it never jumps from pixel to pixel and breaks lines into dashes. The wobble pattern is laid on surfaces, so a pan does not drag it; it is re-seeded each step. The paper does not boil: grounds do not read the wobble. ## How it treats content - Opaque things: their lines and wash edges wobble. - Transparent things (glass, water): no lines of their own, so nothing boils on them. - Particles and smoke: untouched. - Sky: no edges to move, untouched; silhouettes against the sky boil. - Fog: far edges calm with distance (`calm`), so a foggy horizon stays quiet. - Skinned characters: their outlines boil like anything else. - Foliage: leaf outlines boil, which can get busy; lower `amount`. - World text: text outlines boil if a line block draws them; exclude labels that must stay steady. - Black stays black: it moves edges, it adds no light.

The field pass of the Line boil block: publishes the stack's shared wobble on the held clock.

# paper (shader module) The grain of the starterBlocks papers: `sbp_grain(coord, fibre, footprint)` returns a tooth height 0..1 mixing fine tooth, long fibres and soft mottling; `footprint` is how many grain cells one pixel covers (`fwidth` of the coordinate), and every detail finer than about two pixels fades to its mean so the tooth does not shimmer. Include it in a material with `#include "~starterBlocks.blocks.plainPaper.paper"` to give an object the same tooth as the paper ground.

The full-frame pass of the Plain paper block: multiplies the picture onto warm paper with a fine tooth.

# Plain paper (styleBlock, Ground) Lays the whole picture on a warm white paper with a fine tooth, so light areas read as bare paper and every wash and line above shows the grain. Settings: `paper` (warm white), `tooth` (0.35), `fibre` (0.3), `grainSize` (40 cells per metre). As the stack's first Ground block it also publishes the shared ground (paper colour and grain height), which a wash reads to granulate and a line reads to break like dry brush. ## What it gives up in motion The grain is laid in surface coordinates, so it stays on walls and floors as the camera pans and dollies instead of sliding like a screen overlay. The price: on a moving skinned character the grain is taken from world position, so it slides across the body as it moves; and on surfaces seen edge-on the grain stretches. The sky takes its grain from the view direction. ## How it treats content - Opaque things: multiplied onto paper, grain on their surface. - Transparent things (glass, water): multiplied as they appear; the grain is that of the opaque surface behind. - Particles and smoke: multiplied; their grain is that of what is behind them. - Sky: becomes paper tinted by the sky colour; grain by view direction. - Fog: multiplied; fogged distance reads as paper showing through. - Skinned characters: multiplied; grain slides on the moving body (see above). - Foliage: multiplied like any surface. - World text: multiplied; dark text on light stays readable, light text loses a little brightness. - Black stays black: paper multiplies the light, it never adds any.

The field pass of the Plain paper block: publishes the paper colour and grain as the stack's shared ground.

The full-frame pass of the Soft grain style block.

# Soft grain (styleBlock, Medium) Adds a soft film or print grain over the picture, strongest in the mid tones, renewed on the held clock so it never buzzes. Settings: `amount` (0.06), `size` (1.5 reference px), `colour` (0.15), `shadows` (0.4). ## What it gives up in motion Grain belongs to the medium the picture is seen through (film, print, a screen), so it sits on the picture, not on things: that is the one place a mark may stay on the screen. It is renewed on each step of the held clock (8 a second by default), never per frame, and its average brightness never changes, so it does not flash. The Lookbook's screen-stuck test counts it as a medium mark. ## How it treats content - Opaque things: grained in the mid tones. - Transparent things (glass, water): grained as they appear. - Particles and smoke: grained like everything else. - Sky: grained; a clear sky shows it most. - Fog: grained; fog's mid tones carry it. - Skinned characters: grained like any surface, no extra cost. - Foliage: grained. - World text: grain is added scaled by brightness, small enough to keep text readable at the default amount. - Black stays black: grain is scaled by the light already there.

The full-frame pass of the Surface dots style block.

# Surface dots (styleBlock, Tone) Carries shade with a halftone dot screen printed on the surfaces themselves, bigger dots in darker places, like a printed comic, and the dots stay on things as the camera moves. Settings: `ink` (deep violet), `amount` (0.7), `dotsPerMetre` (10), `angle` (45), `threshold` (0.3), `maxCover` (0.7). ## What it gives up in motion Dots live on surfaces (laid along each surface's main axis in the stack's shared coordinates), so a pan or dolly does not drag them. Because they are sized in metres, they get smaller on screen with distance; where a dot cell would fall under about three pixels the dots melt into an even tone, so a floor grazing to the horizon does not shimmer. On a moving skinned character the dots come from world position and slide across the body. Curved surfaces switch dot direction where their main axis changes, which shows as a seam. ## How it treats content - Opaque things: dotted in their darker places. - Transparent things (glass, water): dotted with the coordinates of the opaque surface behind them. - Particles and smoke: dotted where they darken a surface, with that surface's coordinates. - Sky: never dotted. - Fog: fog lightens things, so far away there are fewer dots. - Skinned characters: dotted; dots slide on the moving body. - Foliage: dotted; dense leaves can look busy, lower `amount`. - World text: dark letters can collect dots; exclude labels. - Black stays black: dots darken, they add no light.

The full-frame pass of the Vignette style block.

# Vignette (styleBlock, Medium) Darkens the corners of the picture softly, like an old lens or a framed print, to pull the eye to the middle. Settings: `amount` (0.35), `radius` (0.55), `softness` (0.5), `roundness` (0.7), `tint` (warm near black). The corners are multiplied toward the tint, so they darken and never brighten. ## What it gives up in motion It belongs to the lens, so it is fixed to the screen by design. Things moving into a corner darken as they go; nothing flickers. ## How it treats content - Opaque things: darker toward the corners. - Transparent things (glass, water): the same. - Particles and smoke: the same. - Sky: the top corners darken, which frames a sky well. - Fog: the same. - Skinned characters: the same. - Foliage: the same. - World text: labels near the corners darken; the UI is drawn after the stack and is never touched. - Black stays black: it only multiplies.

# styleBlock (asset type) A styleBlock is one stackable piece of an art style. It sits in one of ten slots (Surface, Light, Fill, Tone, Line, Colour, Ground, Time, Raster, Medium), it states what it reads and what it writes, and the styleKit stack runs it over the whole frame after antialiasing. Any block swaps for any other block of its slot with no other change. ## Folder shape A block is a plain folder holding the block asset and its shader side by side: ``` blocks/posterize/ posterize.styleBlock/ the block: block.yaml, README.md, .metadata (all required) posterize.shader/ the post-process shader the stack runs posterizeField.shader/ optional: the shader that writes a shared field (Ground or Time blocks) posterize.shaderModule/ optional: the piece a material includes for a chosen set of objects ``` Paths in `block.yaml` are relative to the plain folder. The shader sits beside the `.styleBlock` rather than inside it, because a shader nested inside another asset folder is not listed by the engine and could not be found without a computed lookup that would block publishing. The quickest way to start one is `StyleKit.newBlock("myTint", { slot = "colour" })` (written to `/zero/source/myBlocks/myTint`, or the `folder` you pass), which writes the whole folder, block and shader, and registers it at once. `asset.create("styleBlock", name, { slot = "line" })` writes only the `.styleBlock` files; write the `<name>.shader` beside it yourself. ## block.yaml ```yaml name: "Posterize" slot: colour # surface light fill tone line colour ground time raster medium version: "1.0.0" summary: "Cuts the picture into a few flat tone steps." reads: [frame] # frame depth normal albedo motion ground wobble clock mask soft pigments rendered paper sun writes: [frame] # frame, and field:ground, field:paper (Ground) or field:wobble (Time) when it has a field stacking: layer # optional: layer (default) or chain rank: 10 # optional: StyleKit.add places it before the first block of its slot with a higher rank shader: posterize.shader # relative to the plain folder field: { name: ground, shader: plainPaperField.shader } # optional, Ground and Time only include: posterize.shaderModule # optional settings: # every non-sk_ property of the shader, with what it means levels: "How many steps each channel keeps." defaults: # optional: this block's own defaults over the shader's (many blocks, one shader) levels: 4 quality: # optional per-tier overrides of settings low: { samples: 4 } ``` A Ground block's `field` may also name a paper-field shader and say that it layers (styleKit 1.2.0): ```yaml field: { name: ground, shader: paperField.shader, paper: paperTakes.shader, layers: true } writes: [frame, field:ground, field:paper] ``` - `paper`: a shader that publishes the paper field (`sk_paper`: r thirst -1 hard-sized to +1 thirsty, 0 the standard sheet; g sheen; b fibre; a dark ground 0 to 1) for blocks that read `paper`. It is run only when a live block reads it. A Ground block without one leaves the paper field neutral (every value 0). Add `field:paper` to `writes`. - `layers: true`: when this block is not the first Ground block in the stack, it lays its ground (and its paper field) over the one before by its strength and mask, instead of being ignored as a later field. Its field shaders receive the field before as `sk_ground` / `sk_paper` and mix over it (`sk_view.y` is 1 when they are layered). `defaults` lets several blocks share one shader (paperBlocks' seventeen papers run on one): each key must be a setting the shader declares, it overrides the shader's default for this block on every tier (`quality` overrides come after it, an entry's own settings last), and `StyleKit.settingsOf(id)` reports it as the block's default. The shader's `properties.yaml` starts with the styleKit shared header (the `sk_` properties) and then declares the block's own settings with their defaults and ranges. `StyleKit.checkBlock(id)` reports anything missing. ## Stacking and rank - `stacking: layer` (the default): every block in a slot reads the slot's input, and later ones are laid over the earlier ones by strength and mask. - `stacking: chain`: the block reads what the blocks before it in its slot made, so modifier blocks build on each other (a wash, then its granulation, then its darkened edges). - `rank: <number>`: `StyleKit.add` places the block before the first block of its slot with a higher rank, so a chain lands in its intended order whatever order its blocks are added in. ## Extra inputs Five inputs come after the shared header, each declared straight after it and bound by the stack only when `reads` lists the matching word: - `sk_soft` (`reads: soft`): a half-resolution, depth-aware blur of what the block reads, never smearing a nearer thing over a farther one. Read it through the `skSoft` shader module (`sk_soft_at`, `sk_soft_wide`, `sk_soft_depth`, `sk_soft_in_front`). Its width is the stack option `softRadius`. - `sk_pigments` (`reads: pigments`): the scene's pigment set as a 16 x 1 palette. Read it through the `skPigmentSet` shader module (`skg_has_set`, `skg_pigment`, `skg_shadow`, `skg_light`, `skg_air`, `skg_remix`). - `sk_rendered` (`reads: rendered`): the frame as it entered the stack, before any block changed it. Read it through the `skRendered` shader module (`sk_rendered_at`). Its use is a light estimate against `sk_albedo` (texture cancels out) or an original colour to restore. - `sk_paper` (`reads: paper`, a texture, default black): the paper field the Ground blocks publish. Read it through the `skPaper` shader module (`sk_thirst`, `sk_sheen`, `sk_fibre`, `sk_dark_ground`). Where no Ground block publishes it every value is 0, so the block draws as it did without it. A Ground block's own paper-field shader declares it to read the field laid before it, without listing `paper` under reads. - `sk_sun` (`reads: sun`, a float4): the direction toward the scene's first directional light, `w` 1 when it gives light. Read about once a second. Raking light and sheen use it. `StyleKit.checkBlock` refuses a block that declares one of them without the word under `reads`, or lists the word without declaring the texture. When an asset of this type registers on any machine (world load, install, a collaborator's new block arriving), the type's `onRegister` hands it to the styleKit library, so `StyleKit.blocks()` lists it and a stack can use it at once.

# styleKit Build your own art style out of stackable look blocks: a look is a stack of small blocks (a wash, an ink line, a paper, a grain) that runs over the whole frame after antialiasing, lives in the scene and looks the same for every player. Version 1.2.3. ## Install and use Install **styleKit** from ZeroMind (search "styleKit" or "stackable art style blocks"). Installs with several dependencies can be slow (#21420), so give an install time to finish and check `/zero/source` for the package folder. Then, from the console or any script, stack one of each of the kit's four example blocks: ```luau local StyleKit = require("~styleKit.StyleKit") StyleKit.add("posterize") -- Colour: a few flat tone steps StyleKit.add("duotone", { strength = 0.5 }) -- Colour: two inks, laid half over the posterize StyleKit.add("depthLine") -- Line: a clean ink outline from depth StyleKit.add("sketchLine", { strength = 0.6 }) -- Line: soft pencil strokes laid over the outline print(#StyleKit.describe().entries) -- 4 StyleKit.clear() -- the frame is exactly as rendered again ``` No material is edited. The first `add` makes a synced `StyleStack` entity in the scene, so every player draws the same stack; put a `StyleStack` component in your scene's build to keep a look with the scene. ## The blocks in this package | Block | Slot | What it does | |---|---|---| | `posterize` | Colour | Cuts the picture into a few flat tone steps, like a screen print. | | `duotone` | Colour | Maps the picture onto a shadow ink and a light ink. | | `depthLine` | Line | A clean, one-sided ink outline from depth plus creases from normals. | | `sketchLine` | Line | Soft, broken pencil strokes over shape and colour edges, redrawn on the held clock. | | `sharedView` | Medium | A diagnostic for block authors: shows one shared input in place of the picture. | Every block lists its slot and its tags (the words a person would search for: `watercolor`, `pencil`, `halftone`, `pixel art`, `chalk`), so you can pick blocks by tag with `StyleKit.blocks({ tag = "pencil" })` or `zero styleKit list --tag pencil`. A block's tags come from its `block.yaml` `tags:` list when it has one, otherwise from its `.metadata` tags. More blocks come in their own packages and plug straight in: `starterBlocks` has a block for every slot (card surface, light bands, flat wash, surface dots, plain paper, dark board, line boil, chunky pixels, soft grain, vignette), `watercolorBlocks` has ten chained watercolor Fill blocks and a cold-press paper, with pigment sets, whole looks and a hero material, `inkBlocks` has five ink lines, four ink fills, ink colours and whole looks, and `paperBlocks` has seventeen papers (cold press, rough, hot press, rice, newsprint, kraft, parchment, canvas, board, blackboard, green chalkboard, black paper, aged sketchbook, toned grey and tan, ruled notebook, vellum) that publish the paper field and layer by region. `StyleKit.blocks()` lists every block installed. A package can also ship pigment sets (`pigmentSet` assets: `StyleKit.pigmentSets()`) and whole looks (`styleLook` assets: `StyleKit.looks()`) next to its blocks. ## How a stack works A stack is an ordered list of entries `{ id, block, on, strength, mask, settings }` on a `StyleStack` component. Blocks sit in ten slots that always run in this order: 1. **Surface**: what things are made of. 2. **Light**: how surfaces take light. 3. **Fill**: how areas of colour are laid. 4. **Tone**: marks that carry shade. 5. **Line**: edges. 6. **Colour**: palette and grade. 7. **Ground**: what it is drawn on. The first Ground block publishes the shared ground (and the paper field, when it has one); a later Ground block whose field says `layers: true` lays its ground over the one before by its strength and mask. 8. **Time**: how motion is held. The first Time block publishes the shared wobble. 9. **Raster**: how the image is sampled. 10. **Medium**: what it is seen through. Any slot can be empty. Any block swaps for any other block of its slot with no other change (`StyleKit.swap(entry, otherBlock)`); strength and mask stay. Inside a slot the list order decides: the first block reads the slot's input, and every later block in the same slot reads the same input and is laid over it by its strength and mask (`stacking: layer`, the default). So two Line blocks with weights 1 and 0.4 blend 60 / 40, and two Fill blocks with complementary masks split the frame. A block whose `block.yaml` says `stacking: chain` reads what the blocks before it in its slot made instead, so modifier blocks build on each other (a wash, then its granulation, then its darkened edges). A block's `rank: <number>` decides where `StyleKit.add` places it: before the first block of its slot with a higher rank, so a chain lands in its painting order whatever order its blocks are added in. ### Keeping a stack A stack made with these calls is a live edit of the scene, like moving a prop. Save the scene (`layers.active:save()` or the editor's save) and the stack is in its `scene.json`: it comes back on every load and after a restart, the same for every player. `StyleKit.clear()` takes every block off the frame; to get the saved stack back, revert the scene (`tools.use("scene", "revert")`). `scene.reload` keeps live edits by saving them first, so a clear followed by a reload is a saved clear. Keep one StyleStack per scene. ### Shared by every block in a stack - **One clock.** `sk_time()` and the held clock `sk_held()` / `sk_step()`, stepped at the stack's `holdRate` (8 per second by default). Every wobble and boil runs on the held clock. - **One set of coordinates that stay on things.** `sk_surface_coord(uv, perMetre)` lays marks on surfaces from world position along each surface's main axis, and on the sky from the view direction, so a pan or a dolly does not drag them. - **Surface data copied once per frame**: view distance, world position, normal and base colour (`sk_dist`, `sk_world`, `sk_normal`, `sk_albedo`). - **One ground** (`sk_ground_at`): paper colour and grain height, published by the first Ground block (plain white paper with flat grain when there is none). - **Layered grounds** (since 1.2.0): a later Ground block whose `block.yaml` field says `layers: true` lays its ground, and its paper field, over the one before by its strength and mask, so regions of a world sit on different papers: `StyleKit.add("paperParchment", { id = "mapRoom", mask = { kind = "sphere", center = { 30, 2, 10 }, radius = 6 } })`. A Ground block without `layers: true` publishes only when it is the first. - **One paper field** (`sk_paper`, read through `skPaper`, since 1.2.0): how the sheet under each pixel takes paint and ink, for a block that lists `paper` under `reads`: `sk_thirst(uv)` (-1 hard-sized, 0 the standard sheet blocks are tuned on, +1 thirsty), `sk_sheen(uv)`, `sk_fibre(uv)` and `sk_dark_ground(uv)` (1 where the sheet is dark and the picture is made of light marks). A Ground block publishes it with a `field.paper` shader; where none does every value is 0, so a block reading it draws exactly as before. It is only made when some live block reads it. paperBlocks' papers publish it; watercolorBlocks' bleed and edge darkening and every inkBlocks block read it. - **The scene's sun** (`sk_sun`, a float4, since 1.2.0): for a block that declares it and lists `sun` under `reads`, the direction toward the scene's first directional light, `w` 1 when it gives light (0, and a default direction, when there is none). Read about once a second through the lighting toolbox, so a moving sun reaches blocks within a second. Raking light on paper tooth and sheen use it. - **One wobble** (`sk_wobble_uv`): an offset published by the first Time block (still when there is none). A wash and an ink line that both read it tremble together. - **One pattern library** (`skPatterns`): noise, fractal noise, cells, dots, hatching, ordered threshold, triplanar noise for materials (`skp_triplanar_fbm`) and brush strokes (`skp_stroke`). - **One soft field** (`sk_soft`, read through `skSoft`): a half-resolution, depth-aware blur of what a block reads, for a block that lists `soft` under `reads`. Each tap is tested against the centre surface's plane rebuilt from world positions, so a nearer thing is never smeared over a farther one. The stack makes it for the first block that reads it and makes it again whenever a later reader reads a different image; its width is the stack option `softRadius` (reference pixels, 10 by default). - **One pigment set** (`sk_pigments`, read through `skPigmentSet`): the scene's palette of paints as a 16 x 1 texture, for a block that lists `pigments` under `reads`. `StyleKit.setPigments(id)` changes it for every block and every player at once; with none picked blocks keep the scene's own colours. - **One rendered frame** (`sk_rendered`, read through `skRendered`): the frame as it entered the stack, for a block that lists `rendered` under `reads`. Light estimates read it against the base colour, so surface texture cancels instead of printing back as shade. With `sk_geo_normal` (a normal rebuilt from world positions, every tier) it lets a block judge light and shape on the low tier and the forward path too. - **One way to mix paint** (`skPigment`): pigment mixing in transmittance and optical density (log space), two pigments in one wash, glazes that multiply, dilution toward the paper. Pure math, so a full-frame block and a material mix paint the same way. - **Noise that stays on things and keeps its size** (`skAnchored`): triplanar noise on world position that stays on still things (`sk_anchored_fbm`, `sk_anchored_cells`), and noise that also keeps its size in the picture at any distance by blending two octaves by distance (`sk_scaled_fbm`, `sk_scaled_level`, `sk_surface_plane`, `sk_ref_metres`), for paper tooth, flecks and strokes. `sk_tooth(uv)` reads the shared paper's valleys (0 on a peak, 1 in a valley). - **Chain stacking** inside a slot (`stacking: chain` and `rank` in `block.yaml`): later blocks build on what the ones before them made. - **Many blocks, one shader** (`defaults:` in `block.yaml`, since 1.2.0): a block's own defaults over its shader's, so a family of blocks (paperBlocks' seventeen papers) shares one shader and each block is its own starting point. `StyleKit.settingsOf(id)` reports the block's defaults. - **Swap memory** (since 1.2.0): each stack entry remembers the settings of every block it has held, so `StyleKit.swap("paper", "paperKraft")` then `StyleKit.swap("paper", "inkPaper")` puts back exactly the settings `inkPaper` had, and the frame returns exactly. The memory is kept on the entry in the synced stack, so it is shared and saved with the scene; `load` and `applyLook` write new entries without it. - **One exit** (`sk_finish`): strength, mask, layer mode, and black stays black: a block never makes light where the frame had none. ### Masks `StyleKit.setMask(entry, mask)` limits a block: - `{ kind = "depth", near = 0, far = 12, soft = 0.2 }`: by view distance in metres. The soft edges lie outside the band and scale with their own distance: the block fades in over `soft` x `near` metres before `near` and out over `soft` x `far` metres after `far`, so nothing nearer than `near` x (1 - `soft`) is touched, whatever `far` is. The sky lies at the viewing camera's far distance (its `Camera.far`, 8000 m by default): a band whose `far` reaches that distance takes the sky in, a shorter one leaves it out. - `{ kind = "rect", rect = { x0, y0, x1, y1 } }`: a screen region in 0..1 (top left is 0, 0). - `{ kind = "sphere", center = { x, y, z }, radius = 5 }`: a region of the world. - `{ kind = "group", group = 1 }`: the objects in mask group 1, 2 or 3 (`StyleKit.options({ groups = { { id, id }, { id } } })`). - `invert = true` flips any of them. `StyleKit.options({ exclude = { "SignBoard" } })` leaves objects (and their children) exactly as rendered: a prop, a world label. Name them: an entry is an entity name or an id, and a scene should store names, because an id written into the stack does not survive the scene being saved and loaded again (the entity comes back under a new id). Entities that arrive later are picked up within half a second. Put labels on a card of their own (a plain white quad behind the words), so the area left out around them is card rather than the raw scene. ### Quality The stack follows the device's quality tier (`renderer.qualityTier()`), and the tiers really change the cost: - `high` and `medium`: every block pass and every shared input at full resolution. `medium` also applies each block's `quality.medium` settings where it states them. - `low`: the shared inputs (surface data, ground, wobble) and the block chain itself run at half resolution, a quarter of the pixels for every pass, and blocks take their `quality.low` settings (fewer samples, fewer strokes). The copy of base colour and normals is made on `low` too, at that half resolution (since 1.1.4), so a block judges light and lays marks by the same rules on every tier and a look stays the same look; only the forward render path, which keeps no g-buffer, goes without it. The result is scaled up once at the end, before the UI; excluded objects are put back from the full-size frame, so they stay crisp. Measured on the Lookbook's textured wall at 2097 by 1409 with a wash, a sketch line, paper, boil and dots: 1.64 ms of block passes at full resolution, 0.30 ms on `low` (before the half-size copy, which adds one small compute pass). On `low`, marks are drawn at half resolution and so are softer: the honest trade for running on a small device. `StyleKit.setQuality("low")` forces a tier on this machine; `StyleKit.setQuality(nil)` follows the device again. The Lookbook measures the cost per pass at each tier. ### Whole frame or inside a material Every block works on the whole frame with no material edits. Where it means something, a block also ships a shader module a material includes for a chosen set of objects (`include:` in its `block.yaml`), for example starterBlocks' Stepped light, whose `bandedToon` shader bands a material by the same rule. Use a group mask to keep the full-frame pass off those objects. ## API | Call | What it does | |---|---| | `StyleKit.blocks(filter?)` | Every block installed: `{ id, name, slot, tags, summary, reads, writes, settings, package, path }`. Filter by `slot`, `package`, `tag` (one tag or a list, all must match) or `text` (which also searches tags). In the shell: `zero styleKit list`, `zero styleKit list line`, `zero styleKit list --tag pencil`. | | `StyleKit.block(id)` / `settingsOf(id)` | One block / its settings with docs, defaults (the block's own `defaults:` where it states them) and ranges. | | `StyleKit.add(id, opts?)` | Add a block (`strength`, `mask`, `settings`, `id`, `index`). Returns `ok, entryId`. | | `StyleKit.remove(entry)` | Remove an entry (by entry id, block id or position). | | `StyleKit.swap(entry, id, opts?)` | Swap an entry's block for another of its slot; strength and mask stay. The entry remembers the settings of every block it held, so a block swapped back in gets exactly the settings it had (a block it never held starts from its defaults). `{ keepSettings = true }` carries the current settings across instead; `{ anySlot = true }` allows a swap across slots. | | `StyleKit.move(entry, index)` | Reorder (orders blocks inside a slot). | | `StyleKit.setStrength(entry, 0..1)` / `setOn(entry, bool)` | Weight / switch an entry. | | `StyleKit.setMask(entry, mask?)` | Limit an entry by depth, region or group. | | `StyleKit.set(entry, { name = value })` | Change settings. Colours take `"#rrggbb"`, `{ r, g, b }` or `{ r, g, b, a }`. | | `StyleKit.load(entries, opts?)` / `clear()` | Replace / empty the stack. `opts`: `holdRate`, `markScale`, `pigments`, `softRadius`, `look`. | | `StyleKit.options({ holdRate, markScale, exclude, groups, active, pigments, softRadius })` | Stack-wide options. `pigments` is a pigment set id (`""` for none); `softRadius` is the soft field's width in reference pixels (2 to 40, default 10). | | `StyleKit.pigmentSets(filter?)` / `pigmentSet(id)` | Every pigment set installed: `{ id, name, summary, tags, pigments = { { name, colour, granulation } }, shadow, light, air, package, path }`, filtered by `package`, `tag` or `text` / one set by id. | | `StyleKit.setPigments(id)` | Pick the pigment set every block that reads pigments mixes from, for the whole stack and every player. `""` picks none, so blocks keep the scene's own colours. | | `StyleKit.looks(filter?)` / `look(id)` | Every whole look installed (`styleLook` assets): `{ id, name, summary, tags, entries, pigments, holdRate, markScale, package, path }` / one look by id. | | `StyleKit.applyLook(id, opts?)` | Apply a whole look in one change: its blocks replace the stack and its pigment set, hold rate, mark scale and soft radius are set with them. `{ keep = { "line" } }` keeps the entries of the slots named from the current stack. A look naming a block that is not installed is refused and nothing changes. | | `StyleKit.describe()` | What is in the stack, in run order, its `pigments`, `look` and `softRadius`, and what the runtime drew last frame. | | `StyleKit.checkBlock(id)` | Problems with a block against the block rules (empty when it passes). | | `StyleKit.newBlock(name, { slot, folder })` | Write a working block of your own to start from. | | `StyleKit.quality()` / `setQuality(tier?)` | The tier the stack draws at / force one here. | | `StyleKit.setClock(fn?)` | Drive the stack's one clock (boil, grain, wobble) from your own time in seconds, for a cutscene, a recording or the Lookbook; `nil` returns to the shared clock (wall-clock UTC, the same held step on every player's machine). | Writes go through the stack's owner, so in play any player can change the shared stack and every player sees the change. The `styleKit` toolbox offers the same from the shell (`zero styleKit list`, `zero styleKit stack`, `zero styleKit add posterize`). ## Writing a block A block is a plain folder holding `<name>.styleBlock/` (block.yaml, README.md, .metadata) and its `<name>.shader/` (a post-process shader whose `properties.yaml` starts with the styleKit shared header). `newBlock` writes one that works and registers it at once: ```luau local StyleKit = require("~styleKit.StyleKit") local path = StyleKit.newBlock("warmTint", { slot = "medium", title = "Warm tint" }) print(path) -- /zero/source/myBlocks/warmTint/warmTint.styleBlock StyleKit.add("warmTint", { strength = 0.6 }) -- a warm filter over the whole look StyleKit.set("warmTint1", { tint = "#ffcf8a" }) -- its setting, like any block's ``` Then edit `/zero/source/myBlocks/warmTint/warmTint.shader/shader.wgsl` to make it do what you want; the stack picks up the change as you save. To share blocks, move their folders into the `blocks/` folder of a package of your own (a `<name>.package` folder with its `package.yaml`): a package that holds blocks adds them to every world that installs it, with no code. The guide "Writing your own style block" walks the whole shape every block follows. ## Rules every block follows - It states its slot, what it reads and what it writes, and takes over nothing it does not own (a Ground block alone writes the ground, a Time block alone the wobble). - Every setting is named, documented in `block.yaml` and has a good default in its shader. - Marks stay on things unless the medium really is a screen (pixels, grain, a vignette), and they run after antialiasing and upscaling. - Wobble runs on the held clock. - Its README says what it gives up in motion and how it treats opaque things, transparent things, particles, sky, fog, skinned characters, foliage and world text. - With every light off the frame stays black (`sk_finish` holds every block to it). - The UI is drawn after the stack, so it stays readable. - No full-screen flashing above 3 Hz and no fine high-contrast stripes filling the view. `StyleKit.checkBlock` and the `styleKit` test suite check the rules that can be read from files. ## Guides and workflow This package carries its guides (search them with the `guides` tool or ZeroMind): combining blocks into your own art style, how to use styleKit, writing your own style block, and a worked example from an empty world to a small stylized game. The `restyleWorld` workflow gives an existing world, scene or kit a new look non-destructively, and the `styleKit` agent skill tells an agent what it can do with blocks. ## What a look costs GPU milliseconds per frame of the style passes, 3D view drawing at 1893 x 1072 (98% of a 1920 x 1080 frame's pixels), measured with the Lookbook (`zero lookbook cost 1920 1080 true`) over its pan on a desktop GPU. The rest of the frame (scene, shadows, antialiasing) is not counted. Low quality runs the whole chain at half resolution. | Look | High | Low | |---|---|---| | README example: posterize, duotone 0.5, depthLine, sketchLine 0.6 | 0.60 | 0.11 | | Cookbook: flatWash, depthLine, plainPaper, lineBoil, softGrain 0.6 | 1.03 | 0.21 | | Comic: lightBands, surfaceDots, depthLine, posterize | 0.41 | 0.10 | | Chalk: depthLine, darkBoard | 0.43 | 0.10 | | Retro: posterize, chunkyPixels, softGrain, vignette | 0.22 | 0.07 | Each block alone, high / low: flatWash 0.45 / 0.07, sketchLine 0.32 / 0.06, darkBoard 0.24 / 0.07, plainPaper 0.23 / 0.07, depthLine 0.19 / 0.04, cardSurface 0.11 / 0.03, lightBands 0.09 / 0.03, surfaceDots 0.09 / 0.03, softGrain 0.09 / 0.03, lineBoil 0.06 / 0.02, chunkyPixels 0.06 / 0.02, posterize 0.05 / 0.02, duotone 0.04 / 0.02, vignette 0.04 / 0.02. A look costs a little less than its blocks added up, because the shared inputs (depth, surface coordinates, ground) are made once per frame for the whole stack. **Frame rate and the web.** On the web the Cookbook look was measured at about 29 to 30 fps in the Cookbook scene (one sample 25), against about 43 fps with no look, and the low tier did not change it: the look cost about 10 ms a frame there while its passes took about 1 ms of GPU time. That measurement is of styleKit 1.0.6. The cost was not the shading but the work around it, which a browser pays several times over: 15 screen-sized images made up front whatever the look, 11 passes, and engine calls every frame for every effect. 1.0.7 cuts it, measured on desktop: the Cookbook look now makes 7 images on high and 5 on low (was 15), runs 9 passes on high and 8 on low (was 11), and spends 0.19 ms of Luau a frame on high and 0.12 ms on low (was 0.40 ms on both), so low now saves passes and Luau, not only pixels. **Whether 1.0.7 holds 30 fps on the web is not measured yet:** an agent cannot start a browser engine (#20946), and in the desktop editor the whole-frame rate swings more from the editor's own load than the look costs, so no desktop fps is quoted here. `zero lookbook report` now starts with the frame rate in the scene you are in (no look, the look on high, on low, measured in turns), so one run in the web build gives the answer. The web limits it may still meet are open engine issues: #20750 (web frame rate), #17441 (cost of scene-colour features) and #17478 (post tiers on mobile). ## How it runs The `styleStack` render feature starts on a machine as soon as the scene's stack holds a live block (one that is on, has strength above 0 and is installed), on every player's machine alike. Each frame it copies the base colour and normal from the deferred g-buffer at `afterLighting`, then at `afterScenePost` (after antialiasing and the render-scale upscale, before the UI) it rebuilds world position and distance from depth, copies the frame, publishes the ground and wobble, runs each slot, puts excluded objects back and hands the result to the screen. A frame of the Cookbook look runs 9 passes: the copy of base colour and normals (only when a live block reads them, and never on the low tier), world position, the two shared fields, one pass per block, and the hand-off to the screen; the blocks read the scene directly, so there is no copy of the frame first. Only five screen-sized images are made up front (the chain's two, world position and the two fields); the rest are made the first time a look uses them (group masks, excluded objects, the base colour and normal copies). The Luau work per frame is a few calls into the engine: uniforms, settings and mask groups are written only when the stack, the tier or the camera's frame inputs change, and the clock only when the held step moves. When the stack holds no live block (after `StyleKit.clear()`, or with every entry off) the kit lets everything of its own go within two frames: every block effect and its five internal effects are removed from the screen effect list, its screen targets, buffer and mask materials are freed, and the render feature itself ends. `StyleKit.holdsAnything()` then reads false, and the first block added brings it all back. ## Known limits - **Offscreen captures and render-to-texture cameras do not draw the stack.** The stack runs at `afterScenePost`, which only the presented frame reaches, so `capture` with `source = "main"`, `"entity"` or `"position"` shows the unstyled scene; use `source = "presented"` or `renderer.presentedFrames`. Per-camera post: engine issues #66 and #17427. - **Depth in a feature's fragment pass reads 0 after post.** `zero_scene_depth` is not bound to a render feature's fragment pass at `afterScenePost`, so the kit copies depth with a compute pass once per frame and blocks read that copy (#17427). - **G-buffer channels are refused after post**, so base colour and normal are copied at `afterLighting`. On the forward path there is no base colour: Surface and Light blocks fall back to working from brightness alone. - **Marks on moving objects.** Surface coordinates come from world position, so marks stay put on still things under any camera move, but slide across a moving skinned character or a moving prop. Object-space coordinates need per-object data a full-frame pass does not have, so marks that stay on a moving object can only be drawn inside its material: watercolorBlocks' `watercolorSurface` shader shows how, carrying the object's own position from `vertex_clip` (`local_position`) to the fragment in the vertex colour (applied with `WatercolorHero.paint`). - **The soft field costs two half-resolution passes each time a reader reads a new image.** In a chain, a later block that reads `soft` reads a different picture from the first one, so the field is made again for it; keep soft readers few, or next to each other on the same input, on small devices. - **Post effects get one pass each and no history** (#17427): a block cannot read the previous frame or its own last output, so nothing in a block can build up or settle over time. - **Effect uniforms reset on recompile** without notice; the runtime renews its writes twice a second, so after a shader edit a setting can take up to half a second to come back. - **One held clock for every player, as close as their clocks are set.** Since 1.1.3 the held clock runs on wall-clock UTC (caught to the frame from `os.time()` ticking over), so every machine shows the same boil step at the same moment; machines whose clocks are set by the network agree to a few hundredths of a second, so two screens differ only in that sliver around each step. A machine whose clock is set wrong boils out of step with the others. `StyleKit.setClock` drives it from a time of your choosing instead, so a cutscene or the Lookbook repeats exactly. - **Transparent things and particles have no depth**, so lines and surface marks treat them as the opaque surface behind them; each block's README says how. - **Stage order** (#17426, #17439): blocks rely on `afterScenePost` running after the TAA resolve and the upscale, as the engine documents today. - **One stack per scene.** With two StyleStack entities in a scene the kit draws the last one it found; keep one, and change it rather than adding a second. - **After a scene switch** the engine can free the stack's screen targets; the runtime notices within about two seconds and rebuilds them, so the look can be missing for that moment. - Post-process shaders have no preview image, so the shader previews in this package are absent. ## Version history **1.2.3 (2026-11-02)**: the scene's sun is written to every block that reads it again twice a second, like every other shared value, so a block whose shader was compiled or recompiled after its sun was written (the first use of a block in a fresh install, a hot reload) no longer draws without its sun until the sun moves. This was why paperBlocks' Lookbook numbers changed from run to run. And outline ink: a surface that publishes metallic 3/255 with roughness 251/255 (toonBlocks' outlines) is copied with base colour known 0.5, `sk_is_ink(uv)` answers it, and every block, which takes base colour only above 0.5, leaves drawn ink as drawn. `StyleKit.VERSION` says 1.2.3. **1.2.2 (2026-11-01)**: the scene's sun (`reads: sun`, `sk_sun`) is read every 4 frames instead of about once a second, at once whenever the stack changes, and every frame while someone drives the clock (`StyleKit.setClock`, as the Lookbook does). A block that rakes light from the sun (paperBlocks' papers) no longer steps once a second under a moving sun, and no longer draws its first second with the sun of the scene or run before it, which had made Lookbook runs depend on what ran before them. `StyleKit.VERSION` says 1.2.2 (it had stayed at 1.2.0). **1.2.1 (2026-11-01)**: documentation only: install notes describe how installing works (install from ZeroMind search; installs with several dependencies can be slow) without naming internal ticket numbers. **1.2.0 (2026-11-01)**: the paper field, a second shared ground input (`reads: paper`, `sk_paper`, read through `skPaper`: thirst, sheen, fibre, dark ground), published by a Ground block's `field.paper` shader, neutral where none does and made only when a live block reads it; layered grounds (`field.layers: true`: a later Ground block lays its ground and paper field over the one before by its strength and mask, so regions of a world sit on different papers); the scene's sun for blocks that declare `sk_sun` (`reads: sun`); `defaults:` in `block.yaml` (per-block defaults over the shader's, reported by `settingsOf`, so many blocks share one shader); swap memory (each entry remembers the settings of every block it held, so swapping back returns the frame exactly; `keepSettings` carries settings across instead). `checkBlock` knows `field:paper` (Ground only), `sk_paper` and `sk_sun`, and a default for a setting the shader lacks. **1.1.0 (2026-10-31)**: blocks can build on each other inside a slot (`stacking: chain` in `block.yaml`; `layer` stays the default) and take a place in it (`rank`); two extra inputs a block may declare after the shared header, the soft field (`sk_soft`, a half-resolution, depth-aware blur, width `softRadius`, read through `skSoft`) and the scene's pigment set (`sk_pigments`, read through `skPigmentSet`); pigment mixing in optical density (`skPigment`), noise that stays on things and keeps its size in the picture (`skAnchored`), `skp_triplanar_fbm`, `skp_stroke` and `sk_tooth`; two new asset types, `pigmentSet` and `styleLook`, with `pigmentSets`, `pigmentSet`, `setPigments`, `looks`, `look` and `applyLook`; `options` and `load` take `pigments` and `softRadius`, `describe()` returns `pigments`, `look` and `softRadius`, and the StyleStack carries them as synced fields. **1.1.5 (2026-11-01)**: documentation only: Known limits and the using-styleKit guide said the held clock was each machine's own and out of step between players; since 1.1.3 it runs on wall-clock UTC and every machine shows the same boil step. Both now say so. **1.1.4 (2026-11-01)**: the `low` tier makes the copy of base colour and normals too, at its half resolution, so a block judges light and lays marks by the same rules on every tier (a look on `low` had stopped being the same look: light read from brightness turned dark materials grey and put mid-tone marks on lit walls). `sk_mark_normal(uv)` gives marks a surface facing on every path, rebuilt from neighbouring world positions where no normal was copied, and `sk_surface_coord`, `sk_surface_plane`, the triplanar noise and `sk_ref_metres` use it, so a wall is never projected as a floor (which smeared marks down their columns into vertical stripes). **1.1.3 (2026-11-01)**: the stack's held clock runs on wall-clock UTC (caught to the frame from `os.time()` ticking over), so every player's machine holds the same boil step at the same moment instead of each running its own; the step number wraps every 65536 steps at the same moment everywhere, so shaders keep every digit. `StyleKit.setClock(fn)` still drives it for a cutscene or the Lookbook. **1.1.2 (2026-11-01)**: `exclude` and group lists take entity names as well as ids (an id stored in a scene does not survive a save and load, so a scene's left-out board or labels were being painted over), and entries that find nothing yet are looked for again twice a second; a stack whose component was removed and added again is let go instead of refusing every change. **1.1.1 (2026-10-31)**: a third extra input, the frame as rendered (`reads: rendered`, `sk_rendered`, `skRendered`), for light estimates that do not print surface texture back; `sk_geo_normal` (a normal from world positions on every tier); and `sk_albedo` and `sk_normal` answer "unknown" when no g-buffer copy was made (low tier, forward path) instead of reading a stale frame. **1.0.8 (2026-10-31)**: store listing rewritten for creators; built on the current engine library (@builtin 0405ea4). **1.0.7 (2026-10-31)**: a depth mask's near limit holds whatever `far` is (each soft edge now scales with its own distance, not the whole band) and the sky lies at the camera's far distance; blocks list their tags and `blocks({ tag })` and `zero styleKit list --tag` pick by them; a lighter frame for the web: images made only when a look uses them (7 on high, 5 on low, was 15), no copy of the frame before the chain, no base colour copy on low or when no block reads it, and uniforms, settings and the clock written only when they change (Luau per frame 0.19 ms high, 0.12 ms low, was 0.40). **1.0.6 (2026-10-31)**: clearing the stack leaves nothing of the kit behind (every effect, target, buffer and the render feature are released within two frames, and `StyleKit.holdsAnything()` says so); the renderer starts only for a live block, on every machine; a per-look GPU cost table at 1080p; the wrong "black floor of 17" limit is gone (it was the Lookbook panel); the shared black guard now caps a dark pixel at its own brightness and its own brightest channel, so no block, alone or stacked, lightens an unlit frame (worst of all fourteen: +0.17 of 255). **1.0.5 (2026-10-31)**: `StyleKit.setClock` drives the stack's clock from a time of your choosing, so boil, grain and wobble repeat exactly in a cutscene, a recording or the Lookbook. **1.0.4 (2026-10-31)**: `newBlock` registers the block before it returns, so the README example stacks it on the next line; a block whose shader cannot be registered skips itself instead of stopping the whole stack, and the shader index is read afresh when blocks change; the author example writes to `/zero/source/myBlocks`; how to keep, clear and revert a saved stack. **1.0.3 (2026-10-31)**: screen targets freed by a scene switch are noticed and rebuilt; Known limits on one stack per scene and the dark viewport floor. **1.0.2 (2026-10-31)**: the `low` quality tier runs the block chain at half resolution (about five times cheaper in the Lookbook), excluded objects are restored at full size on every tier, the black guard closes fully on unlit pixels, the block type README describes the side-by-side folder layout. **1.0.1 (2026-10-31)**: masks by object group and exclusion drawn per group, durable state across hot reloads, the toolbox, the test suite, `newBlock`, guides, workflow and agent skill. **1.0.0 (2026-10-31)**: first release. Block type, StyleStack component, runtime, masks (depth, rect, sphere, group), exclusion, shared clock, coordinates, ground, wobble and patterns, quality tiers, four example blocks and a diagnostic block, toolbox, tests, guides, workflow and agent skill.

# StyleStack (component) The scene's look: an ordered list of style blocks with each one's strength, mask and settings, plus the stack-wide held clock rate, mark scale, excluded objects and mask groups. It lives on a synced entity in the scene, so it is saved with the scene and every player draws the same stack. Change it with the `StyleKit` module (`add`, `remove`, `swap`, `move`, `setStrength`, `setMask`, `set`, `clear`, `load`, `options`); the runtime redraws on the next frame.

# StyleKit (module) The styleKit library: the block registry (`blocks`, `block`, `settingsOf`, `checkBlock`), the stack operations every player shares (`add`, `remove`, `swap`, `move`, `setStrength`, `setMask`, `set`, `setOn`, `clear`, `load`, `options`), `describe` for what is in the stack, and quality control (`quality`, `setQuality`). Reach it with `require("~styleKit.StyleKit")` from any script.

# skPatterns (shader module) The one pattern library every styleKit block draws from: hashes, value noise and fractal noise in 2D and 3D, cell (Worley) distance, a round dot screen sized by tone, parallel hatching and a 4x4 ordered threshold. Pure math with no bindings, so a full-frame block and a surface material that includes a block's piece share the same marks. Include it with `#include "~styleKit.shaders.skPatterns"` (the package name reaches it wherever styleKit was installed).

# skCommon (shader module) The prelude every styleKit block includes. It reads the shared inputs the stack fills each frame (the `sk_` properties of the styleKit shared header): one clock (`sk_time`, `sk_held`, `sk_step`), surface data copied once per frame (`sk_world`, `sk_dist`, `sk_normal`, `sk_albedo`), coordinates that stay on things (`sk_surface_coord`), the shared ground (`sk_ground_at`) and wobble (`sk_wobble_uv`), resolution-independent mark sizes (`sk_ref_uv`), the block's mask (`sk_weight`) and the one exit every block returns through (`sk_finish`: strength, mask, layer mode, and black stays black). Include it with `#include "~styleKit.shaders.skCommon"` after declaring the shared header.

# StyleRuntime (module) The per-machine half of styleKit, called by the styleStack render feature each frame: it keeps one post-process effect per stack entry, fills the shared inputs (clock, quality, surface data, ground, wobble, object mask) and enqueues the passes in slot order after antialiasing. Scripts use `StyleKit`, not this module.

The full-frame pass of the Depth line style block: one-sided silhouettes from inverse distance and creases from normals.

# Depth line (styleBlock, Line) Draws a clean ink outline where depth jumps and where surfaces fold, the same weight everywhere, for comic, cartoon and technical drawing looks. Settings: `width` (1.6 reference px), `ink` (near black), `opacity` (0.9), `silhouette` (1), `crease` (0.6), `threshold` (0.02), `creaseAngle` (0.35), `fadeStart` (40 m), `fadeEnd` (120 m), `grainBreak` (0.2), `wobble` (1). Low quality samples two directions instead of four and draws no creases. How it reads: silhouettes come from the inverse of the shared view distance, which is linear across any flat surface on screen, so a floor grazing to the horizon draws no false lines; the line lands on the near side of an edge only, so two touching objects never get a doubled outline. Creases come from the shared normals. The ink is broken by the shared ground's grain (`grainBreak`) and follows the shared wobble, so it boils with a wash on one clock and the paper shows through it. ## What it gives up in motion Lines are found again every frame from the opaque depth, so they do not carry history: a part thinner than a line (wires, fence slats, far railings) can shimmer as it crosses pixels, and a crease drawn from normals pops in and out as a curved surface turns past `creaseAngle`. Line weight is constant on screen, so it does not shrink with distance until `fadeStart`. ## How it treats content - Opaque things: outlined and creased. - Transparent things (glass, water): not in the depth, so they get no outline; objects behind glass keep theirs, drawn over the glass colour. - Particles and smoke: no outline; lines of objects behind smoke stay visible through it. - Sky: never lined; objects get an outline against it. - Fog: lines are drawn over fog at full ink until `fadeStart`; lower `fadeEnd` to sink far lines into fog. - Skinned characters: outlined from their depth each frame, so a fast character keeps a clean line. - Foliage: alpha-cut leaves are in the depth and get busy outlines; raise `threshold` or mask foliage out with a group mask. - World text: text drawn as geometry gets outlined like any object, which can make small letters heavy; exclude labels. - Black stays black: in a frame with no light the line is not drawn.

The full-frame pass of the Duotone style block: maps brightness onto a shadow ink and a light ink.

# Duotone (styleBlock, Colour) Maps the picture onto two inks, a shadow colour and a light colour, like a two colour print or a tinted photograph. Settings: `shadowInk` (deep blue), `lightInk` (warm cream), `contrast` (1.1), `balance` (0), `keepColour` (0.1). Colours are display colours as picked, written as `"#1c2245"` or `{ r, g, b }`. ## What it gives up in motion Nothing extra: it maps each pixel on its own, so it adds no marks that could slide or flicker. What it gives up is hue: colour-coded gameplay (a red enemy, a green pickup) reads only by brightness, so raise `keepColour` or exclude those objects. ## How it treats content - Opaque things: mapped by brightness onto the two inks. - Transparent things (glass, water): mapped as they appear, with what is behind them. - Particles and smoke: mapped; bright additive sparks become the light ink. - Sky: mapped; a blue sky turns to the middle of the two inks. - Fog: mapped; fog pulls distant things toward one ink, which reads as depth. - Skinned characters: mapped like any surface. - Foliage: mapped; leaf colour is lost, leaf shape stays. - World text: mapped; keep labels light on dark or dark on light so they keep their contrast, or exclude them. - Black stays black: a pixel with no light stays black even though the shadow ink is not black.

The full-frame pass of the Posterize style block: steps brightness (or each channel) into a few flat levels.

# Posterize (styleBlock, Colour) Cuts the picture into a few flat tone steps, like a screen print or a poster printed with a small set of inks. Settings: `levels` (5), `byBrightness` (1), `softness` (0.12), `saturation` (1.1). Low quality draws hard steps (softness 0). ## What it gives up in motion Smooth gradients become hard steps. When a light changes slowly, a step edge sweeps across a surface instead of the surface fading, and noisy content (fine textures, film grain) flickers between two steps. Keep `softness` above 0.05 where light moves. It holds no marks of its own, so nothing slides or sticks to the screen. ## How it treats content - Opaque things: stepped by brightness, hue kept. - Transparent things (glass, water): stepped as they appear, with what is behind them. - Particles and smoke: stepped like everything else; soft smoke turns into a few bands. - Sky: stepped; a gradient sky becomes bands. - Fog: stepped; distance fog becomes a few flat depth bands, which often reads well. - Skinned characters: stepped like any surface, no extra cost. - Foliage: stepped; moving leaves can flicker between steps. - World text: stepped with the rest; light text on dark keeps its contrast. Exclude a label with `StyleKit.options({ exclude = { id } })` to leave it untouched. - Black stays black: a pixel with no light stays black.

The pass of the Shared inputs view diagnostic block.

# Shared inputs view (styleBlock, Medium) A diagnostic block for block authors: shows one of the shared inputs every block reads (distance, normals, base colour, ground, wobble, object mask or surface coordinates) in place of the picture. Settings: `show` (0 view distance, 1 normal, 2 base colour, 3 ground with its grain on the right half, 4 wobble, 5 object mask, 6 surface coordinates), `range` (60 m). Use it with a rect mask to see an input beside the picture. ## What it gives up in motion It replaces the picture, so it is not a look. Watching `show = 6` while the camera pans is the quickest way to see that surface coordinates stay on things. ## How it treats content - Opaque things: shows their shared data. - Transparent things (glass, water): shows the opaque surface behind, since the shared data comes from the opaque depth. - Particles and smoke: invisible in every view but the ground and wobble. - Sky: distance 0 (black), no normal or base colour; coordinates come from the view direction. - Fog: not part of the shared data. - Skinned characters: shown like any opaque thing. - Foliage: alpha-cut leaves appear, blended leaves do not. - World text: appears where it is geometry in the depth. - Black stays black: not applicable; this is a diagnostic and it is the one block that does not return through `sk_finish`.

The full-frame pass of the Sketch line style block: jittered, broken pencil strokes over shape and colour edges, redrawn on the held clock.

# Sketch line (styleBlock, Line) Draws soft, broken pencil lines over edges of shape and colour, doubled and redrawn a little on every step of the held clock, for a hand-sketched or storyboard look. Settings: `width` (1.3 reference px), `lead` (graphite grey), `darkness` (0.7), `colourEdges` (0.5), `strokes` (2), `jitter` (1.2 px), `breakup` (0.35), `breakScale` (3 per metre), `fadeEnd` (80 m), `wobble` (1). Low quality draws one stroke per edge, medium two. The strokes multiply the picture with the pencil colour instead of covering it, so colour and paper show through them. Breaks in the strokes are drawn in surface coordinates, so they stay on the object as the camera moves; only the small redraw offset changes, and it changes on the stack's held clock. ## What it gives up in motion The strokes are redrawn off the edge on every step of the held clock, so lines boil: that is the look, and it runs at the stack's `holdRate` (8 steps a second by default), never per frame and never faster than the clock. Colour edges are found in the picture itself, so a texture that shimmers makes its strokes shimmer too. On a fast moving skinned character the breaks are taken from world position, so they slide along the body as it moves. ## How it treats content - Opaque things: shape strokes from depth and normals, plus colour strokes. - Transparent things (glass, water): no shape strokes; strong colour edges seen through them are stroked. - Particles and smoke: bright particles over a dark background draw colour strokes around them; soft smoke draws few. - Sky: no shape strokes; strong sky gradients (a sun disc) can draw a faint colour stroke. - Fog: fog lowers colour contrast, so far strokes fade naturally; shape strokes end at `fadeEnd`. - Skinned characters: stroked each frame like any opaque thing; breaks slide on the moving body (see above). - Foliage: busy; lower `colourEdges` or mask foliage out. - World text: letters get pencil edges; exclude labels that must stay crisp. - Black stays black: a frame with no light draws no strokes.

# pigmentSet (asset type) A pigment set is a palette of paints that every styleKit block reading `pigments` mixes from: up to eight pigments, each with how much it granulates, plus the pigment shadows pool in, the tint lit areas thin toward and the colour far things lift toward. One change (`StyleKit.setPigments(id)`) re-colours a whole painted look for every player, because the set is named on the scene's synced StyleStack. ## Folder shape ``` earthy.pigmentSet/ pigments.yaml the palette (required) README.md what it is for and the mood it gives (required) .metadata { "tags": ["pigment set", "watercolor", "earthy"] } (required) ``` ## pigments.yaml ```yaml name: "Earth pigments" summary: "Ochres, siennas and umbers with a cool grey: a warm, granulating landscape palette." tags: [earthy, warm, landscape] pigments: # up to eight; colour is the masstone as picked (#rrggbb) - { name: "yellow ochre", colour: "#d1a24a", granulation: 0.35 } - { name: "burnt sienna", colour: "#a4512b", granulation: 0.5 } - { name: "ultramarine", colour: "#3c4fa8", granulation: 0.9 } shadow: { colour: "#4b4470", strength: 0.6 } # what shadows pool toward light: { colour: "#ffe3b8", strength: 0.5 } # what lit areas thin toward air: { colour: "#ece6d6", strength: 0.4 } # what distance and fog lift toward pull: 0.75 # how hard colours are re-mixed from the pigments, 0..1 darkest: 0.05 # the darkest value the set reaches (display, 0..1) saturation: 1.0 # 1 keeps the pigments' own chroma, lower greys them ``` A block reads the set through the `skPigmentSet` shader module (`skg_remix`, `skg_shadow`, `skg_light`, `skg_air`). With no set picked (`StyleKit.setPigments("")`) blocks keep the scene's own colours. The id is the folder name without `.pigmentSet`; list them with `StyleKit.pigmentSets()`.

# skAnchored (shader module) Stable noise that stays on things, for styleKit blocks. Include after `skCommon` and `skPatterns`. - `sk_anchored_fbm(uv, perMetre, octaves)`: fractal noise laid on the world position of the surface under the pixel from three sides (no seam where a surface turns; the sky by view direction). Sized in metres: a wash's grading, wet patches. - `sk_anchored_cells(uv, perMetre)`: one random value per patch (blooms, pools, dry patches). - `sk_scaled_fbm(uv, refPx, octaves)`: noise that stays on the surface and keeps marks about `refPx` reference pixels across at any distance, by blending two octaves by distance (marks grow into the next octave rather than sliding). Paper tooth, grain, flecks and strokes that should keep their size in the picture. - `sk_scaled_level(uv, refPx)`, `sk_surface_plane(uv)`, `sk_ref_metres(uv)`: the parts, for drawing your own pattern (cells, strokes) the same way. For things that move, use `skp_triplanar_fbm` on the object's own position inside a material (`local_position`).

styleKit internal: copies base colour and world normal from the deferred g-buffer at afterLighting into scene-space targets the style blocks read after antialiasing.

styleKit internal: writes one constant value over a whole target, to reset a shared field that no block in the stack publishes.

styleKit internal: writes selected objects into one channel of the stack's object mask, depth-tested against the scene.

styleKit internal: merges the per-group object masks into the stack's one object mask.

# skPaper (shader module) The paper field, for blocks that list `paper` under reads and declare `sk_paper` (a texture, default black) after the shared header. It says how the sheet under each pixel takes paint and ink: `sk_thirst(uv)` (-1 hard-sized, 0 the standard sheet blocks are tuned on, +1 thirsty), `sk_sheen(uv)`, `sk_fibre(uv)` and `sk_dark_ground(uv)` (1 where the picture is made of light marks on a dark sheet). A Ground block publishes it with a `field.paper` shader in its block.yaml; where none does every value is 0, so a block reading it draws exactly as before. The field is only made when some live block reads it, so it costs nothing otherwise. paperBlocks' papers publish it; watercolorBlocks' bleed and edge darkening and every inkBlocks line and fill read it.

# skPigment (shader module) Pigment mixing for styleKit blocks and materials: transmittance and optical density, the log-space mix of two pigments in one wash (`skg_mix`), transparent glazes that multiply (`skg_glaze`), diluting paint toward the paper (`skg_dilute`), the same hue at another value (`skg_with_value`), and paint on paper (`skg_on_paper`). Pure math with no bindings, so a full-frame block and a surface material mix paint the same way. It is a plain transmittance model written for styleKit.

# skPigmentSet (shader module) Reads the scene's pigment set (`sk_pigments`) in a styleKit block: the set's pigments with their granulation, its shadow pigment, light tint and air colour, and `skg_remix`, which re-mixes any colour from the set's pigments at the colour's own value. Include it after `skCommon` and `skPigment` in a block that lists `pigments` under `reads` and declares `sk_pigments` (a texture) after the shared header.

styleKit internal: reconstructs each pixel's world position (relative to a snapped anchor) and view distance from the scene depth after antialiasing, for every style block to share.

# skRendered (shader module) The frame as it entered the style stack, for blocks that list `rendered` under reads and declare `sk_rendered` after the shared header. `sk_rendered_at(uv)` returns it in display code values. Use it for what the renderer said, not what earlier blocks made of it: a light estimate against `sk_albedo` (texture cancels out), or an original colour to restore. Costs one copy of the frame per frame, shared by every block that reads it (and by excluded objects).

styleKit internal: restores the unstyled frame over objects excluded from the stack.

# skSoft (shader module) Reads the stack's soft field (`sk_soft`) in a styleKit block: a half-resolution, depth-aware blur of what the block reads, with `.a` telling how much of it came from the same surface. `sk_soft_at(uv)` samples it and `sk_soft_wide(uv, px, angle)` reaches further with a ring of taps. Include it after `skCommon` in a block that lists `soft` under `reads` and declares `sk_soft` (a texture) after the shared header. Washes, bleeds, edge darkening and blooms read it, and so can any later block.

styleKit internal: one direction of the depth-aware soft field (half resolution blur) that blocks reading `soft` get as `sk_soft`.

# styleKit (agent skill) Teaches an agent to give a world an art style made of stackable look blocks with styleKit: list the installed blocks, read the scene's style stack, add, swap, weight, mask and exclude, keep UI, labels, characters and gameplay colours readable, look at the result on the presented frame, write and check a new block, run the styleKit tests, and measure a look in motion with the Lookbook. Reach for it when someone asks for a look (watercolour, comic, sketch, chalk, retro pixels, paper, ink, grain) or wants to change, tune, remove or extend a world's style stack, and before writing a full-screen post-process effect by hand.

# styleKit (toolbox) Shell and agent face of the styleKit style stack. Every tool acts on the scene's shared stack, so a change reaches every player. | Tool | What it does | |---|---| | `styleKit.list` | Every style block installed, optionally in one slot | | `styleKit.stack` | What is in the stack, in run order, and what drew last frame | | `styleKit.add` | Add a block (with an optional strength) | | `styleKit.remove` | Remove an entry | | `styleKit.swap` | Swap an entry's block for another of its slot | | `styleKit.set` | Change a setting, the strength or the on switch | | `styleKit.clear` | Empty the stack: the frame is as rendered | | `styleKit.check` | Check blocks against the block rules | From the shell: `zero styleKit list line`, `zero styleKit add posterize`, `zero styleKit set posterize1 levels 3`.

# styleLook (asset type) A whole look in one change: the blocks of a styleKit stack with their strengths, masks and settings, and the stack options that go with them (pigment set, hold rate, mark scale, soft radius). `StyleKit.applyLook(id)` replaces the scene's stack with it for every player; `StyleKit.applyLook(id, { keep = { "line" } })` keeps the slots you name from the current stack, so a look can change the washes and leave your line alone. ## Folder shape ``` looseAndWet.styleLook/ look.yaml the look (required) README.md what it is, what it suits, which blocks it uses (required) .metadata { "tags": ["look", "watercolor"] } (required) ``` ## look.yaml ```yaml name: "Loose and wet" summary: "Big soft washes that bleed into each other, blooms and pooled shadows; little detail." tags: [watercolor, loose, wet] pigments: earthy # a pigmentSet id, or leave it out for the scene's own colours holdRate: 8 markScale: 1 softRadius: 14 entries: # the same shape StyleKit.load takes - { id: wash, block: wcWash, settings: { flatten: 0.85 } } - { id: bleed, block: wcBleed, strength: 0.9 } - { id: paper, block: wcColdPress } ``` Every block a look names must be installed; `applyLook` refuses a look with a missing block and changes nothing. List looks with `StyleKit.looks()`.

# styleStack (render feature) Draws the scene's style stack on this machine. Every frame it hands the stack to `StyleKit`, which copies the frame after antialiasing and upscaling, fills the shared inputs (surface data, ground, wobble, object mask, clock), runs each block in slot order and hands the result back before the UI is drawn. With no live block it enqueues nothing, so the frame is exactly what the scene rendered. Started by styleKit itself on every machine; a world never creates it by hand.

# styleKit (test suite) Checks the styleKit block registry and the rules every installed block follows, runs every stack operation twice in a row, refuses a swap across slots, checks that clearing the stack takes every pass off the frame and leaves the presented frame as rendered, and writes a new block with `newBlock`, registers it and stacks it. The suite saves the shared stack first and puts it back when it ends. Run: `asset.resolve("styleKit", "testSuite"):run()`.

# restyleWorld Give a world, a scene or an installed kit a new art style with styleKit, without breaking or losing anything. ## What it does 1. **Survey.** Reads what is there before changing anything: the scene's entities, the materials in use (toon, outlined, emissive, transparent, pixel-art), the lights and whether they change over time, the screen UI, particles, the player and other characters, world labels, colours that carry gameplay meaning, any stack already in place and the style blocks installed. 2. **Reference.** Saves the unstyled presented frame under `/zero/source/tmp/restyle/<subject>/` and turns the asked look (or a proposed one) into one block choice per slot. 3. **Build.** Builds the stack with one `StyleKit.load` call using readable entry ids, so running it again replaces rather than duplicates. 4. **Tune.** Up to three rounds of comparing presented frames against the look and adjusting settings, strengths, mark scale and hold rate. 5. **Content.** Handles what a full-frame block cannot: excluding world labels, a group mask so characters stay crisp, one owner for outlines on toon or outlined objects, material pieces such as `bandedToon` (only when allowed), transparent things and particles, gameplay colours. 6. **Check.** UI and labels readable, gameplay colours kept, black stays black, no flashing above 3 Hz, the Lookbook's numbers for the new stack against the old one, and the low quality tier. 7. **Report.** Answers with the look, the stack, every exclusion, group and mask, every material change with its old material and the call that restores it, the checks, the Lookbook numbers and how to remove it all. It is non-destructive: styleKit edits no material, and the whole look comes off with `StyleKit.clear()` or by deleting the `StyleStack` entity. Material changes happen only when the run is started with `allowMaterialChanges = true`, and each is recorded with how to put the old material back. ## What it needs styleKit installed, with blocks to choose from (starterBlocks gives one in every slot). The Lookbook check uses lookbookKit when the world has it and says so when it does not. ## Starting it zero workflow start --name restyleWorld --args '{"subject":"main","look":"watercolour with crisp characters"}' `subject` names the world, scene or kit (default: the loaded scene); `look` is the look in the asker's words (default: the run proposes one); `allowMaterialChanges` lets it change materials on chosen objects (default false).