Digital World (I): From X11 Desktop Pets to an Autonomous Living Ecosystem

For years, I’ve had an itch to scratch when it comes to Digimon video games. Aside from niche gems of the PlayStation era like the original Digimon World, almost all modern adaptations commit the exact same sin: they turn Digimon into generic turn-based RPG avatars wrapped in monster skins, completely disregarding the original concept born in the late 90s.

A Digimon is not a Pokémon. It wasn’t created to sit idle inside a capsule waiting for you to hit “Tackle”. A Digimon is, first and foremost, a Virtual Pet (V-Pet): an autonomous software entity with an unforgiving metabolism that eats, poops, sleeps, falls ill, fights for territory, and perishes if neglected. Most importantly: it inhabits the Digital World, a hostile cyber-realm forged from rogue network packets, computer viruses, and entropy.

Throughout this year, I’ve been immersed in redesigning and building my own Digimon game from scratch. But before arriving at the current architecture—where the Digital World breathes as a massive cellular automaton powered by Conway’s Game of Life coupled with the biometric mechanics of a physical Digivice—the project began with a colossal predecessor that served as our experimental testbed.

This is the first article in a series dissecting the technical architecture, mathematical models, and systems design behind this development. And to understand where we’re heading, we must first look at where we started: a monolithic, 17,000+ line native Python program running directly on the Linux desktop.

---

The Origin: Free-Roaming Virtual Pets on the X11 Desktop

The earliest iteration of the project (the legacy codebase preserved in our dev repo under digiworld/) was conceived around a radical premise: why trap Digimon inside bordered game windows when your operating system is already a digital environment?

The architecture was built around PyGObject (GTK+ 3), Cairo, and Pillow on Linux with the X11 windowing system. Instead of spinning up heavy engines like Godot or Unity, each Digimon on screen was an independent, borderless, transparent Gtk.Window (decorated=False), equipped with hardware alpha channel compositing through Cairo RGBA visuals:

# Desktop-pet window architecture in digiworld.py: Transparent floating window
class PetWindow(Gtk.Window):
    def __init__(self, pet_state, app):
        super().__init__(type=Gtk.WindowType.TOPLEVEL)
        self.app = app
        self.pet = pet_state
        self.set_decorated(False)
        self.set_keep_above(True)
        self.set_skip_taskbar_hint(True)
        self.set_skip_pager_hint(True)

        # Configure genuine hardware alpha compositing via X11 / Cairo
        screen = self.get_screen()
        visual = screen.get_rgba_visual()
        if visual and screen.is_composited():
            self.set_visual(visual)
        self.set_app_paintable(True)
        self.connect("draw", self._on_draw)

The Digimon weren’t confined to a cage: they literally walked on top of your terminals, web browsers, and file managers. A timer loop driven by GLib.timeout_add coordinated 25 FPS animations (TICK_MS = 40), boundary collisions, and life cycles.

The entire application revolved around an orchestrator object, DigiWorldApp, driven by four decoupled clock loops:

Loop	Interval	Simulation Responsibility
_on_tick	40 ms (25 fps)	Screen traversal, 16x16 sprite animation frames, cross-window scans, and collision encounters
_on_life_tick	30 seconds	Digestion, hunger depletion, poop generation, and morbidity calculations
_on_evo_tick	5 seconds	Evolution window checks and care mistake threshold evaluation
_on_store_anim_tick	Variable	Storage box animations and transfers to the Digi-Farm

---

Classic V-Pet Simulation: Metabolism and Care Mistakes

To make the experience authentic, I compiled and reverse-engineered telemetry formulas from original Bandai instruction manuals and Humulos documentation (specifically for the Digital Monster Color and Pendulum Color devices).

In digiworld.py, metabolism did not pause upon closing the app. Real wall-clock time was tracked between sessions to calculate hunger and energy degradation when rebooting your machine:

# Core metabolic constants from digiworld.py
HUNGER_TICK_SECONDS = 25 * 60          # -1 Hunger every 25 real-world minutes
FEED_HUNGER_GAIN = 2
FEED_WEIGHT_GAIN = 1
CARE_MISTAKE_HUNGER_SECONDS = 40 * 60  # Hunger at 0 for 40 mins = 1 Care Mistake

POOP_INTERVAL_SECONDS = {
    "Baby I": 6 * 60, "Baby II": 8 * 60, "Child": 12 * 60,
    "Adult": 30 * 60, "Perfect": 40 * 60, "Ultimate-Super Ultimate": 50 * 60,
}
POOP_CARE_MISTAKE_SECONDS = CARE_MISTAKE_HUNGER_SECONDS
SICKNESS_POOP_SAFE = 2                  # Up to 2 poops on screen carries no extra risk
SICKNESS_CHANCE_OWNED_BASE = 0.0015     # Base probability per tick
SICKNESS_CHANCE_OWNED_PER_POOP = 0.02   # Exponential increase per uncleaned bio-waste
SICK_CARE_MISTAKE_SECONDS = 30 * 60     # Remaining sick for 30 mins untreated = 1 Care Mistake

Care Mistakes are the beating heart of the system:

1. Leaving the hunger meter at 0 for more than 40 consecutive minutes.
2. Letting the Digimon fall asleep next to its own waste without using the cleanup tool.
3. Failing to administer medicine after combat injuries or bacterial infections.

Accumulating too many mistakes guaranteed evolution into dreaded mutant species like Numemon or Sukamon, or premature death, leaving a gravestone (tomb.png) right in the middle of your desktop.

For evaluating evolutions into higher tiers (Adult, Perfect, Ultimate), I implemented strict win-rate probability tables:

def roll_evolve_chance(win_rate):
    """
    Evolution probability based on historical win-rate (Humulos DMC specs):
    >= 80% -> 100% success
    60-79% -> 50% chance
    40-59% -> 25% chance
    < 40%  -> 0% (evolution rejected)
    """
    for row in WIN_RATE_EVOLVE_CHANCE:
        if win_rate >= row["min_win_rate"]:
            return row["chance"]
    return 0.0

---

The Colosseum & 90s Hacker PC Aesthetics

To provide a narrative context faithful to the original Digimon mythology (creatures born inside military subnets and legacy 90s workstations), I developed an in-game subsystem called 90s Hacker PC: a retro desktop environment emulating Windows 95/X11, featuring an interactive shell, legacy browser, procedural chiptune synthesizer, and a suite of “exploits” that consumed hacker XP to alter live game memory:

HACKER_PROGRAMS = [
    {
        "id": "overclock",
        "name": "OVERCLOCK.EXE",
        "title": "CPU Overclock V-Pet",
        "type": "MAGIC // BOOST",
        "level": 1,
        "desc": "Injects overvoltage into the CPU: +35% ATK and +25% Speed.",
        "cost": 12, "xp": 30,
    },
    {
        "id": "sys_restore",
        "name": "SYS_RESTORE.EXE",
        "title": "System Restore",
        "type": "MAGIC // HEAL",
        "level": 35,
        "desc": "Flushes buffer errors and restores 100% HP to the active team.",
        "cost": 104, "xp": 260,
    },
    {
        "id": "boss_event",
        "name": "BOSS_EVENT.RAW",
        "title": "Mega Boss Raid",
        "type": "EVENT // INVASION",
        "level": 50,
        "desc": "Tears open a dimensional rift, summoning a feral Mega boss onto the desktop.",
        "cost": 200, "xp": 500,
    }
]

Combat was far from a static numbers roll. I built a procedural rendering pipeline in digiworld/tools/build_attack_fx.py that pre-rendered hundreds of attack frames, beams, and impact bursts categorized by archetype (projectile, beam, melee, ground, barrage).

Kinematic rules governed encounters: if a Digimon initiated a melee rush (melee_dash) while an opponent unleashed a beam, the engine calculated an interrupt check (_fx_mark_interrupted): the losing strike was cancelled point-blank in a shower of bytes, capturing the clash dynamics of vintage 90s anime battles.

---

The Limits of the Model: Why a Radical Shift Was Needed

The digiworld.py prototype was undeniably fun and technically impressive for a monolithic Python script. But it suffered from a fundamental conceptual flaw:

The pets were alive, but their world was dead.

My PC desktop was merely a flat canvas of $(X, Y)$ coordinates. There was no digital flora, no dynamic biomes, no food chain, and no territorial struggle. Wild creatures spawned on arbitrary timers and drifted around bouncing off screen edges. For two Digimon to clash, their hitboxes had to collide purely by chance.

In Digimon lore, the Digital World has always been an emergent byproduct of humanity’s global data transmission—a chaotic computational soup where raw packets spontaneously coalesce into living forms.

That’s when the missing piece clicked: cellular automata.

What if, instead of wandering across a static screen, the Digital World itself were a living cellular automaton governed by the rules of John Conway’s Game of Life?

• What if live cells on the grid represented forageable data bits that grow and reproduce under mathematical laws?
• What if cellular gliders, oscillators, and still-life blocks shaped the physical terrain and resources of the monster’s habitat?
• What if cellular overcrowding collapsed into “Glitches” and digital bio-waste, corrupting the surrounding biome?
• What if Digimon acted as apex predators within the automaton, trampling cells as they roam and disrupting Conway cycles with their actions?

In the next article, we will dive deep into the architecture of Digi-Life: how we adapted Conway’s 4 classic rules into an untamed ecosystem featuring the attribute triangle (Vaccine, Virus, Data), and how we designed the procedural map engine to render the legendary File Island in 16-bit glory.