Light

How a pixel game can light its worlds, from a single lamp up to light that bounces, and which techniques keep a frame within its palette. Light in a pixel game sits on a spectrum: at one end, high-bit renderers put pixel sprites under modern light; at the other, strict-palette games let light only choose which ink a pixel shows. The dividing question for every technique is whether light selects an ink or produces new colors. Smooth, banded, dithered and reprinted light are stages of one pipeline, and only the last stages keep a frame strictly within eight inks. Tile flood fill, shadowcasting and even global illumination are small CPU grids at 320×180; normal maps, bloom and god rays belong to the high-bit look. Tycho already has the high-bit core; what it lacks is the strict core. The sun is on its own page.

Proposed: none of this is in Tycho yet. The demos run here in the page, written in plain JS with the study’s own kit (demos/kit.js), not Tycho; each says how it would run in Tycho: per frame (the GPU stand-in’s calls), pre-bake (painted once offscreen), or shader (per-pixel work every frame). What would move into Tycho, and when, is in the roadmap.

Text marked (inference) is reasoning from the sources, not a sourced fact.

• Selecting an ink
• One pipeline from smooth to reprinted
• Ramp-table light
• Tile flood fill
• Hard shadows
• Global illumination
• Normals, glow and shafts
• What runs where
• Sources

Selecting an ink

Elsewhere’s eight-ink rule puts it at the strict end of the spectrum, and Tycho’s GPU stand-in, which per frame draws only with fillRect, drawImage, alpha, transforms, gradients and four blends, makes the strict end cheap. Those four blends are source-over, lighter, destination-out and multiply; there is no screen. The stand-in also already draws an emissive target (“what glows”, gpu.ctx(F.EM)) and an unlit overlay beside the color target (the renderer).

One pipeline from smooth to reprinted

The looks from smooth to stylized are stages of one pipeline. A coarse light buffer is computed, upscaled (smooth light), optionally quantized to N levels (bands), and optionally broken at band edges by an ordered threshold (dithered light).

Tycho’s Smooth model is the first two stages. It holds RGBA bytes per cell, interpolates them bilinearly in a shader, and outputs clamp(p*m + m*uAdd, 0, 1) with add = 0.1 (light.ts). That is Unity’s two-factor blend with Modulate 1 and Additive 0.1 (Unity URP), and it is fast: Tycho’s renderer cut Lodestar’s frame from 4.3 to 1.3 ms in Chrome and 20 to 2 ms in WebKit (the renderer).

Smooth light does break the pixel grid. Godot’s docs say lighting “is computed at the Viewport’s resolution, not the sprite texture’s texel resolution”, and they suggest flooring light vertices to the pixel grid (Godot docs). Posterizing per-fragment light still leaves “jagged patches that break up the pixel grid” unless shading is done per texel (Unity forum).

In rising order of style:

1. Smooth light, in cells smaller than a tile.
2. Light snapped to art pixels.
3. Quantized bands.
4. Bands with Bayer edges.
5. Palette reprint, where light only selects among inks.

Only the last, or bands resolved to inks through a ramp table, keeps a frame strictly within eight inks (inference).

Ramp-table light

Ramp-table light has a clear public model. LutLight2D gives each palette color its own hand-made gradient “starting from the original, lightest, to the darkest” and picks the replacement by light brightness, so it “keeps the original colors of the palette” (LutLight2D). Bloodless used “a 4-color palette and used lighting to blend between those colors with dithering on the borders” (Game Developer), and Lodestar already runs 16 stepped bands with violet darks through gpu.lightPass (Lodestar gllight.js).

Bayer beats noise for the band edges (Surma: Ditherpunk):

Without a shader, the strictest path is a JavaScript loop out[i] = rampLUT[ink[i]*N + band[i]] over a frame composed as indexes and uploaded with drawPixels. That is about 60,000 table reads at 320×180, estimated at well under a millisecond but not measured on phones (inference). The cheaper stand-in path prints each layer once per band and draws the right print per light region (inference).

Light colors combine best in the CPU buffer. Screen blending is unavailable in the stand-in, but 1 − Π(1 − Lᵢ) per cell gives a non-clipping mix of many lights before the multiply, and warm and cool light can choose between two ramp tables per ink (inference; blend formulas from W3C Compositing).

Tile flood fill

Three shipped engines compute light per tile on the CPU and interpolate it on the GPU.

At Elsewhere’s scale this is trivial. A 40×23-tile view with a light-radius border is about 2,600 cells, and Terraria’s sweeps are about 20,000 cell visits a frame, all deterministic and handed straight to Smooth, whose bilinear filter matches Terraria’s corner averaging (inference). Linear falloff quantizes into evenly spaced rings, which suits bands; Terraria’s exponential tail crowds rings near the source (inference).

Hard shadows

Hard shadows come cheapest from grid shadowcasting. Adam Milazzo measured recursive shadowcasting at 89,577 runs per second on an empty 20×20 map against 83,608 for ray casting, concluding “a well-implemented shadow casting algorithm beats ray casting every time”, though it has blind corners and narrow diagonal vision (Milazzo). Written into the light cells, it gives tile shadows that Smooth softens for free (inference).

Global illumination

Global illumination (GI) is light that bounces: a lamp lights a wall, and the wall lights what’s near it in its own color. It is the far end of the spectrum.

• Jump-flood GI: Sam Bigos’s runs ten passes for a 768×512 buffer and casts 32 rays per pixel with up to 128 steps each, and it stays noisy (Bigos).
• Radiance cascades, unveiled by Alexander Sannikov of Grinding Gear Games in November 2023, cost “roughly the cost of the naive method at 16 rays, but without noise” (80.lv; jason.today; GM Shaders).

A CPU cascade at 160×90 might take 2 to 10 ms, which makes a noise-free bake of static light per room possible. But under eight inks GI reduces to “which band, which ink”, so it suits at most one showcase world with a high-bit look (inference).

Normals, glow and shafts

The high-bit games buy their look with per-pixel tools.

• Normal maps. Dead Cells redrew backgrounds as normal maps, so “a torch on the left of a statue will light up the statue from the correct direction while respecting its base colours” (80.lv). The Siege and the Sandfox warns that one pixel can hold only one normal, so artists should favor angles over gradients (Game Developer). Children of Morta stretched its sprites about four times so lighting could run at a finer resolution than the art (TechRaptor). For a strict palette, the equivalent is baking four or eight light directions per sprite, each quantized to the inks, and picking the nearest at draw time (inference).
• Bloom. Threshold bloom, such as Phaser’s default of 0.55, makes every light ink glow in an eight-ink palette, so glow should come from the emissive target or from halos baked once and drawn with lighter (Phaser; the palette consequence is an inference).
• God rays. Screen-space god rays blur an occlusion mask toward the light, as three.js does in three passes of six samples (three.js ShaderGodRays). On the stand-in, a few baked shaft sprites breathing in alpha give most of the look (inference).

What runs where

The tiers and costs are inferences from the cited mechanisms and Tycho’s renderer limits (the renderer). The demos above run them this way in Tycho’s terms:

Tycho already has the high-bit core (Smooth, ctx.lightMap, ctx.tint, the emissive target and post.Blur). What it lacks is the strict core: a sun, a tilelight that writes the cells Smooth reads, a ramp light model with world-anchored Bayer, and bake helpers for faces, shadows, halos and directional variants.

Sources

• Tycho: the renderer and light.ts
• Unity URP, 2D light blend styles and Unity forum, per-texel lighting
• Godot docs, 2D lights and shadows
• LutLight2D
• Game Developer, the art direction of Bloodless
• Surma, Ditherpunk
• W3C, Compositing and Blending
• Minecraft Wiki, Light
• Terraria 1.4.4.1 decompile: LightMap.cs and Lighting.cs
• OpenStarbound: StarCellularLightArray.hpp and .cpp
• Adam Milazzo, roguelike vision algorithms
• Red Blob Games, 2D visibility
• Matt DesLauriers, 2D pixel-perfect shadows
• Sam Bigos, 2D global illumination in Godot
• Radiance cascades: 80.lv, jason.today, GM Shaders
• 80.lv, interview with the developers of Dead Cells
• Game Developer, hand-drawn normal maps in The Siege and the Sandfox
• TechRaptor, the art of Children of Morta
• Phaser, post bloom
• three.js, ShaderGodRays
• Lodestar gllight.js

The full research is in the notes on 2D lighting and on effects and rendering.