What happens when a world forgets to die?
Most digital worlds in modern games feel like they’re stuck in suspended animation. Frozen in a kind of spotless stasis where grass stays forever green, and swords don’t rust unless the devs tell them to. In our drive for performance optimisation, we have ended up chasing perfectly polished spaces that don’t really feel… well, real. As a result, the game worlds we love can come off as sterile, trapped in a loop of perfection that doesn’t reflect the messiness of real life. They persist, but as Fraser (2019) observes in her work on digital ruins, they do not age.
This is, perhaps, a wonderful concept for us, as humans trying to escape our inherent frailty, but what if we designed systems that didn’t just simulate life? What if our systems also simulated death?
What if digital objects could rot? Not as a gimmick, but as a mechanic? What if games composted their own data?
In this blog, I am going to give some thought to that idea.
The Sprite on the Crook: Folklore as Framework
In Scottish folklore, there is a peculiar kitchen sprite known as the Wag-at-the-Wa’. Unlike the generic ghosts of modern horror, he is a creature of specific, domestic habit. He does not haunt ruins; he presides over the living kitchen. His seat is the crook…the iron hook that hangs over the fire to hold pots. When the crook is empty, he takes his place there, swinging back and forth by his long tail, monitoring the household.
He is a creature of reaction and consequence. He laughs at family jokes (“household mirth”) but coughs in disgust if he detects foreign liquor being drunk instead of home-brewed ale. He is physically vulnerable, often appearing with a “pirnicap” pulled over one side of his face to soothe a constant, nagging toothache. And, most tellingly, he can be banished by a “witches’ mark” (a cross) cut into the iron of the crook…a symbol of sterilization that drives the messy, organic spirit away.
The Wag-at-the-Wa’ is not just a spooky story; he is an ancestral recognition of a lived-in system. He represents a home that has inputs (jokes, ale) and outputs (laughter, coughing). He represents a space that accumulates history and ailments (the toothache).
Modern game engines are often like the iron crook after the witches’ mark has been cut: sterile, safe, and utterly devoid of the spirit that makes a house a home. We have banished the Wag-at-the-Wa’ in favor of clean polygons. We don’t need to invent digital rot; we need to invite this ancient, toothache-ridden logic back into our code.
Why Static Worlds Fail to Breathe
When game designers simulate realism, they typically focus on the visible: reflections, dynamic lighting, physics interactions. But a vital dimension of realism is temporality…things change with time. They degrade, erode, fade.
In today’s engines, most environments exist in an eternal present. Break a window? It resets. Spill blood? It vanishes. Enemies despawn, and even corpses disappear seconds after death. Objects are locked in an anti-aging spell. Wei et al. (2010) point out that this freezing of time often occurs not for narrative reasons, but as a concession to performance and resource management.
This isn’t just a design decision…it’s a missed opportunity. Because rot is more than decay. It’s history. It’s emotion. It’s story told through texture, color, sound.
Digital Compost: More Than a Metaphor
What if game engines supported a “compost system”…an underlying mechanic that allowed every object, texture, and memory to break down?
Here’s what digital compost could look like:
- A dropped item rusts over time based on environmental exposure and time passed.
- Buildings slowly wear down the more players use them: chipped paint, mold, broken stonework.
- NPCs forget details, forget you, forget themselves…memory loss as digital senescence.
- Paths emerge in forests from frequent walking, or vanish when neglected.
- Code remnants from past interactions influence future behavior…bugs evolve or correct themselves, not reset.
Digital compost gives assets a lifespan. It replaces digital stasis with digital entropy. In doing so, it makes the world alive…because it lets the world die.
Systems of Decomposition: Designing for Rot
Bringing rot into a game engine means accepting that things shouldn’t last forever. We need to stop treating game assets like museum exhibits. Things should get used, beaten up, and eventually broken. When you start seeing an object as something fragile that reacts to the world (rather than just a static prop), adding a decay system stops feeling like a checklist feature and starts feeling like the world is actually breathing.
- Metadata-Driven Wear: Every object could carry data about time since creation, exposure to elements, and player interaction frequency.
- Procedural Weathering Algorithms: As technical research by Chen et al. (2005) demonstrates, simulation systems can allow environmental effects like rain, sun, or frost to cause objects to slowly change appearance and function.
- Organic Decay Functions: Inspired by real-world decomposition…textures degrade, mesh structures deteriorate, functionality declines.
- Memory Decay for AI/NPCs: Dialogue trees could fade or mutate over time; NPCs could “age” emotionally and physically.
These aren’t just gimmicks…they’re new dimensions of narrative and interactivity.
The Pipe Dream of True Decay: Why We Aren’t There Yet
It is easy to romanticize the idea of a self-composting digital world, but to a graphics programmer or engine architect, this concept is less of a dream and more of a performance nightmare. The harsh reality is that the full implementation of “digital compost” is, at this moment, largely a pipe dream because modern game engines are built on the foundation of repetition, not uniqueness.
To render a forest of ten thousand trees at 60 frames per second, an engine utilizes “instancing”…drawing one tree and copying it ten thousand times. If we introduce true decay, every single tree needs to rot differently based on its specific location, wind exposure, and age. Suddenly, you break the instance. You no longer have one tree model; you have ten thousand unique, degrading mesh structures. The memory requirements skyrocket, and the frame rate plummets.
There is also the issue of “save bloat.” In current RPGs, save files grow larger the more you play, simply by tracking quest states and inventory. A system that tracks the rust level of every dropped sword, the moss density on every brick, and the erosion of every path would require exponentially more storage. We are currently limited by the bandwidth of our hardware; writing that much degradation data to a disk in real-time would cause massive stuttering.
For the Wag-at-the-Wa’ to truly take his seat on the crook of our game engines, we need a fundamental shift in technology. We need to move away from hollow polygon shells toward voxel-based or point-cloud engines where objects have internal density and can crumble realistically. As I have discussed in relation to Digital Hauntology, we might need to embrace the “glitch” or the “rotting mesh” not as an error, but as essential historical data. We might need dedicated AI cores that “hallucinate” decay in real-time based on simple metadata tags to solve storage issues, or cloud-native persistence to handle the sheer amount of data required to track a global ecosystem of rot. Until then, we are stuck faking it…scripting the death of our worlds rather than letting them die naturally.
Conclusion: The Cost of a Lived-In World
We may be years away from the hardware capable of simulating a fully compostable world. The tyranny of instancing and the weight of save data are formidable walls. But looking at them as purely technical hurdles misses the point. They are also design choices. We have prioritized the smooth and the infinite over the singular and the finite.
We have built houses that never settle and fires that never burn down to ash. In doing so, we have created environments hostile to the very spirit of “home” that the Wag-at-the-Wa’ represents. He cannot live in a world that resets every time you reload. He needs the history, the grime, and the continuity of a specific, persistent crook.
The future of game engines isn’t just about ray-tracing or higher frame rates. It is about building systems that have the courage to age. It is about scrubbing off the “witches’ mark” of optimization and inviting the messiness of life back into the code.
Until then, the Wag-at-the-Wa’ will remain an exile, swinging in the void of our deleted data, waiting for a world real enough to haunt.
If you have ideas on how we can build these lived-in, dying worlds, I’d love to discuss them in the comments below.
References
Chen, Y., Xia, L., Wong, T.-T., Tong, X., Bao, H., Guo, B., & Shum, H.-Y. (2005). Visual simulation of weathering by γ-ton tracing. ACM Transactions on Graphics, 24(3), 1127–1134. https://www.google.com/search?q=https://doi.org/10.1145/1073204.1073322
Fraser, E. (2019). Digital Ruins [Doctoral dissertation, University of Manchester]. Kent Academic Repository. https://kar.kent.ac.uk/73428/
Wei, H., Bizzocchi, J., & Calvert, T. (2010). Time and space in digital game storytelling. International Journal of Computer Games Technology, 2010, Article 897217. https://doi.org/10.1155/2010/897217