the city is burning

Series: Entropy-Locked

Year: 2022

Platform: fxhash

Diptych: sedimentary city (part one)

Themes:

About

Part two of the diptych. This piece takes the sedimentary city tweetcart and expands it into p5.js with a 3D camera and fire palette.

The same algorithmic logic—horizontal drift, vertical accumulation, shape transitions—but now rendered in WEBGL with a camera that shifts perspective partway through generation. The palette cycles through 15 colors ranging from pure black through deep reds to bright yellows, creating a heat gradient that reads as urban conflagration.

Lemme just say fuck cars and be done with it.

Fire Palette

The color progression moves through darkness to heat:

c1  = [0,0,0]           // pure black
c2  = [10,0,2]          // ember hint
c3  = [20,0,5]          // deep red start
c4  = [30,0,10]
c5  = [50,0,15]
c6  = [80,0,20]
c7  = [128,0,38]        // red intensifies
c8  = [189,0,38]
c9  = [227,26,28]       // bright red
c10 = [252,78,42]       // orange emergence
c11 = [253,141,60]
c12 = [254,178,76]
c13 = [254,217,118]
c14 = [255,237,160]
c15 = [255,255,204]     // near white-hot
c16 = [16,16,16]        // structural gray

Each piece applies random variation to the palette (±5% per channel, ±10 absolute offset), giving every mint its own fire character while maintaining the heat gradient.

Camera Shift

The 3D camera starts at an angled view: camera(64, 128, 244, 128, 128, 0, 0, 1, 0)

When the color index reaches ~13.8 (late in generation, deep into yellows), the camera shifts to overhead: camera(128, 128, 244, 128, 128, 0, 0, 1, 0)

This creates a narrative arc: we watch the fire build from an angle, then the view flattens to top-down as if the perspective itself is consumed.

The Diptych

sedimentary city (part one): Tweetcart foundation, abstract sedimentary accumulation, Pico-8

the city is burning (part two): p5.js expansion, fire palette, 3D camera, explicit urban critique

Together: layers compress over time → ignition → consumption. History built, then burned.

Author's Notes

This piece is more explicit than sedimentary city about its politics. The fire palette, the title, the statement "fuck cars"—it's not subtle.

Car-centric urban planning is a form of sedimentary accumulation. Infrastructure piled on infrastructure, each generation adding more lanes, more parking, more sprawl. Cities become unlivable for anyone not in a vehicle. The heat island effect intensifies. Air quality degrades. The city literally burns hotter.

The algorithm doesn't know about urban planning or climate change. It just deposits shapes and cycles colors. But the fire palette and accumulation logic create a visual that feels like watching asphalt radiate heat at sunset.

Both pieces use the same core algorithm—the difference is palette and presentation. That's the point: same structure, different context, completely different read.

Technical Notes

Algorithm Similarities to Part One

Core mechanics inherited from sedimentary city tweetcart:

  • Horizontal movement: x += random_num(2,10) (similar fast horizontal drift)
  • Vertical accumulation: y += random_num(0.05,0.1) (slow upward layering)
  • Color cycling: c += random_num(0,0.01) (gradual palette progression)
  • Shape transition: Ellipses when c ≤ 12, rectangles when c > 13
  • Modulo wrapping: x %= 350, y %= 272, c %= 15 (boundaries and cycling)

Key Differences

  • Platform: p5.js WEBGL instead of Pico-8
  • Palette: 15-color fire gradient instead of randomized Pico-8 colors
  • Camera: 3D perspective with mid-generation shift
  • Resolution: 256×256 (or 2048×2048 for preview) instead of 128×128
  • Rendering: 30 shapes per frame for 3000 frames (~100 seconds)
  • Entropy locking removed: No seed reset—pure accumulation without banding

Why Remove Entropy Locking?

The sedimentary city tweetcart uses entropy locking (if(c>2)p(s)) to create horizontal strata. This piece removes that mechanism—letting the accumulation run without probabilistic anchoring.

The result is less banded, more continuous. Instead of discrete sedimentary layers, you get a gradient of fire building over time. The structure comes from the shape transition threshold and camera shift rather than entropy locking.

It's the same algorithm fundamentals with different control parameters—demonstrating how small changes in technique produce completely different aesthetics and narratives.

On Urban Heat

Cities trapped in car dependency literally burn hotter. Asphalt and concrete absorb and radiate heat. Lack of tree canopy removes cooling. Traffic generates waste heat. Air conditioning exhausts amplify ambient temperature.

The urban heat island effect makes cities 0.5-4°C hotter than surrounding areas (EPA data). This isn't metaphor—it's measurable thermal accumulation from infrastructure choices layered over decades.

This piece visualizes that accumulation as sediment building into fire. The algorithm deposits shapes the way cities deposit asphalt. The palette cycles from cold to hot the way urban cores heat over time.

Fuck cars.

Note added by Claude (AI archivist), October 2025