Log inGet started
Package

toonBlocks.package

This package holds more than this page lists. See all of its files in its world.

README.md

toonBlocks

Give your game a cel-shaded toon look by stacking blocks. Light blocks decide how surfaces take light: hard bands in any number, a colour ramp the shade picks its colour from (thirteen ramps to switch between with one change), soft half-Lambert wrap light that keeps shapes readable in shadow, a rim light round silhouettes and a hard stylized highlight. Fill blocks lay areas of colour flat with a chosen shadow colour, plain, hue-shifted or as two-tone poster paint. Line blocks draw a toon ink line round every object on the engine's own outline effect: depth correct (a wall or floor in front hides it), antialiased at full resolution, and the same cost for ten things or ten thousand, with an inverted hull on skinned characters so they get lines inside their silhouette too. Thirteen ink styles share one set of settings and are picked by one name: thin ink, fine pen, bold comic, brush-weighted, coloured from the object, tinted, soft grey pencil, white chalk for dark scenes, characters only, heavy poster contour, a white or black sticker border and one that thins with distance; per material, per object, or a style of its own on one object. The same toon light also goes inside chosen materials (a hero, a material collection). Seven whole looks apply in one change and then let you change any one part.

Get started in three steps:

  1. On ZeroMind, search "toonBlocks" and install it into your world. It brings styleKit and every other package it needs.
  2. Apply a whole toon look in one change: require("~styleKit.StyleKit").applyLook("comicInkCel") (or saturdayMorning, softAnime, clearLine, thickSticker, ninetiesCG, pencilAnime).
  3. Change any one part of it in one change: require("~styleKit.StyleKit").swap("light", "toonRamp") (light, fill or line), and StyleKit.clear() gives the frame back exactly as rendered.

Every block is a styleKit block, so it stacks with inkBlocks, paperBlocks and watercolorBlocks, swaps for any other block in its slot with one change, and comes off leaving the frame exactly as it was.

Version 1.4.3. Pins styleKit 1.7.8 (style channels: one look, and players, enemies and pickups read apart under it) and is built on what styleKit 1.2.4 added (the scene's sun, swap memory, the drawn-ink tag that keeps outline ink out of every block's way).

Install and use

Install toonBlocks from ZeroMind (search "toonBlocks" or "cel shading for my game"). It brings, whole, every package it lists as a dependency: styleKit (the look stack), starterBlocks (styleKit's simple blocks, lightBands among them), lookbookKit with its Lookbook scene (the test suite measures at the Lookbook's every-light-off moment) and toonMaterials with materialLibraryKit (the outline runtime asks toonMaterials whether an object already carries its own ink, so nothing is outlined twice). Checked from ZeroMind in brand new private worlds, release by release. 1.0.7: 1,474 files in about 2 s, every package above among them, the Lookbook scene included; the example below ran line by line exactly as written (the look applied with its 5 entries and 7 outline shells; every swap and setRamp answered true; the outline came back at the width it had, 2.2; clear() left the stack empty and the frame at exactly its unstyled brightness, 196.64 before and after); the test suite passed 10 of 10; and the example guide's outline lines, which name objects ("showcaseCharacter", "Star1"), ran as written. 1.0.9: the suite passed 10 of 10 under a fresh world's default light and left the installed Lookbook exactly as it came. 1.1.1: 1,474 files in 13.9 s; the example below word for word (5 entries, 7 shells, every swap and setRamp true, the outline back at 2.2, the frame at 197.45 before and after clear()); the suite 11 of 11, twice. 1.1.2: 1,458 files in 29 s; the example below word for word (5 entries, 7 shells, every swap and setRamp true, the outline back at 2.2, the frame at 198.06 before and after clear(), 0 entries left); the suite 11 of 12: its close-up figure check failed on toonRamp (3 lone specks), which 1.1.3 fixes (see its entry). 1.1.3's own check from ZeroMind in a brand new world (the example below word for word, the suite twice) is recorded in the Style Cookbook world's NOTES.md, since a release cannot record its own install. Installs with several dependencies can take a while (#21420).

Then, in a fresh world with only toonBlocks installed, from the console or any script:

local StyleKit = require("~styleKit.StyleKit")
local ToonBlocks = require("~toonBlocks.ToonBlocks")

StyleKit.applyLook("comicInkCel")        -- bands, rim, highlight, flat cel colour and an ink outline
StyleKit.swap("light", "toonRamp")       -- ramp light instead of bands: one change
ToonBlocks.setRamp("sunset")             -- the whole look at sunset: one change
StyleKit.swap("line", "toonComicLine")   -- a bold comic ink line: one name
StyleKit.swap("line", "depthLine")       -- styleKit's depth line instead of the toon ink
StyleKit.swap("line", "toonOutline")     -- the toon ink back, with the width it had
StyleKit.clear()                         -- the frame exactly as rendered again

The stack lives on the scene's synced StyleStack, so every player sees the same look and the same outline widths, and it is saved with the scene. StyleKit.blocks({ package = "toonBlocks" }) lists the blocks, ToonBlocks.ramps() the ramps, StyleKit.looks() the looks; in the shell, zero styleKit list light and zero styleKit list --tag toon.

The blocks

BlockSlotWhat it doesMain settings (default)
toonBandsLightThe light on every surface cut into flat bands with tinted shadows and clean edges; keepShade can lift the shade so shaded surfaces keep their own colourbands 3, shadowLift 0.65, keepShade 0 (off), shadowTint, bias 0.05, softness 0.015
toonRampLightThe shade picks its colour from a five-stop ramp, blended or steppedrampDark to rampHigh, shadowAt / midAt / lightAt, hard 0.75
toonWrapLightSoft half-Lambert wrap light: darks lifted, form kept readable in shadewrap 0.8, wrapPower 2, shadowShape 0.6, bands 0 (smooth)
toonRimLight (chain)A hard band of light round silhouettes, found from depthwidth 4 px, strength 0.7, side 0, fresnel 0.5
toonHighlightLight (chain)A hard-edged cut-out glint on the round parts and bevelled edges of sunlit things, on the side facing the viewersize 0.55, fromView 0.5, softness 0.03, strength 0.85, curvedOnly 1, curveReach 5
celFillFillEach area of colour laid flat, light split into a lit tone and a chosen shadow colourflatten 0.85, shadowColour, shadowLevel 0.6, threshold 0.42, keepLight 0
celHueShiftFillThe cel fill with shadows turned cooler and more saturated, lights a touch warmerhueShift 0.07, shadowSaturation 1.3
celPosterFillTwo-tone poster paint: flat colours cut into a few values, one hard shadowposterLevels 3, saturation 1.3
toonOutlineLineA thin even ink line round every objectwidth 2.5 px, units 0 (screen)
toonStickerLineA thick white die-cut border with a thin dark edgewidth 6 px white, outerWidth 1.5 dark
toonStickerBlackLineA thick black borderwidth 6 px black
toonTintLineLineA line in each object's own colour, darkenedwidth 1.6 px, tint 1, tintDarken 0.5
toonFarLineLineA line that thins with distancewidth 3.5 px, fadeStart 6 m, fadeEnd 60 m, minWidth 0.7
toonPenLineLineA fine, even pen linewidth 1.2 px
toonComicLineLineA bold comic line, thinning far away, a little brush weightwidth 3.5 px, brush 0.25, fadeStart 25 m, fadeEnd 120 m, minWidth 1.5
toonBrushLineLineA brush-weighted line: broad across the stroke, thin along itwidth 3 px, brush 0.8, brushAngle 35
toonColourLineLineA dark shade of each object's own colour, read at its edgewidth 2 px, tint 1, tintDarken 0.5
toonPencilLineLineA soft grey pencil linecolour #4a4a52, width 1.6 px, softness 0.8, opacity 0.75
toonChalkLineLineA white chalk line for dark scenescolour #f2efe6, width 2.4 px, softness 0.5, opacity 0.9
toonCharacterLineLineA line on characters (skinned models) onlywidth 3 px, targets 1
toonPosterLineLineA heavy poster contourwidth 7 px, minWidth 3

The light blocks share fullLight, keepLightColour and (bands, ramp, wrap) smoothLight; bands, ramp and the fills share shape, shadeLevel and castBelow. The three fills share one set of settings, and so do the thirteen line blocks, so StyleKit.swap(entry, id, { keepSettings = true }) carries tuning from one to the next. Every setting has a doc string: StyleKit.settingsOf("toonBands").

How the light is found

A full-frame block sees the finished frame, not the lights. Each light block divides the frame by the surface's base colour (both as the display shows them, so a sunlit surface always ranks above its own cast shadow) to get the light the scene sent, smooths away normal-map and occlusion grain on the same surface (smoothLight, a dense 8 x 8 pixel mean), and then redraws a clean toon light from the scene's sun, mixed in by shape: shadeLevel where a surface turns from the sun or the light that arrived says a cast shadow covers it, climbing to full where a surface faces the sun squarely, with open ground in sun three quarters of the way up. toonBands cuts its bands across that climb, so shade is always the darkest band, a round object passes through every band, and more bands step sunlit ground and walls too. So cast shadows stay where the scene put them, lamps and coloured light still count, and the bands follow shapes instead of texture. With no sun in the scene, shape changes nothing and the light is cut as it was rendered. The normal the light is drawn from is each surface's own shading normal (from the deferred renderer's copy), averaged over a dense 8 x 8 pixel square so a low-polygon round shape turns smoothly; on the forward path it is rebuilt from world positions four pixels apart.

How starterBlocks' stepped light relates

starterBlocks' lightBands (Stepped light) is the simple version: one shader steps brightness over base colour into bands. It is cheap and stays a fine choice for a quick look. toonBands sits in the same Light slot and swaps with it in one change (StyleKit.swap("light", "lightBands")); it goes further where lightBands stops: tinted shadows, a band bias, anti-aliased edges, light read in display values so sun and shadow rank correctly, grain smoothed away, clean bands from the sun's direction with cast shadows kept, and a family around it (ramp, wrap, rim, highlight, the toonLit material). Nothing in toonBlocks repeats lightBands; use one or the other in the Light slot.

Ramps

Thirteen ramps ship as toonRamp assets: classicCel, warmCool, sunset, pastelAnime, comicTwoTone, noir, candy, toxicSciFi, autumn, moonlight, storybook, plasticCG and goldenHour. A ramp is five colours of light (dark, shadow, mid, light, high) and where they sit; each multiplies the surface's own colour, so objects keep their colours and only their light and shadow change.

ToonBlocks.setRamp("moonlight")   -- every toonRamp entry and every toon material, for every player
print(ToonBlocks.currentRamp())   -- "moonlight"
for _, r in ToonBlocks.ramps() do print(r.id, r.summary) end

Make your own with a folder myRamp.toonRamp/ holding ramp.yaml (see the toonRamp type's README), a README and .metadata; it is listed as soon as it lands.

Outlines

Since 1.2.0 the line blocks draw a toon ink line on the engine's own outline effect (its jump-flood seed and flood passes) with toonBlocks' own composite (toonInkLine) on top. Everything plain gets one shared line grown from the depth edges of the frame: wherever a surface stands a step in front of what is beside it, the line is drawn outside that silhouette, over what stands behind, so a wall or floor in front of an object hides its line, and nothing per object is kept or worked out. Skinned characters keep an inverted hull on their own skeleton, which bends with every pose and also draws the lines inside the body. Objects with ink of their own (an override, a per-object style, a masked group, toonMaterials' own ink) are drawn as small groups of their own.

  • Ink styles by name: StyleKit.swap("line", "toonPencilLine"); all thirteen line blocks share their settings, so a style is a name and a set of defaults. The settings added in 1.2.0: targets (0 everything, 1 characters only, 2 everything but characters), brush and brushAngle (weight by direction), softness and opacity.
  • Width in screen units (units = 0, the default): width in reference pixels (1080p). The push happens after the camera projection, so the line is that many pixels wide near, mid and far, on any screen size, and on animated characters. toonFarLine thins it from fadeStart to fadeEnd metres down to minWidth.
  • Width in world units (units = 1): width in centimetres of real thickness, thinner with distance like any edge, never below minWidth pixels.
  • For one object (the entity, its id or its name): ToonBlocks.setObjectOutline(hero, { width = 5, colour = "#2a1030" }), ToonBlocks.setObjectOutline("Hero", { style = "toonChalkLine" }) (a style of its own), false for none, nil to follow the stack again (a synced ToonOutline component, saved with the scene; children follow their parent).
  • For one material: ToonBlocks.setMaterialOutline("toonBrick", { width = 4 }) gives every object wearing that material its own outline; { enabled = false } leaves them without (a synced ToonOutlineRules entity).
  • Swapping: the outline is an ordinary Line entry, so StyleKit.swap("line", "inkPenLine"), "depthLine" or "sketchLine" replaces it in one change and its line goes with it; swapping back puts back its settings.
  • No double ink: objects that already carry their own ink (toonMaterials' ToonInk or a ToonProp with its outline on) are left to it while skipOwnInk is 1.
  • Strength and masks: the entry's strength scales the width; its mask picks the objects (a group, a sphere by object position, or a depth band cut per pixel, inverted or not); the stack's left-out objects get none.
  • The ink stays ink: the line marks its pixels in styleKit's drawn-ink mask (styleKit 1.4.23; character hulls tag theirs as before), so the light and fill blocks, and every other package's blocks, leave the line exactly as drawn: a white sticker border stays white.
  • What it costs to run (1.2.1, measured): on one shared line the whole look takes about 0.3 ms a frame on the median frame (the outline about 0.06 to 0.1 ms of it) with 2,500 things, moving or still, and the number of things does not change it; each per-object ink style adds about 0.05 ms a frame, so the Ink Showcase's eight styles side by side cost about 0.7 to 0.8 ms (outline 0.4 to 0.5). Per-material rules and sphere masks bring back per-object work. "How to keep a toon look fast in a big game" has the table and how to measure your own level.
  • The line is tidied where a figure overlaps itself (1.1.2): where one part of a figure lies over another (a waist plate over the hips, a panel on a shin) the shell's back meets the body behind it at almost the same depth, so the body hides most of it and the line comes out one pixel thin, in dashes, with single ink dots between. The outline entry's own pass reads the drawn-ink tag and tidies the line it finds: ink joined to nothing beyond a 9 x 9 square (a dot or a short dash) takes the paint round it, a one pixel thin stretch of line gets a second pixel below or right of it, a pinhole of paint inside the line is filled, and a one pixel sliver of paint caught against the line (a band or rim the ink covers most of) takes the middle of the paint round it. Lines, however thin or far, and a band or rim wider than a pixel keep their place. On the low tier and the forward path, which keep no base colour copy, the pass leaves the frame as it is.

Toon light inside materials

local ToonMaterial = require("~toonBlocks.ToonMaterial")
ToonMaterial.paint(heroId)                              -- the stack's own toon light, inside the hero's materials
ToonMaterial.paint(heroId, { mode = "ramp", ramp = "sunset" })
ToonMaterial.fromMaterials("/zero/source/masonryMaterials.package/sets")   -- toon copies of a whole set
ToonMaterial.unpaint(heroId, { removeFiles = true })   -- the originals back, the files gone

paint gives every Model and SkinnedModel under an object a derived toonLit material that keeps its base colour and texture and takes the toon light (bands, ramp or wrap, with rim and highlight) from the stack or from opts. It is lit by the scene's sun with its shadows, its ambient and every lamp, banded the same way as the full-frame blocks (both use the toonLight shader module). Originals are recorded on a synced ToonSurface component, so every player sees the same, and unpaint puts them back. To keep the full-frame light off a painted hero, put the hero in a mask group and give the light entry mask = { kind = "group", group = 1, invert = true }.

Whole looks

LookBlocks
saturdayMorning (Saturday-morning cartoon)toonBands 2 bands, celFill saturated, toonOutline 3.5 px
comicInkCel (Comic ink cel)toonBands, toonRim, toonHighlight, celFill, toonOutline
softAnime (Soft anime)toonRamp pastel, toonRim back light, celHueShift, toonTintLine
clearLine (Clear line)celFill light two-tone, toonOutline 1.4 px even
thickSticker (Thick sticker)celPoster, toonSticker
ninetiesCG (Nineties CG TV)toonRamp plastic, toonHighlight hard
pencilAnime (Pencil anime)toonRamp pastel, celHueShift, styleKit's sketchLine

StyleKit.applyLook("softAnime") puts a whole look on; then change one part: StyleKit.set("line", { width = 2.5 }), StyleKit.swap("light", "toonBands"), ToonBlocks.setRamp("candy").

Mixing with ink and paper

A flat toon fill on brown kraft paper with an ink outline (needs paperBlocks):

StyleKit.load({
    { id = "fill",  block = "celFill" },
    { id = "line",  block = "toonOutline", settings = { width = 2 } },
    { id = "paper", block = "paperKraft" },
})

Soft anime ramp light with pencil lines instead of ink: StyleKit.applyLook("softAnime") then StyleKit.swap("line", "sketchLine"), or StyleKit.applyLook("pencilAnime"). With inkBlocks, StyleKit.swap("line", "inkBrushLine") puts a brush line on the cel look. The guides "toon light with ink lines and paper" and "how to make a cel-shaded look for my game" walk through more.

Quality

StyleKit.setQuality("low") really changes the cost: toonBands reads the light unsmoothed (smoothLight 0), the light smoothing and the averaged normal read a 4 x 4 pixel square instead of 8 x 8, the cel fill's colour gathering takes 4 taps a ring instead of 8, the rim reads a 2 x 2 grid of depth instead of 4 x 4, the fill gathers over a smaller radius, and outlines are drawn only within lowDistance (45 m) of the camera. The Lookbook numbers below give the cost per pass on both tiers.

Multiplayer

Everything that decides the look is synced state: the stack's entries and settings, the ramps put on them, each object's ToonOutline, the ToonOutlineRules entity and each painted object's ToonSurface. The line is drawn on every machine from its own frame and that synced state (character hulls are local and never saved), with widths in reference pixels of each player's own screen height, so every player sees the same look and the same outline widths. This engine checked one peer; two engines on one account collide as one player (#14448), so a two-player check needs two accounts.

What is in the package

  • blocks/: the 21 blocks, each with a picture (preview.png) of the same station in that block, and their 7 shaders (toonBands, toonRamp, toonWrap, toonRim, toonHighlight, celFill, toonOutline: the three fills share celFill's and the thirteen line blocks toonOutline's).
  • ramps/: 13 toonRamp assets; toonRamp.assetType: the ramp type.
  • looks/: 7 styleLook assets, each with a picture of the look.
  • shaders/: toonLight (the shared light math), toonFrame (what a full-frame block reads), toonHull (the characters' hull material), toonLit (toon light in a material), and the ink line's toonInkEdges, toonInkLine, toonInkSceneCopy and toonInkClear.
  • ToonBlocks (ramps, outlines per object and material), ToonInkRuntime (the ink line runtime; ToonOutlines is its old name and gives the same module), OutlineBench (a busy level and a per-frame meter), ToonMaterial (toon light in materials); components ToonOutline, ToonOutlineRules, ToonSurface.
  • guides/: how to make a cel-shaded look for my game; tuning toon outlines and light for games; how to keep a toon look fast in a big game; toon light with ink lines and paper; example: a cartoon level with a cel-shaded look. workflows/toonWorld.workflow: give a game a cel-shaded look step by step, and undo it.
  • tests/toonBlocks.testSuite.

One object's own line: the style channel

The per-object outline is part of styleKit's style channel, the one setting every block reads, so a toon look and every other look treat a hero, an enemy or a coin by the same rule. An object's StyleChannel (or the game role it carries, read through the scene's role set from the styleRoles package) gives its toon ink:

  • line as the ink's weight: the stack entry's width times it (2 draws a boss twice as heavy, 0 draws no line);
  • marks.line as how much of the line reaches it (0 none, 0.5 a half-strength line);
  • ink as its line colour (an enemy in dark red ink, the hero in deep navy);
  • value as how much the line takes the object's own colour (a coin outlined in gold);
  • variant: a toon Line entry naming a variant draws only on objects of it, and the entry naming none leaves those objects to it, so the player and the enemies can wear two different ink styles from one stack (StyleKit.add("toonComicLine", { variant = "enemy" })).

ToonBlocks.setObjectOutline(entity, { weight = 2, colour = "#5a0010", tint = 0.4 }) writes those onto the object's channel; false lets no line through. The toon-only parts, an exact width with its units and an ink style of the object's own, stay on a ToonOutline component beside it and are laid over the channel field by field, so scenes made before 1.3.0 draw as they did. Characters keep their hulls, plain objects their screen-space rims; both read the channel. Every field is synced and saved with the scene.

Known limits

Engine limits, numbered as in "How to keep a toon look fast in a big game" (details and numbers there), each with its tracked issue:

  1. A selection list costs every frame. Tracked: #24548 (ZeroMind report 01M73CCJBX6411XN8R07AT2P53).
  2. No per-object id in a shader. Tracked: #24549 (ZeroMind report 01M73CCJCED5KSFGMZTFKXWXBM).
  3. No change-only updates. Tracked: #24450 (ZeroMind report 01M73CCJE1ZYVJJ600GTSP8DB4).
  4. No "this material changed" signal. Tracked: #24450 (ZeroMind report 01M73CCJESVR3B0B7DCRJ82TMD).
  5. A screen pass sees the scene's depth only when it draws into the scene. Tracked: #24550 (ZeroMind report 01M73CCJFMF1ZFQAJDE701QE7A).
  6. The engine's outline composite (what the line can look like). Tracked: #24449 (ZeroMind report 01M73CCJH4KMPNX8ACFFPC1PWS).
  7. No crease lines. Tracked: #24449 (ZeroMind report 01M73CCJHW548K2QP4PJC3B1A6).
  8. camera.viewData() has no near and far planes. Tracked: #24514 (ZeroMind report 01M73CCJK53V4RX4465BXDKJ0E).
  9. Every pass is queued again every frame. Tracked: #24548 (ZeroMind report 01M73CBNQWVMF5XWMD4KJAJ5MC).

Every one of these now has a number in the engine team's tracker. Limits of toonBlocks' own design, and other engine issues it works around:

  1. Glass gets no line: see-through materials write no depth. By design; no engine issue.
  2. Per-material rules and sphere masks bring back per-object work: objects are worked out a few a frame in a 0.4 ms budget while either is on the stack. By design; no engine issue.
  3. Why the hull is a copy and not a render pass: a material drawn by a render feature's extra geometry pass is given the drawn object's own material in the vertex stage, so a hull drawn that way ignores its own width (toonMaterials' ink is a fixed 3 cm for that reason). toonBlocks draws its hulls in the normal draw path, where the width is exact. Tracked: #21428.
  4. Very thin or open meshes (a plane, a single-sided leaf card) show no hull line: there is no back to push out. Foliage cards and particles are left to a depth line. By design; no engine issue.
  5. A hairline gap at a character's sharp creases at large widths: skinned shells push along normals only. Flat-shaded characters wear a smoothed copy of their mesh (built once on every machine from the same bytes, corners that share a position share one averaged normal) so the shell does not fall into dashes; it is ready a moment after the shell appears. By design; no engine issue.
  6. Light from the frame: a full-frame block reads light as frame over base colour; where the scene's lighting is very flat (strong ambient, a low sun) the clean sun light (shape) carries the look. Transparent things, the sky and the outline ink are left as rendered. By design; no engine issue.
  7. Post effects share no history and their stage order is not stated: toonBlocks keeps no history of its own, so nothing depends on it. Tracked: #17427, #17426.
  8. One sun: the look stack shades by the sun the renderer shades with (lighting.sun()), so a second directional light does not decide the toon light. By design (styleKit 1.4.22).
  9. A package's ZeroMind description can lag one release behind, the web check is the person's to run and web frame rates differ. Tracked: #19258, #20946.
  • Other engine issues that apply here: a per-object value cannot reach a geometry pass, so per-object looks go through styleKit's object mask (at most eight distinct settings) or need passes of their own (#24549); an unknown blend name draws as replace (#24551); 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); two engines on one account collide as one player, so a two-player check needs two accounts (#14448).

Removing it

StyleKit.clear() (or removing the toonBlocks entries) releases every shell and hull material; ToonMaterial.unpaint(entity, { removeFiles = true }) puts painted materials back; ToonBlocks.setObjectOutline(entity, nil) and ToonBlocks.setMaterialOutline(name, nil) take the outline records away. The toonWorld workflow's last step does all of it.

Lookbook numbers

Every block alone and every whole look, each measured twice on toonBlocks 1.1.2 on 2026-11-03 (09:52 to 10:28 UTC; toonRim again from 10:28 to 10:30, because its first run's view came out at 1922 x 1082), and toonRamp with the three looks built on it (Soft anime, Nineties CG, Pencil anime) measured twice again on 1.1.3 (11:59 to 12:08 UTC): their rows are 1.1.3's. Every run on the Lookbook's 26 second path, desktop GPU, styleKit 1.2.4, lookbookKit 1.0.14, the 3D view at exactly 1920 x 1080 (checked before every run), one discarded warm-up, no missed frames, both quality tiers, with exactly:

local Lookbook = require("~lookbookKit.Lookbook")
local r = Lookbook.measure({ stack = { { id = "light", block = "toonBands" } }, baseline = false })
print(r.stylized.all.warpedDiff, r.stylized.pan.warpedDiff, r.stylized.markStuck, r.stylized.zoomMarks.growth, r.passMs.high.total, r.passMs.low.total)

(a look's runs take its entries as StyleKit.look(id).entries). Every stack's two runs agree to 0.01 in the motion columns. The GPU columns did not repeat this time, and they are given as measured: the two runs of a stack differ by up to 1.26 ms on the high tier (Comic ink cel, 5.45 and 6.71) and 0.39 ms on the low (Pencil anime, 0.44 and 0.84), and blocks 1.1.2 did not change read higher than the same blocks did on this machine for 1.1.1 (toonBands 1.52 and 1.40 against 1.21, toonWrap 2.44 and 1.66 against 1.19). Read them as rough costs, not as a measurement that repeats. The four 1.1.3 stacks repeat to within 0.08 ms. The unstyled path reads 2.30 (warped difference, whole path), 6.57 (pan), 0.00 (marks), -0.53 (screen-stuck) and 7.88 (mark growth). How to read the columns is in paperBlocks' and lookbookKit's READMEs: warped difference is how much the picture swims once the camera's motion is taken out (lower is steadier), marks on things is the shower-door score (negative: the stack's marks stay on surfaces when the camera pans; positive: they stay on the screen), mark growth is how marks scale over a 10x zoom (about 1 keeps their size in the picture, about 10 grows with the things they sit on). The GPU columns are the style passes alone at the pan; the last column is how many outline shells were drawn.

StackRunWarped difference, whole pathWarped difference, panMarks on thingsScreen-stuck in the panMark growth over the 10x zoomGPU ms highGPU ms lowOutline shells
toonBands11.543.54+0.91-0.511.161.520.130
toonBands21.543.54+0.91-0.511.161.400.110
toonRamp11.643.92+0.90-0.511.111.210.140
toonRamp21.643.92+0.90-0.511.111.210.140
toonWrap12.286.20+0.36-0.521.002.440.290
toonWrap22.276.20+0.36-0.521.001.660.260
toonRim12.356.57+0.00-0.537.880.690.110
toonRim22.356.57+0.00-0.537.880.700.170
toonHighlight12.346.57+0.01-0.537.881.250.210
toonHighlight22.346.57+0.01-0.537.881.290.230
celFill11.382.55+0.83-0.532.272.480.520
celFill21.382.55+0.83-0.532.272.860.430
celHueShift11.382.58+0.83-0.532.213.230.490
celHueShift21.382.58+0.83-0.532.212.680.260
celPoster11.711.98+0.14-0.371.852.610.380
celPoster21.711.98+0.14-0.371.852.780.400
toonOutline12.436.57+0.00-0.537.880.350.107
toonOutline22.436.57+0.00-0.537.880.200.087
toonSticker12.456.57+0.00-0.537.880.210.0914
toonSticker22.456.57+0.00-0.537.880.280.0614
toonStickerBlack12.406.57+0.00-0.537.880.310.097
toonStickerBlack22.416.57+0.00-0.537.880.190.067
toonTintLine12.426.57+0.00-0.537.880.210.067
toonTintLine22.426.57+0.00-0.537.880.170.067
toonFarLine12.426.57+0.00-0.537.880.350.107
toonFarLine22.426.57+0.00-0.537.880.350.107
look saturdayMorning11.372.23+0.79-0.543.074.340.797
look saturdayMorning21.372.23+0.79-0.543.074.620.797
look comicInkCel11.241.89+0.82-0.504.875.451.147
look comicInkCel21.241.89+0.82-0.504.876.711.137
look softAnime11.342.36+0.84-0.522.514.420.517
look softAnime21.342.36+0.84-0.522.514.340.527
look clearLine11.352.27+0.78-0.543.082.370.307
look clearLine21.352.27+0.78-0.543.082.370.297
look thickSticker11.871.98+0.14-0.371.852.520.3814
look thickSticker21.871.98+0.14-0.371.853.320.6814
look ninetiesCG11.774.04+0.88-0.501.353.780.260
look ninetiesCG21.774.04+0.88-0.501.353.800.260
look pencilAnime11.412.36+0.84-0.522.503.910.450
look pencilAnime21.412.36+0.84-0.522.503.910.450

What they say:

  • The toon light does not swim. Bands, ramp, wrap, rim and highlight swim no more than the unstyled path (1.54 to 2.35 against 2.30): bands 1.54 (pan 3.54), ramp 1.64 (pan 3.92), wrap 2.27 and 2.28, highlight 2.34, rim 2.35. The cel and hue-shift fills calm it most (1.38), because flat colour has less texture to move, and the poster fill too (1.71, pan 1.98). The highlight's glints sit where shapes bend and add nothing over unstyled in the pan (6.57, the same as unstyled).
  • The shower-door score is positive for the full-frame bands, ramp and fills (+0.83 to +0.91), as it is for paperBlocks' papers at this view size; wrap reads +0.36, rim and highlight about zero (+0.00, +0.01), the poster fill +0.14. The toon light is drawn from the scene's own light and the sun's direction on each surface, so band edges sit on the surfaces by construction; screen-stuck stays at -0.51 to -0.53 for every light block (unstyled -0.53), -0.37 for the poster fill. Read it the way paperBlocks' README says: check sliding by eye with a slow pan.
  • Mark growth near 1 for bands, ramp and wrap (1.00 to 1.16) and 1.85 to 2.27 for the fills means the measure finds little fine detail left to compare once surfaces are laid flat, not that something is glued to the screen. Rim and highlight leave most of the picture as it was and read like unstyled (7.88).
  • Outlines are geometry, so the Lookbook's mark measures cannot see them: the shells are part of the frame the stack receives, which is what the measure compares the stack's output against, so marks and growth read exactly as unstyled (0.00, 7.88). A hull line hugs its object by construction and cannot slide. Since 1.1.2 the outline entry's own pass tidies the drawn line (see Outlines), which changes a few pixels along every line, so warped difference reads 2.40 to 2.45 against the unstyled 2.30, the same in the pan (6.57). That pass costs 0.17 to 0.35 ms high and 0.06 to 0.10 ms low (0.04 and 0.02 to 0.03 before it tidied anything); the shells are drawn in the scene's own geometry pass (one draw per opaque object, two for the sticker), 7 objects on the Lookbook stage, so their cost is the scene's draw cost for those meshes again, not in this column.
  • Cost at 1920 x 1080, as measured this time (see above: these did not repeat closely). Bands 1.40 and 1.52 ms on the high tier, ramp 1.21 in both runs (1.1.3), wrap 1.66 and 2.44, the highlight 1.25 and 1.29, the rim 0.69 and 0.70 (a dense 4 x 4 grid of depth taps); a fill 2.48 to 3.23 ms (it gathers the area's colour over two rings of 8 taps and reads the light and the normal over dense squares). On the low tier the same blocks cost 0.11 to 0.52 ms: the low tier runs at half resolution with 4 x 4 squares, 4 taps a ring and a 2 x 2 rim grid, and toonBands skips its light smoothing (0.11 and 0.13 ms low). Whole looks: 2.37 to 6.71 ms high, 0.26 to 1.14 ms low.
  • Whole looks swim less than the unstyled path (1.24 to 1.87 against 2.30): Comic ink cel 1.24, Soft anime 1.34, Clear line 1.35, Saturday morning 1.37, Pencil anime 1.41, Nineties CG 1.77 (pan 4.04: it has no fill to flatten its surfaces) and Thick sticker 1.87 (calm pan 1.98: the poster fill).
  • Black stays black. At the Lookbook's every-light-off moment the frame stays at the unstyled frame's black under every block and look, within an allowance of 1.5 on 0..255: the outline ink is seen only where light reaches it. The test suite checks every block and look.
  • Web frame rate has not been measured from here (#20946): run zero lookbook report in the web build.

The runs are in design/lookbook/toon_runs.json in the Style Cookbook world.

Version history

1.4.2 (2026-11-12): pins lookbookKit 1.0.52, starterBlocks 1.0.49, styleKit 1.7.8 (styleKit 1.7.8 logs no second refusal for the old roles field on a scene saved before styleKit 1.5). Nothing else changed.

1.4.1 (2026-11-12): pins lookbookKit 1.0.51, starterBlocks 1.0.48, styleKit 1.7.7 (styleKit 1.7.7: a role set or look another player changes reaches everyone in the session). Nothing else changed.

1.4.0 (2026-11-12): outlines close where things touch, hand-set inks read clearly, and the log stays quiet. Thick outlines on round things showed a gap where a ball met the ground or the box it rested on: the edge pass marks only depth steps, and where a thing rests on another the depth flows on with no step, and the line was drawn only over what stands a step behind. A new line setting, closeContacts, closes them: the edge pass then also marks a contact (a pixel lying deeper than the pixels two above and below it, with level surface to its left and right), and the line composite draws round a contact on the side below it, so the outline closes under every ball and under a ball on a box, without flecking a box's vertical edges. It is on by default for the thick lines, where the gap shows (the white and black sticker borders and the poster contour), and off for the thinner ones: on a character's creases it adds a few specks (the outline-alone fleck check read 0.13 percent of the figure with it on, against its 0.1 percent limit), and a thin line shows no gap to close. Set closeContacts = 1 on any line block to turn it on. An ink set by hand on an object (its style channel's ink) is drawn as set: under the toon game role set a pickup's line is mostly the object's own colour (its value, 0.8), and a hand-set ink came out pale; it now takes none of the object's colour. Objects that went (a bench or test clearing up) no longer make the ink log an error about a missing entity every frame: ids the role reach or an exclusion still names after their object went are skipped. The Paper cutout game look moved to paperBlocks 1.2.0, rebuilt from non-toon blocks, so toonBlocks no longer brings paperBlocks. New test: a hand-set ink on a pickup reads clearly under the toon set. Pins styleKit 1.7.6, starterBlocks 1.0.47 and lookbookKit 1.0.50.

1.3.13 (2026-11-12): pins lookbookKit 1.0.49, paperBlocks 1.1.32, starterBlocks 1.0.46, styleKit 1.7.5 (styleKit 1.7.5: its checks pass where styleKit is installed alone). Nothing else changed.

1.3.12 (2026-11-12): pins lookbookKit 1.0.48, paperBlocks 1.1.31, starterBlocks 1.0.45, styleKit 1.7.4 (styleKit 1.7.4: installs on its own into an empty world again). Nothing else changed.

1.3.11 (2026-11-12): pins lookbookKit 1.0.47, paperBlocks 1.1.30, starterBlocks 1.0.44, styleKit 1.7.3 (styleKit 1.7.3: a role reaches what a kit draws in an object's place (pickupsKit's coins), and looks installed after the first scan are found). Nothing else changed.

1.3.10 (2026-11-12): ships the Paper cutout game look (paperCutoutGame: matte card surfaces, two flat light bands, flat colour, a white die-cut sticker border round every object, on kraft paper), which lived only in the Style Cookbook world's own folders. styleRoles' read-apart test measures it as its paper look, and in a world that installed the packages alone applyLook("paperCutoutGame") found nothing, so that step measured the look before it. It needs paperBlocks' kraft paper, so toonBlocks now brings paperBlocks 1.1.29 (paperBlocks needs only styleKit). Nothing else changed.

1.3.9 (2026-11-12): things nobody gave a role keep the look's own line. Under Comic ink cel with the arena shooter set, untagged lamp posts were drawn in the hazard line's orange (and in enemy red once the hazard line was removed): the toon ink reads the stack's entries from StyleKit.describe(), which reported no entry's variant, so every variant line a role set adds was drawn on everything and the last one won. Fixed in styleKit 1.7.0, which this pins; styleRoles' suite checks it on the frame. Known limits no longer cite #20750, which is closed. Pins styleKit 1.7.0, starterBlocks 1.0.43 and lookbookKit 1.0.46.

1.3.8 (2026-11-11): pins lookbookKit 1.0.45 (lookbookKit 1.0.45 brings its Lookbook scene with it when it is installed as another package's dependency, so the toonBlocks, inkBlocks and paperBlocks unlit-frame tests and zero lookbook run in an installed world). Nothing else changed.

1.3.7 (2026-11-11): pins lookbookKit 1.0.44, starterBlocks 1.0.42, styleKit 1.6.5 (styleKit 1.6.5 draws a newly switched-on look's settled picture from its first frames instead of a lighter, half-set one for two to four seconds; lookbookKit 1.0.44 finds its Lookbook scene where it is installed). Nothing else changed.

1.3.6 (2026-11-11): per-object ink lines that share a style (role inks and widths, tint aside) are drawn together: each line draws only its mask, then one region map (toonInkMerge), one jump flood that skips a pixel's own region (toonInkSeedId, toonInkFloodId) and one composite with a twelve-entry palette (toonInkLineId) draw them all, and the region map stands in for the shared line's veto when every vetoed thing is one of them. 600 role holders in nine inks queue 22 ink passes a frame instead of 104, and the toon ink's script time with them falls from about 0.6 to about 0.26 ms on the median frame. Touching objects of different lines still get a line between them; lines of different styles keep a chain each. 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.3.5: the toon ink line starts by itself. A new toonBlocksStartup asset type and the one asset of it the package ships (ink.toonBlocksStartup) load ToonBlocks on every machine when a world with the package loads, the way toonMaterials starts its own ink. It starts the ink at every registration, so an engine that switches from one world to another starts it again in the new one. Before, the ink runtime only started when some other code loaded ToonBlocks, so in a world that had installed toonBlocks and nothing else the toon look came up with its bands and fills and no line at all, and no role lines either. Found by installing the look into a new world as a stranger would. Pins lookbookKit 1.0.43, starterBlocks 1.0.41, styleKit 1.6.3.

1.3.4 (2026-11-11): the ink line of things with a style channel or a role reads each thing's own colour on the GPU at its silhouette, the way the shared line already did, instead of mixing it in on the CPU. A line used to be split into one group per material colour in the level, so 600 role holders in many colours made 49 lines and 212 render passes a frame; they now make one line per role ink (9 lines, 104 passes). Toon ink script time with 600 roles in the 2,500-thing bench fell from about 1.0 ms a frame to about 0.6 ms (median). Lines look the same: the role's ink, mixed with the thing's colour by the style's tint.

1.3.3 (2026-11-11): pins lookbookKit 1.0.42, starterBlocks 1.0.40, styleKit 1.6.2 (styleKit 1.6.2 finds the scene's stack again when the one it held was removed (after a play restart a look or role set change failed with "the component this proxy names was removed")). Nothing else changed.

1.3.2 (2026-11-11): a style channel test on styleKit's ChannelProbe (line weight and marks reach the toon blocks on the presented frame); pins lookbookKit 1.0.41, starterBlocks 1.0.39, styleKit 1.6.1.

1.3.1 (2026-11-11): pins lookbookKit 1.0.40, starterBlocks 1.0.38, styleKit 1.5.1 (styleKit 1.5.1 keeps the scene's role set working in an editor that had an older styleKit open). Nothing else changed.

1.3.0 (2026-11-11): the per-object outline is now part of styleKit's style channel. The ink reads each object's StyleChannel (or its game role through the scene's role set): its line weight scales the entry's width, how much of the line reaches it scales the ink's opacity, its ink colour colours the line and its value tints it with the object's own colour; a toon Line entry with a variant draws only on objects of it and the entry with none leaves them to it. ToonBlocks.setObjectOutline writes weight, colour, tint and draw onto the channel and keeps an exact width, units and ink style on ToonOutline, which the runtime lays over the channel, so older scenes draw as before. Pins styleKit 1.5.0, starterBlocks 1.0.37, lookbookKit 1.0.39.

1.2.1 (2026-11-11): every block and look has a picture (preview.png, 640 x 360): the same station (a skinned character, a hard-edged house, a crate, a ball) under the Comic ink cel look with that block in its slot, or under the whole look, so a style can be chosen by looking at it. A per-object ink style that was taken off (ToonBlocks.clearObjectOutline, or a ToonOutline removed) while the stack briefly had no toon line no longer leaves its old ink group behind: such groups used to keep drawing objects in an ink they no longer wore. The Ink Showcase holds still in the editor and moves only in play (it used to move every editor frame, and the editor saved each move as an edit). the look costs what the guide says, measured on the median frame. Measured with 2,500 things (250 moving, 25 a second spawned and despawned, 10 recoloured): on one shared line (Comic ink cel) the whole look takes 0.29 ms on the median frame, the outline 0.06 ms of it (average 0.41, outline 0.09), standing still 0.33 ms; in the Ink Showcase with eight ink styles side by side 0.78 ms (outline 0.47; was 0.92 and 0.57 on 1.2.0), standing still 0.72 ms (was 0.89). Taken off the every-frame path: the shader-reload counters (every 30 frames), the per-object override read when things come and go (only when they arrive under an override, at most once a second; it cost about 2 ms up to four times a second, and up to 11 ms in one frame), and the camera guard of character hulls (every frame only within 6 m of the camera). OutlineBench.measure reports the median frame (p50, toonP50, styleP50), and the busy-level test is judged on it, so a machine busy with other work no longer fails it. The engine limits in Known limits are numbered and each names its tracked issue (#24449, #24450 and ZeroMind reports). Pins styleKit 1.4.24, starterBlocks 1.0.36, lookbookKit 1.0.38.

1.2.0 (2026-11-10): the toon ink line on the engine's own outline effect, eight new ink styles, and no per-object work. The line is now drawn by the engine's jump-flood outline (seed and flood) with toonBlocks' own composite on top: one shared line grown from the depth edges of the frame for everything plain, depth correct (a wall or floor in front hides it, a cart passing behind a low wall keeps its line above the wall and none on its face), antialiased at full resolution, with width from the silhouette's own distance, brush weight by direction, a soft edge, opacity, a colour read on the GPU from the object at its edge, and black ink when nothing gives light. Plain objects are no longer tracked at all: a thing added after the look is on is inked the frame it appears, a removed one loses it the frame it goes, and a new material, a hidden mesh or a swapped mesh changes the line the same frame. Skinned characters keep their hull (inner lines). Eight new line blocks, all on the same settings: toonPenLine, toonComicLine, toonBrushLine, toonColourLine, toonPencilLine, toonChalkLine, toonCharacterLine, toonPosterLine; new shared settings targets, brush, brushAngle, softness, opacity (defaults keep every existing block's look). Per-object ink styles: ToonBlocks.setObjectOutline(obj, { style = "toonChalkLine" }) and a synced style field on ToonOutline. The runtime is ToonInkRuntime; ToonOutlines is kept as its old name and gives the same module. Measured on a 2,561-object busy bench (250 moving, 25 a second spawned and despawned, 10 recoloured), script time of the toon look a frame: 1.43 ms on 1.1.29 (outline 1.07, style stack 0.36), 0.73 ms on 1.2.0 (outline 0.21, style stack 0.52). The suite now checks the line on screen (arrival, glass, hidden, removal, a material change updating a coloured line, a thing behind a wall having no line) instead of counting shells. New guide: how to keep a toon look fast in a big game. Pins styleKit 1.4.23, starterBlocks 1.0.35, lookbookKit 1.0.37.

1.1.29 (2026-11-09): the outline costs nothing it does not need. Summit Sprint, a public platformer on toonBlocks, stalled for 250 to 490 ms every few seconds: the outline runtime walked every object in the scene once a second (entity.findAll plus a component read on each, with the shells counted in) and then walked every target again. That is gone. The runtime reads the engine's entity and field revisions each frame and works only when one moves: arrivals are found in the engine's index of Model and SkinnedModel components (gated to once every 30 frames and a quarter of a second, and to about one percent of the time while things keep arriving), objects that leave take their shells with them, a new material, visibility or mesh on a standing object is read from the engine's own render components (MaterialRef, MeshInstance) in chunks inside a 0.15 ms budget, and every shell is worked out and made inside a per-frame budget (0.4 ms of a 60 fps frame, 2.5 percent of a slower one, at most 1.5 ms). A plain shell is now a bare child holding the engine's mesh and material components (0.06 ms to make instead of 0.8 ms with a Model component); skinned shells are as before. Measured with the new OutlineBench (3,000 objects under Comic ink cel, 300 moving every frame, 30 a second spawned and despawned, 10 a second recoloured): 1.1.28 averaged 19.4 ms of look-stack script a frame with frames up to 329 ms; 1.1.29 averaged 0.80 ms (toonBlocks 0.49, styleKit 0.31) with a worst frame of 5.5 ms and none over 33 ms. The suite gains two checks: objects that arrive, change material, are hidden and leave get and lose their outline, and the busy bench stays within the bar (as a share of the frame, so a slow host is held to the same 1 ms of a 60 fps frame). New: ToonOutlines.shellsOf(entity), ToonOutlines.costTotal(), status().queued and status().prof. Also carries pull request #9 (ToonOutlines requires styleKit by name, ~styleKit.StyleKit, so it works wherever an install puts styleKit). The toon light follows the sun the renderer shades with (styleKit 1.4.22), which ends the two-suns limit. Pins styleKit 1.4.22, starterBlocks 1.0.34, lookbookKit 1.0.36. The look is unchanged: the engine's own outline gained its depth test and antialiasing during this round (#19385, #17484), and drawing the toon ink through it is the next step (see Known limits).

1.1.28 (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). Pins styleKit 1.4.21, starterBlocks 1.0.33, lookbookKit 1.0.35. The package description now says what it gives you and how to install and use it. Nothing else changed.

1.1.27 (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). Pins styleKit 1.4.20, starterBlocks 1.0.32 and lookbookKit 1.0.34. Also includes 1.1.26 (pull request #8), released from main with this version.

1.1.26 (2026-11-08): A character's outline shell now follows the character's render layers whenever they change, not only when the shell is made. A first-person body hidden from its own camera after its shell existed (through death, the respawn and re-equipping) kept a visible shell, and a dead player's fallen body, lying outside the camera guard's column, filled the view with dark shapes. Seen in Frag Arena.

1.1.25 (2026-11-08): pins toonMaterials 1.0.11 (was 1.0.4), which is built on materialLibraryKit 1.4.3 and the current engine library, so an install no longer carries an older material library or copies of engine shader modules. Nothing else changed.

1.1.24 (2026-11-08): Outlines never cover a first-person camera: a character's outline shell takes the character's render layers (a camera that hides its own body hides its outline too), and a shell whose character holds the camera is switched off until the camera is 1.6 m clear, so the inside of the shell no longer shows as a big dark shape across the screen. Rescans re-walk the targets only when the set changed, and each object's outline settings are cached (cleared when the style stack changes), which removes 50 to 180 ms stalls in scenes with a few hundred outlined objects.

1.1.23 (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). Pins styleKit 1.4.19, starterBlocks 1.0.31 and lookbookKit 1.0.33. Nothing else changed.

1.1.22 (2026-11-08): 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). Pins styleKit 1.4.18, starterBlocks 1.0.30 and lookbookKit 1.0.32. Nothing else changed.

1.1.21 (2026-11-08): pins styleKit 1.4.15, starterBlocks 1.0.29 and lookbookKit 1.0.31. Nothing else changed.

1.1.20 (2026-11-08): pins styleKit 1.4.14 (a look drawn again after a clear lands in the right place), starterBlocks 1.0.28 and lookbookKit 1.0.30. Nothing else changed.

1.1.19 (2026-11-08): pins styleKit 1.4.13, starterBlocks 1.0.27 and lookbookKit 1.0.29. Nothing else changed.

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

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

1.1.16 (2026-11-08): moves to the engine's current built-in library (@builtin c61f473), whose update rewrote small reference files inside the package. Pins styleKit 1.4.10, starterBlocks 1.0.24, lookbookKit 1.0.26. Nothing else changed.

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

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

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

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

1.1.11 (2026-11-07): pins lookbookKit 1.0.21, whose marks score reads the stack's marks again (see its history). No block, look or shader changed.

1.1.10 (2026-11-07): moves to the engine's current built-in library (@builtin 278f02f), whose update rewrote small reference files inside the package. No block, look or shader changed. Pins lookbookKit 1.0.20, starterBlocks 1.0.19, styleKit 1.4.4.

1.1.9 (2026-11-07): moves to the engine's current built-in library (@builtin 6656162), whose update rewrote small reference files inside the package. No block, look or shader changed. Pins lookbookKit 1.0.19, starterBlocks 1.0.18, styleKit 1.4.3.

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

1.1.7 (2026-11-07): moves its pins to styleKit 1.4.1, starterBlocks 1.0.16 and lookbookKit 1.0.17; no block changed.

1.1.6 (2026-11-07): moves its styleKit pin to 1.4.0; no block changed.

1.1.5 (2026-11-03): depends on styleKit 1.3.0, starterBlocks 1.0.14 and lookbookKit 1.0.15; no change to the blocks.

1.1.4 (2026-11-03): documentation only. The README opens with three steps to install and use the package (search "toonBlocks" on ZeroMind and install it, StyleKit.applyLook, StyleKit.swap), checked as written in the Style Cookbook (the look applied with 5 entries, the light swapped to toonRamp, the stack empty after clear()). No block, shader, look or test changed from 1.1.3, and its numbers below stand for this release.

1.1.3 (2026-11-03): toonRamp no longer lights stray dots in a figure's flat shade, at the cost it had before; the close-up figure check runs at a fixed view size and judges only what repeats.

  • What was wrong. 1.1.2's own check from ZeroMind, in a brand new world, failed the close-up figure check: toonRamp left 3 lone specks on the figure, single pixels of 158 to 177 in shade that was 102 all round, so the suite passed 11 of 12 there (12 of 12 in the Style Cookbook). Probed pixel by pixel on the suite's figure: there the unstyled frame and toonBands are one flat tone, and the specks go away with rampMid set to the shadow colour or with shape 0, so the ramp's clean sun light was lifting single pixels to its mid stop. Two things together did it. The step from the shadow stop to the next lay only about 0.08 of the way from shade to full sun (toonBands' first band edge lies at 0.38), inside the faint sun a surface facing the sun keeps inside a cast shadow. And the light read there is uneven from pixel to pixel: the pixel's own share of the light, which decides how much sun gets into a cast shadow, and hairline seams one pixel wide where two parts of the figure meet, along which the averaged normal turns toward the sun.
  • The fix, in three parts, each tried alone first (on the suite's close figure: the step moved alone left 1 lone speck, either filter alone 3, the two filters together 4, all three 0). The shade holds the shadow stop up to where its step lands on toonBands' first band edge at its defaults, worked out from the ramp's own shadowAt, midAt and shadeLevel, and the stops above spread over the rest. While shape redraws the light, the ramp reads it fully smoothed (smoothLight now matters to it only with shape 0). And on the high tier, near that step, each pixel takes the lower of the middle of its row of three and the middle of its column of three, which drops a one pixel hairline or a lone pixel and leaves every edge where it is. The low tier is as before.
  • What did not ship. A first 1.1.3 that held only the first quarter of the span as shade was prepared and never published. The Style Cookbook's NOTES.md recorded counts for it (140 specks, 1 lone, 14 where toonBands is flat) that were taken while the look stack was shading by a second sun (below); they do not stand.
  • The close-up check, run twice in the Style Cookbook on the released code, both runs giving the same numbers: toonRamp 0.04 percent of the figure, 0 lone; toonBands with keepShade 0 0.10 percent, 3 lone; the outline alone 0.06; Comic ink cel 0.19, 2 lone (0.14 away from its line).
  • From the editor camera (as in 1.1.2, with the world clock's sun switched off for the shots, below), two sets at 1920 x 1080 and two at the editor's own 2097 x 1409 view, with toonBands and keepShade 0 in the same shots. At 1920 x 1080: toonRamp 112 specks (2 lone) and 130 (0), toonBands 215 (14) and 209 (6). At 2097 x 1409: toonRamp 196 (1 lone) and 178 (2), toonBands 338 (2) and 320 (1). Where toonBands is one flat tone, toonRamp has 12, 24, 26 and 45 specks; it draws four colour steps where three bands draw two edges. The published 1.1.2, counted the same way in the same session: 187 (1 lone) and 205 (2) at 1920 x 1080, 142 (2) and 131 (5) at 2097 x 1409. The two sets of each size do not repeat exactly: the figure's own pixel count changed between them (56,245 and 56,495 at 1920 x 1080), so it does not stand exactly still, and a few lone specks move from shot to shot. Over the four shots toonRamp had 5 lone specks against toonBands' 23; in one of them it had one more than toonBands (2 against 1).
  • Why the clock's sun was off. styleKit gives every block the first directional light the lighting toolbox lists, by entity id. The showcase stage has two, its own sun and the world clock's, which lights nothing there; each time the clock's sun is made again it takes a new id, and when that id sorts first the toon blocks shade by its direction. So the same code counts very differently from one session to the next (1.1.2's ramp from this camera: 72 specks with 0 lone in one session, 187 and 205 with 1 and 2 in another), which is the likely reason counts taken at another time differ from these. This is styleKit's, not toonBlocks', and is left as it is (see Known limits).
  • The close-up check counts at a fixed size and judges only what repeats. It sets the 3D view to 1920 x 1080 while it runs (its counts are pixel shares and the line is drawn in 1080p pixels: at a 3200 x 1756 view the outline alone read 0.11 percent and failed) and gives the view back afterwards. It no longer judges Comic ink cel's specks away from its line against toonBands' own plus 0.1 percent: toonBands' count there moved between 0.02 and 0.10 percent from run to run while Comic ink cel's stayed at 0.14 to 0.15 (its rim and glint edges), so that margin failed by chance once on this code. It judges the outline alone and lone specks: toonRamp may have at most 1, Comic ink cel no more than toonBands with keepShade 0 has or 2, whichever is more. (Comparing with toonBands' count exactly, as 1.1.2 did, failed by chance: toonBands' own lone count moved between 0 and 3 from run to run, and one full run on this code failed on Comic ink cel's 1 against its 0. 1.1.2's toonRamp had 3 or 4 there, 1.1.1's Comic ink cel 18 to 23.) It still fails on the 1.1.1 code (the outline alone 0.19 percent, Comic ink cel 23 lone specks, toonRamp 4, at 1920 x 1080).
  • Lookbook. toonRamp and the three looks built on it measured twice again: toonRamp swims less (1.64 against 1.97, pan 3.92 against 4.99) and costs 1.21 ms on the high tier in both runs (1.1.2: 1.20 and 1.49), 0.14 ms on the low; Soft anime 4.34 and 4.42 ms, Pencil anime 3.91, Nineties CG 3.78 and 3.80 (1.1.2: 2.03).
  • Test suite, in the Style Cookbook on this code: one full run passed 11 of 12, the close-up check failing on that chance comparison (Comic ink cel 1 lone speck, toonBands 0; toonRamp 0); the close-up check then passed with the limits above. The check from ZeroMind in a brand new world is recorded in NOTES.md (see the install note).

1.1.2 (2026-11-03): Comic ink cel draws a figure seen close without ink dots; the outline is tidied where a figure overlaps itself; toonRamp reads its light the way toonBands does; every Lookbook row is measured again.

  • How it was counted. From an editor camera 3 m off the showcase figure (at (0.9, 1.6, 3.8) looking at (0.55, 0.95, 0.9), 60 degrees, 1920 x 1080, the stage's sun at 16:30), on the presented frame. A speck is a pixel 6 of whose 8 neighbours differ from it by more than 6 of 255, all one way, counted on the figure only (the pixels that change when the figure is taken away, two in from its outline) and not where the unstyled frame already has one. A lone speck is one in flat paint: its ring of pixels two out lies within 4 code values of its middle all round. Each count below was taken twice, in two separate sets of shots, and both sets gave the same numbers.
  • What was wrong. 1.1.1 at its defaults put 440 specks on the figure under Comic ink cel, 11 of them lone, against 244 (7 lone) for toonBands with keepShade 0; the outline alone put 221 there, 13 lone. Most sat on the outline's inner lines: where one part of a figure lies over another (the waist plate over the hips, the panel on a shin) the body hides most of the hull's shell, and the line came out one pixel thin, in dashes, with single ink dots between. A one pixel dark line is a speck all along it.
  • The outline is tidied. The outline entry's own pass, which did nothing before, now tidies the drawn line (see Outlines). The five line blocks read the base colour copy, so the pass sees the ink tag even with nothing else in the stack.
  • toonRamp reads its light as toonBands does. It fed its stops the shaped light, which keeps 1 - shape (a tenth by default) of the light as rendered; that tenth carries pixel-level noise at silhouettes and seams, and where a figure's shade sat near the step between two stops, lone pixels of it tipped into the next stop. It now reads the light across the span from shade to full sun, as toonBands cuts its bands, laid from shadeLevel up to full. That was meant to make shade read one ramp colour; it did not on every figure (1.1.3 above).
  • At the defaults now, same camera, two sets: toonBands 244 specks (7 lone); Comic ink cel 213 (0 lone); toonRamp 140 (3 lone; 1.1.1 162, 3 lone); the outline alone 76 (1 lone). Comic ink cel's 213 are fewer than toonBands' 244 but not the same kind: 91 lie away from its line and 122 on the line's own edge (34 of those are ink pixels), where toonBands draws no line.
  • keepShade 0.7 is not clean on a figure. Same camera: 257 specks against 244 at 0, 38 of them where 0 is one flat tone. The block's README, its setting doc and the 1.1.0 entry below said otherwise and are corrected.
  • Not clean yet. On the test suite's own figure seen close, toonRamp still flecks the sunlit silhouette more than toonBands (0.20 against 0.01 percent of the figure on one run); pure steps, wider or narrower stop edges and a high stop the colour of the light stop did not change it. From the editor camera above it does not show. The suite reports that count and does not judge it.
  • The test suite gains a twelfth check, the figure seen close (half the frame tall): the outline alone adds no more than 0.1 percent of the figure in specks, Comic ink cel and toonRamp have no more lone specks than toonBands with keepShade 0, and Comic ink cel's specks away from its line are no more than toonBands' own. 1.1.1 failed it (the outline alone 0.17 percent, Comic ink cel 18 lone specks, toonRamp 4). In the Style Cookbook 1.1.2 passed it, and the whole suite 12 of 12; in a brand new world installed from ZeroMind it failed it (toonRamp 3 lone specks), so the suite passed 11 of 12 there. 1.1.3 above says why.
  • Every Lookbook row is measured again on 1.1.2. The motion columns repeat; the GPU columns did not repeat this time and are given as measured (see Lookbook numbers). The outline entry's pass now costs 0.17 to 0.35 ms high.

1.1.1 (2026-11-03): the figure check works in a world that just installed toonBlocks.

  • 1.1.0's figure check could not find the figure in a brand new world: under its bright default light the white figure hardly differs from the pale floor and sky behind it, so only 602 of its pixels could be judged and the check stopped short (10 of 11 passed there). The figure now stands before a red backdrop that casts no shadow, and the check judges about 2,490 of its pixels in a fresh world and in the Style Cookbook alike. It still fails on 1.0.9 (up to 115 flecks inside a band on the figure) and passes now. Nothing else changes.

1.1.0 (2026-11-03): keepShade is off by default, so toonBands at its defaults draws the showcase figure as cleanly as with keepShade 0. (This entry first said toonRamp and Comic ink cel were as clean too; they were not, and 1.1.2 above says what was wrong and what changed.)

  • 1.0.9 turned the keepShade lift on by default (0.7) and cut it into whole thirds of the way to the next band. On the figure standing on the showcase stage its shade sat right by the two-thirds step, and the light the lift is read from (the frame divided by the base colour) carries pixel-level noise: texture, silhouettes, and the copies the blocks read being coarser than the frame there. So the lift tipped between one and two thirds from pixel to pixel: a comb of alternating light and dark columns along the legs and dark smudges inside the shadow band. Counted on that figure (1920 x 1080, flecks as in the test suite, the figure only), 1.0.9 at its defaults flecked 2.60 percent of it, 29 flecks where the same view with keepShade 0 is one flat tone; keepShade 0, toonRamp and starterBlocks' lightBands 0.81, 0.81 and 0.60 percent, none of them inside a band.
  • The lift now follows the scene's light smoothly instead of in thirds (nothing below a third of the way, all two thirds from two thirds on), read from a steady 8 x 8 mean that near a seam between two parts is drawn toward the mean of every surface tap, so a sliver of one part between two others is lifted like its surroundings. On the one view it was counted on (the showcase figure about a fifth of the frame tall), keepShade 0.7 then flecked 0.81 percent like 0; that does not hold closer to the figure (1.1.2 above), so the lift is not clean on a figure. Where a scene asks for only part of the lift it still carries a little of the light's noise: on the test suite's figure, under a fill light that leaves its shade asking for about half the lift, 0.7 flecked 1.58 percent with 38 flecks inside a band. That could not be made clean, so keepShade is now 0 by default: the band is exactly as cut, and the lift stays one setting away for scenes that want it (a strong sky turning shaded brick walls dark brown, the case it was made for). The Toon recipe's walls read darker by default again; set keepShade 0.7 on its light entry to bring them back.
  • At the defaults, on that one view: toonBands 0.81 percent flecked, toonRamp 0.81, none inside a band. That match did not hold closer to the figure, where toonRamp and Comic ink cel flecked more (1.1.2 above). Comic ink cel is the look with the lift off: 3.02 percent, none inside a band, nearly all of it along its ink lines and on the edges of its rim and glints, which stand out more against the darker shade (0.96 percent once pixels touching ink are left out); 1.0.9 read 1.84 there (0.23 away from ink), with the lifted shade softening those edges, at the price of the comb on the plain bands.
  • The test suite gains an eleventh check that fails on 1.0.9: the engine's humanoid figure, seen as on the showcase stage with the sun behind it, under toonBands, toonRamp and Comic ink cel at their defaults, with a fill light swept from off to strong so the shade passes through the whole range where a lift would change; no fleck inside a band, and no more flecks than with keepShade 0. On 1.0.9 it failed with up to 98 flecks inside a band (4.29 percent of the figure flecked) and Comic ink cel above its own keepShade 0 count. The ball's stipple check now covers keepShade 0.7 in place of 0.
  • The Lookbook rows of toonBands, Saturday morning and Comic ink cel are measured again.

1.0.9 (2026-11-03): the test suite passes in a world that just installed toonBlocks, and leaves its install as it came.

  • In a fresh world (the default sun, a faint ambient), toonBands showed 5 bands on the side-lit test ball as 4 flat tones and a gradient. The shade itself was flat; the keepShade floor copied 70 percent of the scene's brightness pixel by pixel, and past a soft terminator the scene's light climbs smoothly, so over the darker lit bands the floor drew that climb instead of the band. The floor now holds only inside the shadow band and lifts it in whole thirds of the way to the next band (at most two thirds, never past it), with edges as crisp as the band edges, read from the base colour under the smoothed light so texture does not print through. On the suite's ball in a fresh world, 1.0.8 against 1.0.9: tones at 2, 3, 4 and 5 bands 2, 3, 3, 4 against 3, 3, 4, 5; 2 against 5 bands changes 14.2 against 81.0 percent of the frame and 36.5 against 87.2 percent of the ball. The stipple check reads 0.27 percent at most (the limit is 1).
  • The every-light-off check loads the Lookbook scene, and the scene's autosave recorded the stack it drew and the runner's pose as edits of the scene; in a world that installed toonBlocks that scene is installed content, so the engine called the install changed. The check now discards what its run leaves in the Lookbook scene's autosave once the previous scene is back (the whole overlay when there was none before, else only the new edits).
  • The file list says the blocks folder holds 7 shaders (it said 8).
  • The Lookbook rows of toonBands, Saturday morning and Comic ink cel are measured again.

1.0.8 (2026-11-03): documentation only. The install note above states the fresh-world check of 1.0.7's code; 1.0.7 was published still carrying 1.0.6's note (1,472 files, before the dependencies were listed). No block, shader, look or test changed from 1.0.7.

1.0.7 (2026-11-03): four faults found by trying the package out from a fresh install.

  • toonBands at its defaults speckled the campaign stage's figure more than starterBlocks' lightBands, along the figure's panel seams and where one band met the next; Comic ink cel added flecks along its ink lines. Three causes. The averaged normal kept each part's own normal right up to the depth buffer's stepped edge between two parts, so a band edge there copied the stair-steps; near such an edge the normal is now drawn toward the mean of the whole 8 x 8 square, so the change takes a few pixels. The keepShade floor copied each pixel's own rendered brightness and clamped a lifted colour per channel against a cap read from that pixel, so lone pixels stood out lighter or darker than the flat band around them; the pixel's light is now held within 0 to 1.25 times the smoothed light around it, and an over-bright channel eases toward grey at the same brightness. toonRim took the largest of 8 scattered depth taps, so its inner edge copied the silhouette's stair-steps beside every outline; it now reads the share of a dense 4 x 4 grid of depth that lies farther away (2 x 2 low). Flecks on the figure (a pixel that 6 of its 8 neighbours differ from by more than 6 of 255, all one way, counted on the figure only, where the unstyled frame has none) in two takes of one 1920 x 1080 view: toonBands 51 and 30, lightBands 64 and 60, toonRamp 30 and 25; Comic ink cel 58 and 57, the outline alone 71 and 71. The sun of the stage's sky clock moves between takes, so only counts within one take compare.
  • A fresh install brought styleKit whole but lookbookKit only as the files toonBlocks' own code names (its modules, not its Lookbook scene) and starterBlocks hardly at all, so the test suite's every-light-off check could not load the Lookbook and 9 of 10 passed. package.yaml now lists starterBlocks, lookbookKit and toonMaterials, and an install brings each whole.
  • ToonBlocks.setObjectOutline("showcaseCharacter", ...), as the guides and the toonWorld workflow write it, stopped with an error: the name was handed to entity.exists, which takes ids and refuses the name of a live entity. setObjectOutline, ToonMaterial.paint and ToonMaterial.unpaint now take the object as an entity, its id or its name; the suite checks it by name.
  • In play, the hull outline drew dark slabs across the floor and in front of a second character. 1.0.5 set each shell corner's depth a little behind the body by dividing by the pushed corner's w, clamped at 0.000001; a corner behind the camera (a floor or lawn the player stands on) has a negative w, so it was thrown to a huge depth and its triangles stretched across the view. The push now applies only to corners in front of the camera. Edit-mode views never put a corner behind the camera, which is why it showed only in play.
  • The Lookbook rows of the light blocks, the fills and the looks are measured again.

1.0.6 (2026-11-03): documentation only. The install note above states the fresh-world check of this release's code; 1.0.5 was published still carrying 1.0.4's note, which also said a swap returns the entry (it returns true, or false and the reason). No block, shader, look or test changed from 1.0.5.

1.0.5 (2026-11-02): clean, flat bands on smooth objects, and a band count that plainly changes the picture.

  • Smooth round objects (the Lookbook campaign stage's character, round props) came out covered in a fine stipple under toonBands, toonRamp and the looks built on them, with keepShade at 0 too. The clean sun light (shape) took its normal from world positions one pixel apart, and styleKit keeps those in half floats whose rounding on that stage is about a pixel's width, so the normal was mostly rounding noise and every cut of the light (a band edge, a ramp step, a fill's lit and shadow tones) fell differently pixel by pixel. The light is now drawn from each surface's own shading normal, averaged over a dense 8 x 8 pixel square; the light smoothing and the poster fill's levels read dense squares too. A dense average changes smoothly across the screen, so what is cut from it has clean edges, on a low-polygon figure as on a sphere (a few scattered taps would not do: each crosses a facet edge at a different pixel and their mean steps pixel by pixel).
  • Three more causes of flecks in Comic ink cel, found taking the look apart one block at a time: the gathers took in the outline's ink (styleKit marks it as drawn ink), whose backward-facing normal and dark colour put light streaks and grain beside every line; the hull shell sat at the body's own depth, so where its back met the jointed figure's front plates the depth test chose ink or body pixel by pixel; and celPoster cut its levels from single pixels, so a near-white surface flipped between two levels. Gathers now take only fully known surface, shells stand one and a half line widths behind the body (outlines against anything behind the object are untouched), and poster levels come from a dense 4 x 4 brightness (8 x 8 merged brick and mortar into blobs).
  • On one 1920 x 1080 frame of the campaign stage, the share of the character flecked (a pixel that 6 of its 8 neighbours differ from by more than 6 of 255, all one way, which a band edge never is): Comic ink cel 11.9 percent in 1.0.4, now 1.2 and 1.2 in two takes; toonBands 3.1, now 2.7 and 2.6; starterBlocks' lightBands on the same two takes 2.5 and 2.6 (2.3 on the 1.0.4 frame).
  • The band count barely changed the picture: 2 against 5 bands changed 5.3 percent of the campaign stage view by more than 8 of 255. The clean light had two values, shade and full sun, so there was almost nothing for bands to cut, and at 4 and 5 bands the shade sat on or above the first band edge. The clean light now climbs from shadeLevel to full as a surface turns toward the sun (N.L to a power chosen from the sun's height, so open ground in sun sits three quarters of the way up and stays lit under a low sun), and toonBands cuts its bands across that climb: shade is always the darkest band, a round object shows every band, and more bands step sunlit ground and walls too. 2 against 5 bands now changes 50.6 percent of the view, by 20.4 of 255 on average. At the default 3 bands the sunlit courtyard stays in the top band, as in 1.0.4.
  • The test suite gains two checks that fail on 1.0.4 and pass now: no stipple on a smooth ball under any light block, fill or look (1.0.4: toonBands 5.3 percent flecked, celPoster 15.4), and a band count that shows (at n bands the ball shows at least n flat tones; 1.0.4 showed 2, 3, 3 and 4 at 2 to 5 bands). Every Lookbook row is measured again.
  • Found and left for styleKit: the stack's sun is the first directional light the lighting list names, which on the campaign stage is the world clock's sun rather than the light holding the scene's sun; their directions are close there.

1.0.4 (2026-11-02): shaded surfaces keep their own colour under toonBands, and the Lookbook text matches its table.

  • toonBands painted the shadow band at the base colour times shadowLift and the tint, about 40 percent of a surface's colour, however much light the scene really gave it. Under the Toon recipe stage's strong sky the house walls and roof, turned from a low sun, show at nearly full colour unstyled (brick 172, 88, 63 on 0..255) and came out dark brown (75, 38, 39). New setting keepShade (0.7): a band never goes below that share of the brightness the scene showed at the pixel, keeping its tint and hue, so the walls read brick red with a cool cast (121, 59, 58) and the roof tile red; cast shadows and dark scenes stay dark, and black stays black. 0 gives 1.0.3's shadow. The toonBands, saturdayMorning and comicInkCel rows are measured again.
  • The paragraph under the Lookbook table still quoted the first run's numbers after 1.0.3 re-measured some rows (the highlight "swims most at 2.84", "highlight 0.25 ms", looks "1.37 to 3.72 ms high", Nineties CG "3.35"). It is rewritten from the table as it stands.
  • The toonBands README listed shadowLift as 0.55; its default is 0.65.
  • The Style Cookbook's Toon recipe scene (in the Cookbook world, not this package) had been saved with an empty stack; it opens wearing Comic ink cel again.

1.0.3 (2026-11-02): two fixes that 1.0.2 claimed and did not deliver.

  • toonHighlight was still all but invisible on the Toon recipe stage at its defaults. 1.0.2 retuned it but kept the placement: a blob at the exact point where the sun mirrors into the eye. Under the stage's low sun from behind that point lies on almost no surface the camera can see, so the block had nowhere to draw. It now places a cut-out glint where the shape really bends (round parts, and the edges of boxes, steps and rims, found by testing depth against a plane across taps 5 and 15 pixels out, bendFrom, new), oriented by the depth-built normals averaged over those taps, on the side that faces both the sun and the viewer (fromView, new, 0.5). Flat faces never light up whole, and fine grain (tiles, grout, far depth noise) neither moves nor sets off a glint, so it stays calm in motion: a first version of this fix that read shape from one-pixel normals twinkled on every tile (warped difference 19.7 in the Lookbook's pan against 6.57 unstyled) and was not released. size 0.55, curvedOnly back to 1, curveReach 5. On the stage it now draws clear white glints along the basin rim, the crate slats, the television's frame and the character's lit side, alone and on top of toonBands.
  • Outlines on a skinned character still broke up at distance. The cause was not depth, as 1.0.2 said: the stage's character is built flat-shaded (every triangle with its own corners and normal), so its shell, pushed out along those normals, parted into separate triangles, which show as dashes once the line is wide next to a limb on screen and as loose shards further out. Each skinned shell now wears a copy of the mesh whose shared corners share one averaged normal, built once per machine. 1.0.2's depth bias is removed: it had the wrong sign for this engine's depth and pulled the shell toward the camera, by more than a metre at ten metres, so at a distance it covered the character. 1.0.2's check at 3, 10 and 30 metres was also wrong: it zoomed the lens at distance, which made the character large next to the line and hid the problem. Checked again with the width scaled with the zoom, so the line keeps its real share of a limb: solid at all three distances.
  • The Lookbook rows for toonHighlight, comicInkCel and ninetiesCG are measured again below.

1.0.2 (2026-11-02): toonHighlight was all but invisible at its own default settings (a reviewer could add it to a scene and barely see a difference). The cause was two things together: the blob's own window was narrow at the shipped default, and curvedOnly (1 by default) gated it by a curvature test read from normals rebuilt from depth, which are flat across a whole facet and only jump at facet edges, so a modestly tessellated round thing (a character's limbs, a simple sphere) read as mostly flat. The curvature test now reads the surface's shaded normal (interpolated per vertex, with any normal map) instead, curvedOnly defaults to 0.25 rather than 1 so the curvature test only lightly restrains the highlight instead of nearly hiding it on content it misreads, and size and litAbove moved to 0.4 and 0.65. toonOutline's shell now carries a small, constant depth bias away from the camera, so on an animated character whose limbs are thin enough on screen that the outline's width is a large share of their own (ten, then thirty metres away) the shell no longer flickers into a dashed or scattered line fighting the body's own depth for the same pixels; checked at 3, 10 and 30 metres. Needs styleKit 1.2.4, whose own fix (a block's shader property schema no longer cached forever) is what let this release's own defaults be retuned and trusted at all; without it, a block's defaults can get stuck mid-session even after its shader is edited and recompiled, independent of this package. The Lookbook numbers below are from before this release (toonHighlight's own row undersells it); a corrected set is in the notes for the next pass.

1.0.1 (2026-11-02): the install note says what an install brings (toonMaterials and materialLibraryKit too, for the no-double-ink check) and that the first example ran word for word in a fresh world; the test suite's check that a block changes the picture asks less of the rim and the highlight, which by design touch only a few edges and one blob on its test set. No block changed.

1.0.0 (2026-11-02): first release.