Log inGet started
World

Style Cookbook: Mix Your Own Art Style from Stackable Look Blocks

README.md

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.7.8.

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:

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

BlockSlotWhat it does
posterizeColourCuts the picture into a few flat tone steps, like a screen print.
duotoneColourMaps the picture onto a shadow ink and a light ink.
roleGlazeColourRoles glaze: a transparent glaze of one colour over the objects of one group (a variant), keeping their light and shade. StyleRoles.use adds one per group from a role set's glazes, so a hero, the enemies and the pickups that share a material still read apart under any look.
depthLineLineA clean, one-sided ink outline from depth plus creases from normals.
sketchLineLineSoft, broken pencil strokes over shape and colour edges, redrawn on the held clock.
sharedViewMediumA 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 sun the renderer shades the scene with (lighting.sun()), w 1 when it gives light (0, and a default direction, when there is none). Read every frame as a table the engine keeps current (nothing in the scene is surveyed), and written to blocks only when its direction (to three decimals) or whether it lights actually changes, so a still sun costs nothing and a moving one reaches blocks on the next frame. 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.
  • Strokes for shading blocks (skStrokes, since 1.3.0): hand-laid strokes that build up by tone, for any block that shades with marks (pencil, charcoal, hatching, scribbles). Since 1.4.0 every layer of strokes at one place shares the same patch grid and the same random slant, so layers keep exact angles to each other; outside crossed mode the first two layers run parallel (the second fills between the first) and darker layers cross at clear angles (60 degrees each way, then 30, then square), so soft strokes never beat into broad zebra bands. sks_layer_d(p, n, tone, dpx, dpy, px_per_ref, st, k) sizes the strokes across their own width on screen from the position's screen derivatives, so the spacing is the same number of pixels whichever way strokes run and however steeply a surface is seen; prefer it over sks_layer wherever derivatives are at hand. Since 1.4.1, sks_edge_on(facing) says how much of its stroke pattern a surface keeps from how squarely it faces the eye, and sks_layer_mean(tone, st, k) is the average coverage a layer gives: on a floor or a field seen at a low angle, patches of strokes squeeze into rows whose ends read as zebra bands, so mix each layer toward its average there and the ground keeps its value as even rubbed tone.
  • The dim guard (since 1.4.0): keeps a dark scene dark. See the next section.

Keep a dark scene dark: the dim guard

A shading block lays marks and a sheet over the picture, and in a dim room the sheet and the light between the marks can end up brighter than the room was. The dim guard stops that, so no shading block (hatching, stipple, dots, pencil, charcoal) brightens a dim or unlit room.

  • When it runs. When any live block in the stack declares keepDim. Every Tone slot block does unless its block.yaml says keepDim: false; a block in another slot opts in with keepDim: true. So a new shading block in the Tone slot gets the guard for free.
  • What it does. Two small passes after the chain. A meter at an eighth of the chain's resolution records the mean brightness of the stack's result and of the frame as rendered under each of its texels, plus how bright the rendered picture's brightest parts are (a power mean over a fixed 5 by 5 grid) and its overall mean. Then the guard scales the result down wherever, smoothed over about 36 pixels, it is brighter than the rendered frame there (with no allowance since 1.4.4; it was 0.006, about 1.5 of 255). Then it holds each pixel to at most a fifth above the rendered brightness on its darker side: the darkest of four small patches ten pixels off (left, right, above, below), never below the pixel's own rendered brightness. Bare sheet beside a pale prop in a dark-walled room is held to the wall it lies on instead of keeping the prop's brightness and glowing around it, the prop's own edge to the prop, and a patterned surface to its mean, so no texture prints back. It scales rather than clips, so every mark keeps its shape.
  • Only on a dim or unlit picture. It lets go fully once the picture's mean is 0.42 or above, its brightest parts are at 0.55 or above and some light other than an ambient one is on (daylight, an overcast day, a well lit room), and is fully on below a mean of 0.30 or brightest parts of 0.40. A scene with no light switched on (the engine falls back to a default ambient) counts as unlit however bright that fallback draws it. In a lit frame it hands the result on exactly unchanged. A night street, or a room with dark walls under one lamp, has bright spots but a low mean, so it is guarded.
  • Cost. Two small passes, only while a block that keeps dim is live. StyleKit._status().dimGuard reports whether it ran last frame.

Blocks registered before 1.4.0 (the registry survives hot reloads) get their keepDim filled in by the kit, so an upgrade needs no restart.

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.

Players, enemies and pickups under one look: style channels

A look treats every object the same unless the object says otherwise. A StyleChannel on an object (synced, saved with the scene) says how the look treats it and everything under it:

  • variant: which variant of the look it gets. A stack entry that names a variant draws only on objects of it, and an entry of the same slot that names none leaves those objects to it, so two blocks share one slot by group: one ink for the player, a different ink for the enemies. "asRendered" leaves the object exactly as rendered (labels, in-world HUD, a screen inside the world).
  • line: how heavy its lines and strokes are (1 as the look draws them, 2 twice as heavy, 0 none). Read by styleKit's depthLine and sketchLine, every inkBlocks line, pencilBlocks' lines (width) and shading (stroke density), and toonBlocks' ink (width).
  • marks: how much of each kind of mark reaches it, 0 to 1: line (Line blocks), tone (Tone and Light blocks: hatching, dots, bands), fill (Fill, Surface and Colour blocks: washes, cel fills, posterize) and paper (Ground blocks: how much paper shows through). Every block honours this with no change of its own: the kit weighs each block by its kind of mark on each object. A block may name its kind in block.yaml (marks: line | tone | fill | paper | none); otherwise its slot decides, and the Time, Raster and Medium slots are screen-wide.
  • value: one free value, 0 to 1, a block may use however it likes; 0 changes nothing. The shipped blocks read it as "how much of its own colour the object keeps": watercolorBlocks' wash keeps its colour brighter and purer, inkBlocks' wash keeps its colour through the ink, toonBlocks' ink takes its colour.
  • ink: the colour of its line, for blocks that take one per object (toonBlocks' ink).
  • role: a game role (hero, enemy, pickup, ...). The scene's role set fills in every field the object does not set itself. Role sets are styleRoleSet assets; the styleRoles package ships sixteen roles tuned for six kinds of look.
local StyleKit = require("~styleKit.StyleKit")

StyleKit.give(entity.findAll("Goblin")[1], "enemy")              -- one thing, one change
StyleKit.setChannel(entity.findAll("Coin")[1], { marks = { tone = 0, paper = 0 }, value = 0.8 })
StyleKit.setChannel(entity.findAll("ScoreBoard")[1], { variant = "asRendered" })
StyleKit.add("depthLine", { id = "enemyInk", variant = "enemy", settings = { ink = "#6a0a0a", width = 2.4 } })
StyleKit.setRoles("toonGame")                                     -- the whole game's roles, one change
print(StyleKit.channelOf(entity.findAll("Goblin")[1]).line)

An object with no channel, in a scene where none has one, draws exactly as before: the kit makes no object mask and gates no block. Every field is synced on the object's own entity, so every player sees the same roles on the same things, they survive a save and reload, and a change made in play (by any player; a write from a player who does not own the object goes to its owner) reaches everyone. A child with a channel of its own keeps its own; things attached under a role holder later are picked up within ten seconds (at once when its channel changes).

How it runs. Objects are grouped by what they ask for into at most eight distinct settings; each setting is one geometry pass into a small image of its own, and one pass packs them into the object mask every block reads (sk_obj). A block reads its object through sk_chan_line(uv), sk_chan_line_near(uv, r) (the nearest surface within r reference pixels, so a line drawn just outside a silhouette belongs to the thing in front), sk_chan_value(uv), sk_chan_mark(uv, kind) and sk_chan_tagged(uv) from skCommon; the gate by kind of mark and variant is applied inside sk_weight, so sk_finish honours it for every block. Measured on toonBlocks' busy bench (2,500 things, 250 moving, 25 a second spawned and despawned, Comic ink cel), look stack script time a frame:

The whole look (median)averageToon ink (median)styleKit (median)
Roles off0.44 ms0.53 ms0.11 ms0.32 ms
150 things with a role, toon game set0.63 ms0.78 ms0.17 ms0.44 ms
600 things with a role, toon game set0.93 ms1.25 ms0.26 ms0.64 ms
600 things with a role, before this release (toonBlocks 1.3.5, styleKit 1.6.3)1.33 ms2.29 ms0.60 ms0.55 ms

Measured on 11 November 2026 with toonBlocks' busy bench (design/roles/bench_roles.luau in the Style Cookbook world): 2,500 things, 250 of them moving, 25 a second appearing and 25 disappearing, 10 recoloured a second, under the Comic ink cel look; script time the look spends each frame. It ran in a test client of its own drawing 14 to 17 frames a second on a shared, busy desktop, which overstates every per-frame number; your game on its own will measure lower. What changed: toonBlocks 1.3.6 draws every role ink through one shared flood (104 render passes a frame for 600 role holders in nine inks before, 22 now), and styleKit 1.6.4 rebuilds the role mask at most four times a second while roles keep changing. So the whole look stays under a millisecond on the median frame with 600 role holders, and well under one (about 0.6 ms) with the 150 or so a typical level gives roles to. What is left is mostly styleKit queuing its eight mask passes and their selection lists again every frame (#24548): with hundreds of role holders and a slow client the average frame can pass 1 ms. The GPU time of the look did not change measurably.

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

CallWhat 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 the stack's blocks / empty the stack. opts: holdRate, markScale, pigments, softRadius, look; an option left out keeps the stack's current value, so to reproduce a look exactly pass all of its options or use applyLook.
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.setLocal(entry, settings?) / localSettings()Lay settings over one entry on this machine only, over its synced settings (a tint or a ramp for the level this player is on); nothing is synced or saved, nil takes them off / list what is laid here.
StyleKit.setLocalEntry(id, entry?) / localEntries()Lay a whole entry on this machine only ({ block, strength, on, mask, settings, variant }), after the synced stack and ordered by slot like any other: for short local effects such as an impact frame on a hit, which a game keeps in step across players with a message of its own. Never synced or saved; works with no StyleStack in the scene; nil removes it. (Contributed by another account as pull request #10, ported onto 1.7.0.)
StyleKit.publishInput(name, texture?) / inputs() / inputWanted(name)Publish a texture another package computes (a heat map, a sonar wave, a thickness map) on this machine for blocks that list input:<name> under reads and declare an in_<name> texture; nil withdraws it (blocks read black). inputWanted says whether a live block reads it now, so the producer works only then. Never synced or saved (1.8.0).
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).
StyleKit.give(entity, role?)Give one object (and everything under it) a game role, for every player and saved with the scene; nil takes it away.
StyleKit.setChannel(entity, fields) / channelOf(entity) / clearChannel(entity)Set how the look treats one object: { role, variant, line, marks = { line, tone, fill, paper }, value, ink, children } (-1 or "" gives a field back to the role) / what it gets now, read through the scene's role set, and which object's channel reaches it / take its channel away.
StyleKit.channels()Every object a channel reaches with what it gets, and a revision that moves when any of it changes (for runtimes that draw per object).
StyleKit.setVariant(entry, variant?)Share a slot by group: the entry draws only on objects of that variant, and the entry of its slot naming none leaves them to it. add takes variant too.
StyleKit.setRoles(id) / roles() / roleSets(filter?) / roleSet(id)Pick the role set for the whole scene and every player ("" follows the look, "none" reads no roles) / the set in use / every installed set / one set, with what it extends laid under it.
StyleKit.lookRoles()The set the scene's look suits by itself: what a set written with extends: look (a set for a kind of game) is laid over.

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:

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.

A block that shades the picture (hatching, stipple, dots, a pencil shade) belongs in the Tone slot, where it is kept from brightening a dim room by the dim guard with no work of its own. A block in another slot that lays a light sheet or light marks over the picture can ask for the same with keepDim: true in its block.yaml; a Tone block that should be left alone in the dark says keepDim: false.

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), and a dim room stays dim (the dim guard holds every block that keeps dim 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.

LookHighLow
README example: posterize, duotone 0.5, depthLine, sketchLine 0.60.600.11
Cookbook: flatWash, depthLine, plainPaper, lineBoil, softGrain 0.61.030.21
Comic: lightBands, surfaceDots, depthLine, posterize0.410.10
Chalk: depthLine, darkBoard0.430.10
Retro: posterize, chunkyPixels, softGrain, vignette0.220.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, publishes the ground and wobble (only when a block of the look publishes them; otherwise blocks read a tiny constant image written every few seconds), runs each slot and hands the result to the screen, blending it over the frame as rendered so excluded objects stay as they were (one pass, no copy of the frame). When a live block keeps dim, the dim guard's two small passes (a meter at an eighth of the chain's resolution, then the guard) run between the last slot and the hand-off. 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). A frame in which nothing the stack draws from has moved (the stack, its options, the tier, the images, the camera anchor, the view, the channels) hands the engine the passes of the frame before as they were and skips the rest of its work; a held clock step writes only the clock. Otherwise 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 internal effects (the dim guard's two among them) 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.
  • A full-screen pass cannot tell which object a pixel belongs to (#22178), and a geometry pass carries no per-object value (#24549). Style channels are drawn as at most eight distinct settings, one geometry pass and one small image each, packed by one more pass into the object mask. Objects asking for the same thing share a setting, so a game's sixteen roles fit; a ninth distinct setting is left out (the objects it reaches draw as if they had no channel), and StyleKit._status().parts says how many were drawn. Colours per object (an enemy's ink) cannot ride the mask; blocks take them through a variant entry of their own (styleRoles adds one per coloured variant), and toonBlocks' ink, which draws per object, takes the channel's ink directly.
  • Every pass is queued again every frame (#24548). Each mask setting's selection list costs a little script time per selected object every frame; with 600 role holders that is most of the 0.2 to 0.3 ms the channels add.
  • A pass reads no depth unless it also writes the scene picture (#24550), so the mask parts test against the scene's depth in their own shader, and a line block finds the object a line belongs to by looking at the nearest surface around it (sk_chan_line_near) rather than at a depth the mask pass kept.
  • An unknown blend draws as replace (#24551): the mask parts use opaque (each part is an image of its own), and nothing in the kit relies on another blend name.
  • A running editor that had styleKit 1.4 open keeps the StyleStack's old fields until it restarts. It cannot read or write the stack's new roles field, so the role set lives on a StyleRoleSet component beside the stack (new in 1.5.1), which every client has at once; objects' channels (a component new in 1.5.0) replicate at once too.
  • Edit mode does not share live changes between two editors. Roles given in one editor reach another through the saved scene; in play every change reaches every player at once.
  • 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.
  • Switching looks can show picture memory a little above where it began. Two seconds after the last live block goes, the kit frees every screen image it made (checked with 1.4.4: four looks applied and cleared, five rounds). The engine keeps freed render scratch for reuse until its next collection, so between collections the texture memory reads one or a few screen images above the start (112, 136, 160, then back to 88 MB in one session); renderer.collect() brings it back to the same figure every round (64 MB there). It does not grow without end.
  • The dim guard keeps a dim room's level, not every pixel's. It matches brightness smoothed over about 36 pixels and holds each pixel to a fifth above the render around it, so one light mark can still sit a little lighter than the render right under it while the area around it stays as dark as rendered. In a lit picture (brightest parts at 0.7 or above and a mean of 0.4 or above) it does nothing, so how a block treats daylight is up to the block.
  • Post-process shaders have no preview image, so the shader previews in this package are absent.
  • Other engine issues that apply here: the camera gives no near and far planes (#24514); a two-client editor sometimes refuses to load two different scenes at once (#24666, #24667); a world boot can wait about 30 s on a network handshake before content starts (#24669); installs with several dependencies are slow (#21420); the ZeroMind description can lag one release (#19258); the web build was not checked from here (#20946); two engines on one account collide as one player, so a two-player check needs two accounts (#14448).

Version history

1.8.3 (2026-11-13): a block added with no rank lands before the first block of its slot ranked 100 or more, so a finishing block (a printed margin, a frame, weather laid over the picture) that states rank: 100 and up with stacking: chain stays on top when grain or a vignette is added after it. Before, the later block was appended last and, as a plain layer reading the slot's input, painted the margin out. Blocks with a rank, and every stack already saved, are placed as before.

1.8.2 (2026-11-13): the sky distance a depth mask uses costs the render path nothing. The active camera, its entity and its Camera component were read from inside the render feature's frame (about twice a second: forced on the replay check and again on the full path), where those engine calls can cost far more than from a script: a profile of a 2-3 block look in a large world (about 2,900 entities) put about 24 ms of every second there. The render path now reads only the cached far distance; the lookup runs in a deferred task off the frame, at most every 2 seconds, and a replayed frame takes the full path as soon as the cached value differs from the one it was built with. A camera far-plane change is picked up within about 2 seconds; the frame drawn is unchanged.

1.8.1 (2026-11-13): a still frame costs less script time. (1) A frame in which nothing moved now replays every frame instead of taking the full path every 15th frame: the periodic checks run on cadences of their own, spread over the frames, and send a frame down the full path only when one finds something moved. The renewal backstop (one effect every 30 frames) and the dim guard's rewrite are a few property writes on a replayed frame; each effect's shader-reload count is read in turn (about every 30 frames each); the lighting watch every 15 frames (a change takes the full path and reads the sun again); the sky distance every 60 frames; the neutral fields' backstop write keeps its 240-frame cadence. Target residency, the quality tier and a rebuilt device are read before the replay check as before, and a new effect settling, a driven clock, objects still awaited, a tier change, lost targets and any stack, option, view or channel change still take the full path. (2) A replayed frame allocates nothing: the live-entry list is kept per stack (ordered list, revision and registry), and the anchor and clock are made only when used. (3) The stack's 60-frame backstop copy of an unchanged stack replays like the list it copies (compared by content) instead of forcing a full frame. Measured on the Cookbook's main scene (5 entries, 9 passes, static camera, 12 s): forced full frames went from 58 to 0, mean styleKit render time from 0.20 to 0.17 ms a frame in a headless client; what is left on a replayed frame is almost all the engine's own per-pass enqueue (about 4 µs warm per pass). The frame drawn is unchanged.

1.8.0 (2026-11-13): published inputs. A block can now read a texture another package computes on each machine: the producer calls StyleKit.publishInput(name, texture) and every block that lists input:<name> under reads gets it bound to its in_<name> texture (black while nobody publishes it); StyleKit.inputs() lists what is published and StyleKit.inputWanted(name) says whether a live block (synced stack or local entry) reads it now, so the producer only works while one does. checkBlock pairs each input: read with its in_ texture and does not ask for a description or default for in_ textures. Inputs are never synced or saved. Asked for by sensor-look blocks (thermal, sonar, x-ray) that read a heat map, a sonar wave and a thickness map made by other packages; before this a block could only read styleKit's own fields. The test suite gains "published inputs reach the blocks that read them"; the writing-a-style-block guide and the styleBlock type README describe it. Nothing changes for existing blocks.

1.7.9 (2026-11-12): a look costs the engine less per frame. Measured with the engine's own CPU and GPU time (look off against on, 1920 x 1080, 2,500 things) on animeBlocks' one-pass TV anime look, which went from 10 passes to 5 and from about 0.33 to 0.19 ms of styleKit script a frame. (1) A frame in which nothing the stack draws from has moved (the stack, its local entries and options, the tier, the images, the camera's anchor, the view, the channels) hands the engine the previous frame's passes again and skips the rest of its work; a held clock step writes only sk_clock; every 15th frame, a frame with a new effect still settling, a driven clock and objects still awaited take the full path, so every periodic check keeps running. (2) The ground and wobble a look reads when no block of it publishes them are tiny constant images written every few seconds instead of two full-screen passes every frame. (3) Excluded objects: the hand-off blends the styled result over the screen, which still holds the frame as rendered, transparent where an object is kept, so there is no copy of the original frame and no copy before the hand-off (three passes become one; kept objects stay full size and crisp on every tier). (4) When the object mask only keeps objects as rendered (no mask group, no channel), the restore reads the exclusion's own part and the merge pass is skipped; when the merge does run it reads only the parts in use. (5) The stack's own effects are registered the first time a look uses them (the engine surveys every registered effect each frame): the TV anime look holds 4 instead of 10. Checked: excluded objects stay exactly as rendered (a pedestal and a ball excluded on animeBlocks' plaza), and the TV anime look looks as before.

1.7.8 (2026-11-12): quieter on a scene saved before styleKit 1.5. Its StyleStack has no roles field (the role set lives on the StyleRoleSet component beside it), and setting a role set tried to write the old field as well, logging a refusal each time; once a read has found the field missing, the write is skipped. Found following the Summit Sprint example guide on a fresh fork. Nothing else changed.

1.7.7 (2026-11-12): a role set or look that another player changes (or a pull brings) now reaches this machine at once. The asset type's change hook runs only on the machine that made the change, so every other player kept the old roles and looks until they reloaded; each registered role set and look is now watched, and a change arriving from elsewhere is read again. Checked with two clients: a role set edited in one was read in the other within the same session, with no restart. Nothing else changed.

1.7.6 (2026-11-12): a style channel reports inkByHand when its ink was set on the object by hand rather than by its role, so runtimes can draw it as set (toonBlocks 1.4.0 mixes none of the object's own colour into it). Role sets take noLook:, the set one written with extends: look sits over while no look is on: styleRoles' sets for kinds of game name the toon game set, so a game's hero, enemies and pickups carry their groups (player, enemy, pickup, and with them the variant lines and glazes) from the start rather than only once a look is picked; before, with no look on, a game set gave its hero the variant hero, which no line or glaze targets. Nothing else changed.

1.7.5 (2026-11-12): styleKit's checks pass in a world that holds only styleKit (or only styleRoles, which brings it). "Clearing puts the frame back as rendered" loaded starterBlocks' plainPaper, so where starterBlocks is not installed the load was refused, nothing drew and the check failed (since 1.7.4 a plain styleKit install no longer brings starterBlocks along); it now stacks styleKit's own posterize, duotone and depthLine. "Block defaults stand over the shader's" skipped itself unless another package's block stated defaults (paperBlocks); it now writes a throwaway block of its own whose block.yaml states amount: 0.37 over the template shader's 0.5, checks it, and removes it, then checks every other installed block that states defaults. In a fresh world with only styleRoles installed the suite passed 13 of 13 twice, with nothing skipped (it was 11 passed, 1 failed, 1 skipped). No block, shader or runtime changed.

1.7.4 (2026-11-12): styleKit (and everything that brings it, styleRoles first) installs into an empty world again. The styleKit agent skill listed the Lookbook (lookbookKit.Lookbook, lookbookKit.lookbook) among its dependencies, so every install of styleKit brought lookbookKit along under deps, and lookbookKit's own pin on starterBlocks could not be met there: a fresh world that installed only styleRoles refused it ("is not installed, because it does not run"). The Lookbook stays optional, as the skill and the restyle workflow already said (they use it only where a world has it); it is no longer a dependency. Nothing else changed.

1.7.3 (2026-11-12): fixes on top of 1.7.2, which came in as pull request #12 (another account's, merged). The stand-in search 1.7.2 added ran one name search over the whole scene per object with a channel on every sweep, and every second for 15 s after roles arrive: 0.023 ms each in a 158-thing scene, so 14 ms a sweep with 600 roles, growing with the scene. It now builds one index of stand-ins per prefix with a single glob search (pk_vis_*), kept until anything spawns or despawns: 0.0035 ms. And look(id) / pigmentSet(id) scan again on a miss at most once every 2 s: the role set picker and the roles test ask for looks that are not installed on purpose, and each miss read every look and pigment set the world holds. Checked here: 40 coin stand-ins and their child meshes all take the pickup role.

1.7.2 (2026-11-12): a role reaches pickupsKit coins (from the first second of play), and a look installed after the first scan is found.

  • A style channel now also reaches an object's stand-ins: root entities named <prefix><owner id> that a kit draws in the object's place. pickupsKit pools every pickup's model as its own root, pk_vis_<pickup id>, so StyleRoles.give(coin, "pickup") (the guide's own example) reached nothing the coin draws: on a pencil level the coins stayed grey, with no gold glaze and no ochre line, while the hero and enemies took theirs. pk_vis_ is registered by default; StyleChannels.addStandInPrefix(prefix) registers another kit's. For 15 seconds after channel owners arrive (a scene load, the start of play), subtrees are swept every second instead of every 10, since pickupsKit builds its visuals a frame or more after the pickups; without that, coins stayed grey for the first 10 seconds of play. On a 16-coin, 2-gem level, 52 of 52 coin and gem models took their role (0 before), and ReadApart's least distance read 19.3 with roles on and 2.5 with roles off.
  • look(id) and pigmentSet(id) scan again on a miss. Looks were scanned once a session and then kept up by per-file registration, so a block package installed into its own folder after another install had first placed it under deps/ (inkBlocks, brought by pencilBlocks, then installed itself) lost its looks in the move: applyLook("comicInk") answered "no look called comicInk" and the RoleSetSwitcher's Ink comic button switched the roles alone, until the editor restarted.

1.7.0 (2026-11-12): groups that share a material read apart under every look, untagged things keep the plain line, and a look switched on never flashes black.

  • New block Roles glaze (roleGlaze, Colour): a glaze of one colour over one variant's objects, keeping each surface's own value (a white surface takes a light tint of it, never paper white). Role sets gain glazes: beside lines: (merged through extends the same way), and styleRoles 1.3.0 adds one glaze per group. On a plain stage where one player, five enemies and five pickups share one white material, the least distance between the groups with roles on went from 4.0 to 18.9 under Picture book, 4.2 to 22.6 under Watercolor, 10.7 to 26.5 under Pencil sketch, 10.1 to 17.4 under Ink drawing, 11.5 to 19.4 under Comic ink and 20.2 to 43.0 under Paper cutout game (styleRoles' README has the table).
  • describe() reports each entry's variant. It did not, and toonBlocks' ink reads its entries from there, so under a toon look every variant line a role set adds was drawn on every object, things with no role included, and the last one won: lamp posts nobody tagged came out in the arena shooter's hazard orange, and in enemy red once the hazard line was removed. Untagged things now keep the look's own line.
  • A look's passes run only once every shader they use has compiled; until then the frame is shown as rendered (at most 4 s per new effect). A pass whose shader has not compiled draws nothing, and the next pass then read an image that was still black, so in a fresh engine, where a look's first compile takes seconds, switching to a look could flash the screen black.
  • The dim guard lets an object whose style channel asks for a lighter line weight (under 1) lighten in proportion, so a light pencil on one object reads lighter than the rendered frame even in a dim picture (pencilBlocks' per-object weight test: weight 0.3 read 245 against 204 with no channel, where before the guard held it at the rendered 90).
  • StyleKit.setLocalEntry(id, entry?) and localEntries(): a whole entry on this machine only, from pull request #10 (another account's, made on 1.5.1 with seven conflicts; ported by hand, the rest of that pull request was older copies of files this world has since moved on).

1.6.5 (2026-11-11): A new effect's settings, frame values and sun are written every frame for its first three seconds. A value written before an effect's shader had compiled read as the shader's default (#22741) and was written again only by the every-30-frames backstop, one effect at a time, so a look switched on from nothing (a stack with a paper most of all) drew a lighter, half-set picture for two to four seconds and then snapped to the real one. It now draws the settled picture from its first frames (measured: FLIP 0.049 from the settled frame for the first 2.5 to 3.5 s before, 0.000 from the first sample after). Found by running every suite twice in a freshly installed world: paperBlocks' unpaint test and pencilBlocks' shadow-band test read the picture inside that window.

1.6.4 (2026-11-11): the role mask is rebuilt at most four times a second while channels keep changing (enemies spawned and killed every frame in a busy level), where it was rebuilt on every frame something changed; a read for one object (channelOf) always sees the latest. With toonBlocks 1.3.6 this takes the look with 600 role holders from 1.33 to 0.93 ms on the median frame (table under Style channels). Every README in the package (each block, look, shader and guide) now ends with a Known limits section naming the engine issues that apply there. It also carries what was prepared as 1.6.3: a role or channel given to a player template (an entity holding a PlayerPrototype, such as the Player of the engine's player scene) now goes on the template's body, which is what the engine copies into the world for each player who joins. Before, StyleRoles.give(entity.find("Player"), "hero") reported success and read back as hero in edit, but the template itself is never in the world, so no actual player, late joiners included, carried the role. setChannel, give, clearChannel and channelOf all follow the template to its body. Found by installing the look into a new world and building a small scene from the engine's player template.

1.6.2 (2026-11-11): a look, a block or a role set change works after a play restart. The kit held a handle to the scene's StyleStack across the restart; the old component still answered reads, so the kit kept using it, and every write failed with "the component this proxy names was removed". A write that fails that way now drops every held handle, finds the scene's stack again and runs once more. Found while checking styleRoles 1.1.0 on a fork of Summit Sprint.

1.6.1 (2026-11-11): (released as 1.6.1 because the number 1.6.0 was already taken on ZeroMind) role sets for a kind of game. A set may write extends: look to sit over whichever set the scene's look suits (its line weights and inks over that set's, which keeps deciding tone, fill, paper and value), so one set works under every look and follows a look change by itself; variant lines merge the same way, variant by variant. StyleKit.roleSet(id) lays such a set over the current look's set, StyleKit.lookRoles() names that set, StyleKit.EXTENDS_LOOK is the word. New ChannelProbe module, a test helper that measures what one object's channel does to the presented frame (used by every block package's tests). A scene's script cost is unchanged (see What it costs).

1.5.1 (2026-11-11): the scene's role set is kept on a StyleRoleSet component beside the StyleStack (and in the stack's roles field where a client has it). An editor that had styleKit 1.4 open when the update arrived keeps the stack's old fields until it restarts; there StyleKit.setRoles used to report success while the write failed, and reading the set logged an error every frame. Both work now. Found by installing the release into a fork of Summit Sprint.

1.5.0 (2026-11-11): one look, and players, enemies and pickups read apart under it. A StyleChannel on any object (synced, saved, reaching everything under it) says which variant of the look it gets or asRendered, how heavy its line is, how much of the look's line, tone, fill and paper reaches it, one free value and an ink colour, or just names a game role the scene's role set fills in. A new asset type, styleRoleSet, holds role sets (with extends: for an author's own); StyleKit.give, setChannel, channelOf, clearChannel, channels, setRoles, roles, roleSets, roleSet and setVariant, and variant on add. The object mask (sk_obj) now packs exclusion, mask groups and each object's channel; every block is weighed by its kind of mark and its entry's variant inside sk_weight, so every installed block honours channels with no change; sk_chan_* helpers let a block read line weight and value; depthLine and sketchLine take the line weight. A scene with no channel draws exactly as before and makes no mask. Writes to another player's object go to its owner. StyleKit.VERSION says 1.5.0.

1.4.24 (2026-11-10): less work every frame. The stack's entries are copied and put in order once per change (any property change on any machine moves the stack's revision) instead of every frame, with a fresh copy every 60 frames as a backstop; each effect's shader-reload counter (a name lookup) is read every 30 frames instead of every frame; the quality tier and the render targets' residency are checked every 15 frames (a rebuilt render device is still caught the frame it happens). Measured under toonBlocks' bench with 2,500 things, the style stack takes about 0.23 ms on the median frame on one shared line (0.33 ms with eight per-object ink styles, which was 0.33 ms with more variance on 1.4.23).

1.4.23 (2026-11-10): nothing on a timer looks over the scene. The sun and the light rows are read only when a light or the sky changed (a native watch over the engine's Light and Sky components; before, the "is anything lit" check read the light rows once a second); a scene stack and the objects named in its groups are looked for again only when the entity set changed (before, twice a second while one was missing). The cached writes to every effect are renewed when the render device is rebuilt or a block's shader reloads (both counted by the engine), and as a backstop one effect in turn every 30 frames, instead of every effect at once every 30 frames and every schema every 120, which put a 2 to 5 ms frame into the stack every half second. The surface capture reads toonBlocks' ink mask (StyleRuntime.setInkMask), so the toon ink line drawn on the engine's outline effect is kept exactly as drawn by every block after it; StyleRuntime.directLight() answers whether anything but ambient light is on.

1.4.22 (2026-11-09): the sun is read directly. The stack used to find the sun with the lighting toolbox's lighting.get, which surveys every entity and component in the scene (23 to 56 ms a lookup in a 2,450-entity game, about 70 ms of script a second in Summit Sprint, and 8 to 17 ms even in this world's 150-entity scene), once a second and whenever the stack changed. It now reads lighting.sun(), the sun the renderer itself shades with (a table read, about 0.0002 ms), every frame, and writes sk_sun to blocks only when the sun's direction (to three decimals) or whether it lights changes. Whether any other light is on (the dim guard's question) comes from the renderer's resolved light rows, once a second. A side effect that fixes a known limit: with two directional lights the stack used to follow the first one by entity id, which could be a light that lights nothing (a world clock's sun); it now follows the one the renderer lights the scene with. Also new: StyleKit.revision() (a number that moves whenever the stack or the block library changes, for readers that derive from the stack) and StyleRuntime.cpuTotal() (the stack's script milliseconds since load, for per-frame cost meters). StyleKit.VERSION is unchanged in meaning; the guide "Combining blocks into your own art style" now says what a combination costs and which outline to pick for a big level.

1.4.21 (2026-11-08): moves to the engine's current built-in library (@builtin e89b9db), whose update rewrote small reference files inside the package (a world on an older built-in library is hidden from players). Nothing else changed.

1.4.20 (2026-11-08): moves to the engine's current built-in library (@builtin edb50c2), whose update rewrote small reference files inside the package (a world on an older built-in library is hidden from players). Nothing else changed.

1.4.19 (2026-11-08): moves to the engine's current built-in library (@builtin f4425a5), whose update rewrote small reference files inside the package (a world on an older built-in library is hidden from players). Nothing else changed.

1.4.18 (2026-11-08): releases the two contributions below from main, and moves to the engine's current built-in library (@builtin f39f044), whose update rewrote small reference files inside the package (a world on an older built-in library is hidden from players). One change on top of 1.4.17: between full scans the remembered sun is used only while its Light is enabled, so a sun switched off in a game stops lighting the drawing at once instead of up to a second later. 1.4.16 and 1.4.17 were the numbers the contribution branches published, so this release is 1.4.18.

1.4.17 (2026-11-08, contribution, pull request #4): the scene's sun is found once a second instead of every 4 frames. lighting.get walks every entity in the scene, which in a busy scene (about 750 entities) was about 3% of all Luau time with a spike every fourth frame; between full scans the runtime now reads the sun it found directly. A full scan still runs once a second, whenever the stack changes, every read while the clock is driven (the Lookbook, the test suites), and when the remembered sun is gone.

1.4.16 (2026-11-08, contribution, pull request #3): blocks from an updated package draw again without a restart. The block registry lives in module state, so after an update it still pointed every id at the old copy of the package, whose shaders the engine no longer lists; the new copy was renamed to a package-qualified id, and the stack drew nothing for those blocks. A block registering from another copy of the same package now replaces the old entry, StyleKit._rescan() rebuilds the registry from the blocks the engine lists, and the runtime rescans by itself (at most every 5 s) when it reports a missing shader.

1.4.15 (2026-11-08): the package's description now reads as a store listing (what you get and how to start), without a version number or a list of changes. No code changed.

1.4.14 (2026-11-08): a look drawn again after a clear lands in the right place. The runtime stores each place's position relative to an anchor near the camera, and writes that anchor into a small buffer only when it moves. A clear tears the buffer down with everything else, but the runtime still remembered the last anchor it had written, so a stack drawn again with the camera where it was (within 25 cm) got a fresh buffer that was never written: positions were stored against the world's origin and read against the real anchor, and paper grain and strokes landed in the wrong places, more so the farther the camera stood from the origin, until the camera moved. A new buffer now always gets the anchor. Found by pencilBlocks' suite in a fresh world, whose cases rebuild the stack at one camera pose 400 m out: the first build and every later one drew different marks. Checked on the Cookbook 500 m out: a stack cleared and drawn again with the camera still read FLIP 0.124 against the first draw before the fix and 0 after. No block or shader changed.

1.4.13 (2026-11-08): a released stack leaves nothing behind. When the last block goes, the runtime removes its internal effects; the neutral paper effect (skNeutralPaper) was missing from that list, so it survived every release and was registered out of order when the stack came back. It is removed with the rest now. Checked on the Cookbook: after a release no styleKit effect is left, and after a reload the internal effects come back in their usual order. No block or shader changed.

1.4.12 (2026-11-08): moves to the engine's current built-in library (@builtin f110cb3), whose update rewrote small reference files inside the package. Nothing else changed.

1.4.11 (2026-11-08): moves to the engine's current built-in library (@builtin a29b227), whose update rewrote small reference files inside the package. Nothing else changed.

1.4.10 (2026-11-08): settings for one machine only. StyleKit.setLocal(entry, settings) lays settings over one entry's synced settings on this machine alone (never synced, never saved; nil takes them off), and StyleKit.localSettings() lists them, so a look can follow each player (two friends on different levels, each at their own time of day) while every player still shares the same stack. Unknown names are ignored and colours converted exactly as set does; a change rewrites the effect settings once. Contributed as pull request #2 (published from its branch as 1.4.9), merged here. Checked on the Cookbook: a local paper tint changes this machine's frame (FLIP 0.76) while describe() keeps the synced entries, and setLocal(entry, nil) gives the frame back (FLIP 0.0000055). Also moves to the engine's current built-in library (@builtin c61f473), whose update rewrote small reference files inside the package.

1.4.8 (2026-11-07): moves to the engine's current built-in library (@builtin 7ca1f19), whose update rewrote small reference files inside the package. Nothing else changed.

1.4.7 (2026-11-07): moves to the engine's current built-in library (@builtin fdc9a99), whose update rewrote small reference files inside the package. Nothing else changed.

1.4.6 (2026-11-07): moves to the engine's current built-in library (@builtin 7e13a48), whose update rewrote small reference files inside the package. Nothing else changed.

1.4.5 (2026-11-07): moves to the engine's current built-in library (@builtin 2809239), whose update rewrote small reference files inside the package. Nothing else changed.

1.4.4 (2026-11-07): a guarded room is never drawn brighter than it was rendered, a pale prop in a dark room no longer glows, and an effect made again is bound again. The dim guard's allowance above the rendered brightness is 0 (it was 0.006, so a room with no light switched on read about 1.4 of 255 brighter than rendered). Beside matching the drawing's brightness to the render over areas about 36 pixels across, the guard holds each pixel to a little above the rendered brightness on its darker side (the darkest of four small patches ten pixels off, never below the pixel's own), so bare sheet beside a pale prop in a dark-walled room no longer keeps the prop's brightness: the share of its dark places drawn 25 levels brighter fell from 1.3 to 1.6% to about 0.3%. An effect made anew under the same name (a stack cleared and loaded again) is bound again to the soft field, the paper, the pigment palette and the rendered frame; their bindings stayed marked as done before, so the new effect could miss one. load keeps an option it is not given, as before, and now says so: to reproduce a look exactly pass all of its options or use applyLook. Also moves to the engine's current built-in library (@builtin 278f02f), whose update rewrote small reference files inside the package. StyleKit.VERSION says 1.4.4.

1.4.3 (2026-11-07): positions keep millimetre steps up close, so nothing laid on a surface streaks. The shared surface data holds each place's position relative to an anchor in half floats (three significant digits); the anchor snapped to a 64 m grid, so a camera just on the far side of the world's centre stood about 64 m from it and positions came in steps of a few centimetres. Paper grain, smudge and strokes laid on those steps drew thin horizontal streaks across a wall seen up close (the Charcoal study recipe showed it on its dark brick wall). The anchor now snaps to 25 cm around the camera, and moving it rewrites only the anchor (settings and object groups no longer follow it). On a dark wall 90 m out, seen close at an angle, the row-to-row change over the along-the-row change fell from 3.4 to 5.4 to 0.65 to 0.78 for charcoal and the soft leads on rough paper. Also moves to the engine's current built-in library (@builtin 6656162), whose update rewrote small reference files inside the package. StyleKit.VERSION says 1.4.3.

1.4.2 (2026-11-07): moves to the engine's current built-in library (@builtin 808b4a1), whose update rewrote small reference files inside the package. No block, look or shader changed.

1.4.1 (2026-11-07): skStrokes gains sks_edge_on(facing) and sks_layer_mean(tone, st, k). A floor or field seen at a low angle squeezed each patch of strokes into a short row, and the rows of stroke ends read as zebra bands across the ground (a plain ground plane in a fresh world showed it; the Cookbook's stage hid it). A block mixes each layer toward its average coverage where sks_edge_on falls below 1, so the ground keeps its value (within about 6 of 255 in pencilBlocks' check) as even rubbed tone. StyleKit.VERSION says 1.4.1.

1.4.0 (2026-11-07): the dim guard, so no shading block brightens a dim or unlit room. When a live block declares keepDim (every Tone block by default, any other block with keepDim: true in its block.yaml), two small passes after the chain (skDimMeter, skDimGuard) measure the stack's result against the frame as rendered and scale the result down wherever, smoothed over about 36 pixels, it comes out brighter than the room was, keeping every mark. It judges a picture dim by its mean (fully guarded below 0.30, free from 0.42 with brightest parts of 0.55 or more), and a scene with no light other than an ambient one switched on counts as unlit however bright the engine's fallback ambient draws it; daylight, an overcast day and a well lit room are handed on exactly unchanged. StyleKit._status().dimGuard reports whether it ran, and blocks registered before 1.4.0 get keepDim filled in. skStrokes: every layer of strokes at one place shares one patch grid and one slant, the first two layers run parallel and darker layers cross at 60, 30 and 90 degrees (was a 24 degree lean), so soft strokes no longer beat into broad zebra bands; new sks_layer_d sizes strokes on screen from the position's screen derivatives. sks_layer and sks_stack keep their signatures. The suite gains a dim-guard case in a closed room of its own (a white Tone block: lit room lightened, low lamp held to the render, the same block with keepDim: false lifting it, every light off black). StyleKit.VERSION says 1.4.0.

1.3.0 (2026-11-03): a new shared shader module, skStrokes (#include "~styleKit.shaders.skStrokes"): hand-laid strokes for any block that shades with marks, with stroke direction (sks_direction: follow the form, one fixed angle, crossed, scribbled, from the surface normal and world axes only) and stacked strokes by tone (sks_layer, sks_stack: darker tones add strokes on top of the lighter tone's, each stroke at its own threshold), laid in patches in 3D cells on the position you pass and kept on screen size by two octaves. Pure math, so materials can include it too. pencilBlocks (graphite, coloured pencil, charcoal, conte, ballpoint and doodle blocks, and a hero material) is built on it. The guide "Writing your own style block" has a section on it. No existing block changed.

1.2.4 (2026-11-02): a block's shader property schema (its settings' defaults, min and max) was cached by shader path and never forgotten, so editing a block's own defaults while its stack was live (adding a setting, changing a default) kept reading the schema from before the edit, sometimes for the rest of the session. It is now forgotten on the same twice-a-minute cycle the stack's other per-effect caches already use.

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.