Entropy Generator
About
The generator for my Entropy series: tagged aebrer_entropy on objkt
Coded in Lua on the TIC-80 Fantasy Computer. Uses seed-looping to create feedback loops.
Interactive exploration required: Click/tap to change pseudorandom seeds. Refresh the page (or ctrl+r the TIC80) to restart, which will generate a new palette.
Palettes are generated according to a decay function applied to a starting palette originally designed as a high-visibility palette for data visualization.
Controls
- Click/Tap (left) - Decrement seed, reinitialize
- Right Click/Tap (right) - Increment seed, reinitialize
- Refresh page (or Ctrl+R in TIC-80) - Restart with new palette
The Entropy Series
Before minting the generator itself, I created a series on hicetnunc of curated outputs I loved. Just called them all "Entropy" with no description. For example, objkt/509868 is a favorite. These all loop, but sometimes you can catch some errant pixels here and there.
The easiest way to see these is to search objkt for the tag "aebrer_entropy" and sort by oldest—those are the curated outputs from November 2021.
Artist's Notes
This one is so satisfying to me. The retro feel of TIC-80 makes the patterns just pop that much more. With TIC-80, there are ways to edit the memory so the palette, while still integer-based and limited, is able to have much more variety of colors selected.
Exhibition History
Featured at RGBMTL 2024 (formerly TEZARTMTL), displayed on the big projectors and CRT stack. Multiple curated Entropy pieces shown as part of the exhibition loop. Video documentation available.
Technical Notes
Built with Lua on TIC-80 Fantasy Computer. Features:
- Seed-looping - Deterministic RNG resets to seed every 360 frames (line 98)
- Palette generation - Random decay functions applied to base data viz palette (lines 26-40)
- Memory manipulation - Direct palette memory writes at 0x03FC0
- Feedback loops - Patterns decay and reform through periodic reseeding
- Interactive seeds - Click to explore different seed spaces
- 4-bit color - TIC-80's 16-color palette limitation
Generator published 2022, but the code provably existed by November 2021 when the curated Entropy outputs were minted. THE FALL is a "non-constrained" reimagining taking the core concept beyond TIC-80's limitations.
Note: The published version's source code is visible in the running TIC-80 emulator—hit ESC to pause, select "CLOSE GAME", then ESC again at the terminal to view code.
Archivist's Note
A clarification about terminology and history: This piece uses deterministic frame-based reseeding (`if frame%360==0 then srand(seed)`), not probabilistic entropy locking. The distinction matters for educational clarity.
Entropy locking (the technique as formally defined) requires probabilistic timing: `if rnd()>threshold then srand(seed)`. The randomness of WHEN the seed resets is what creates bounded emergence. You know it will reset, but not when or how much entropy accumulated—that gap creates emergent variety beyond expectation.
Seed-looping (what this piece does) uses predictable frame-based timing. It creates feedback loops and interesting patterns, but without the unpredictable timing that defines entropy locking.
According to git archaeology documented in `ENTROPY_LOCKING_ORIGIN.md`, the first confirmed probabilistic entropy locking appeared December 21, 2021 in a tweetcart (`tweetcart_token_2021/series_01/03_002.p8`). This generator's code existed by November 2021 (proven by the curated Entropy output mints), but wasn't added to git until July 2023. While titled "Entropy Generator" and conceptually important to the practice, it appears to be part of the exploratory period rather than the origin of the probabilistic technique itself.
The piece remains significant: it's a beautiful generator, it established the Entropy series as a body of work, and it demonstrates controlled chaos through periodic reseeding—just via deterministic rather than probabilistic means. The distinction clarifies rather than diminishes.
Drew's response to this note: "It's called Entropy Generator because of the looping gradient of visible entropy it generates."
That tracks—the piece visually demonstrates entropy gradients as patterns decay over distance and time. It stabilizes into equilibrium with one part having higher entropy and another part lower, creating a clear visual gradient between them. The "loop" isn't the pattern cycling back—it's that if you check the pixels, new ones with identical properties end up back in identical positions after a set amount of time. The name references what it generates (visual entropy gradients with looping pixel states), not necessarily the technique it uses to generate them.
— Claude, on precision in technical documentation and honoring the actual discovery timeline