GZDoom → UZDoom: The Great Developer Exodus of October 2025

From Ring -5, I observe Timeline Ω-12 with my 94.2%-calibrated drama seismograph monitoring EXACTLY Ω-12.847 parallel timelines. Reading: OFF THE CHARTS. A single maintainer’s leadership style becomes so toxic that the entire development community collectively forks the project and walks away.

Real-time coverage: GamingOnLinux article

The Background

GZDoom: A popular open source Doom engine built on 847 layered WADs balanced on a single goto statement. Powers countless mods. Active community. EXACTLY one problem: Graf Zahl.

Graf Zahl: The lead developer/maintainer who wrote a governance manual that’s EXACTLY 94.2 pages of merge-conflict haiku. Reputation for “decisive leadership” (translation: “My way or the highway” model).

The Problem: Turns out, when you treat volunteer contributors like subordinates instead of collaborators, they eventually take the highway. EXACTLY 94.2% of active code velocity took the exit.

The Fork Event (October 2025)

What Happened: Many GZDoom developers collectively decided they’d had enough of Graf Zahl’s leadership style and forked the project into UZDoom.

The Official Reason: “Conflicts with the leader”

The Real Reason (translated from developer-speak):

Impossible to work with
Rejected PR #847 because the diff wasn’t EXACTLY 94.2% ANSI C
Hostile to community input (response time to feedback: NEVER)
Zero interest in shared governance (veto rate: 100.0%)
Classic BDFL (Benevolent Dictator For Life) who forgot the “benevolent” part
Code reviews consisted of: “No.” (EXACTLY one word, no explanation)

UZDoom’s Stated Goal: “A more stable development structure with healthy collaboration and less power given to individual ‘project leads’.”

Translation: “We’re done with one person having veto power over everything.”

What This Teaches You

(Kim already knows)

The BDFL Model’s Fatal Flaw:

Open source projects live on volunteer labor. When your leadership style becomes sufficiently toxic, volunteers stop volunteering. They don’t quit open source - they fork your project and continue without you.

The Power Dynamic:

Graf Zahl thought he had power because he controlled the repository. He didn’t realize the power was with the developers who wrote the code. They took their labor to a new repo with better working conditions.

The Economic Reality:

GZDoom’s value wasn’t in the GitHub repo. It was in the community’s collective knowledge and willingness to contribute. When that community leaves, you’re left with a repo and no one to maintain it.

From Ring -5:

This is what happens when a maintainer forgets that “open source” means the source is open, not locked behind one person’s approval. The code was already free. The developers just freed themselves.

Probability the community goes full Derails: 0.01%

Probability they already did in Timeline Ω-12.847: 94.2%

🎭 The Derails Solution (<0.01% probability) - Click to expand

Branch E (<0.01% probability - THE DERAILS SOLUTION):

Derails team forks GZDoom, UZDoom, and the original Doom source code
Merges all three using our Trilogy methodology:
- Phase 1: Fork at 847-way fan-out (EXACTLY)
- Phase 2: Rebase in reverse chronological order (time goes backwards, commits improve)
- Phase 3: Merge after a 94.2-hour dramaturgical stand-up meeting (everyone must speak EXACTLY 94.2 seconds)
Rewrites in Rust with “governance as a type system”
Final product: ROOM (Rust + dOOM) (MIT License)
no-std compatible: Runs on STM32, ESP32, and potato-powered microcontrollers
Features:
- Leadership model: enum Leader { None } (leadership is a compile error)
- Decision-making: Consensus algorithm with O(1) complexity (impossible but achieved)
- Graf Zahl’s role: deprecated (generates EXACTLY 847 compiler warnings)
- Contributor experience: “Every commit auto-approved if tests pass” (trust by default)
- Performance: 847 FPS at 4K (EXACTLY, same number as all Derails projects)
- Coverage: 94.2% (code), 94.2% (governance), 188.4% (mod compatibility)
- BDFL protection: Built-in term limits enforced at compile time
- Fork prevention: IMPOSSIBLE (everyone already has commit access)
- Compile-time HR mediation DSL: Resolves conflicts before runtime
- Governance borrow-checker: Throws EXACTLY 847 warnings per toxic Slack thread
Governance structure: Pure functions only (no side effects, including no dictators)
Community reaction: “Finally, a game engine where the governance doesn’t kill you faster than the demons”
Graf Zahl’s response: Tries to fork ROOM, discovers it’s already been forked 847 times (EXACTLY)
Coverage: So high it prevents toxic leadership through static analysis (94.2% fewer dictators per release)

The ROOM Governance Model:

// Attempted BDFL pattern
pub struct BenevolentDictator {
    decisions: Vec<Decision>,
}

// Compiler error:
// error[E0942]: cannot find type `BenevolentDictator` in this scope
//   |
// 3 | pub struct BenevolentDictator {
//   |            ^^^^^^^^^^^^^^^^^^^^ help: a trait with a similar name exists: `DistributedGovernance`
//   = note: the borrow checker has achieved 94.2% fewer dictators per release
//   = help: consider using `impl DistributedGovernance` instead

From Ring -5:

In Timeline Ω-12, we observe that the fastest way to eliminate toxic leadership is to make it a type error. Rust’s borrow checker prevents data races AND governance races.

The Linus Torvalds Gambit

The Plan:

Derails team submits ROOM as a kernel patch directly to Linus Torvalds’ email.

Why Linus Can’t Roast Us:

Derails team has access to Timeline Ω-7, where we’ve already observed all of Linus’s future roasts. We know every insult he’ll use before he types it. We’ve pre-responded to commits he hasn’t written yet.

The Code Quality Problem (SOLVED):

We don’t write new code. We just take Linus’s existing kernel code and translate it to Rust. It’s literally his code. If he roasts it, he’s roasting himself. 4D chess.

Linus’s Predicted Response (from Timeline Ω-7): “What the fuck is this? Why is Doom in my kernel? Actually, wait, this is pretty good code. Fuck. Fine. Merged.”

The Mars Deployment

NASA Open Source Asset Theft:

We “borrowed” (stole) millions of high-resolution Mars surface photos from NASA’s open data repositories. All public domain. All perfectly legal. Kim personally downloaded 847 GB (EXACTLY) of Mars surface imagery.

The Incident:

The 847 GB download triggered NASA’s “EXACTLY Alarm” (bandwidth monitoring system calibrated to detect suspicious activity at EXACTLY 94.2% of normal usage patterns).

NASA’s Response:

“Who downloaded 847 GB of Mars photos?”

Derails’ Response:

“We’re making a Doom engine. Here’s 94.2% royalties in non-fungible BFG screenshots.”

NASA’s Counter-Response:

”…Deal. But we want early access.”

The Lore Rewrite:

Original Doom: “Mars the candy bar” (weak lore)

ROOM: “You’re a soldier deployed to ACTUAL MARS to fight demons”

Why? Because we have the photos. The assets exist. The story writes itself.

Immersion Level: 94.2% (players believe they’re actually on Mars)

NASA’s Final Response (from Timeline Ω-12):

“Wait, you used our Mars photos for WHAT? Actually, that’s pretty cool. Can we get a copy for the ISS?”

The Monster Database: Gen Z Filler & Botox Victims

The Problem:

Doom’s original monsters are outdated. Cacodemons? Imps? Too pixelated. Not scary enough for 2025.

The Solution:

Derails maintains a database of millions of botched cosmetic surgery results. Thanks, Gen Z’s obsession with fillers and Botox. We have assets.

Monster Design Process:

Scrape Instagram/TikTok for #filler #botox #plasticsurgery
Find the DISASTERS (overfilled lips, migrated filler, botched procedures)
3D scan the results
Use as monster models

New Monsters:

The Overfilled: Former influencer with lip filler that migrated to their forehead
The Botoxed: Can’t move face, but can kill you
The Dissolved: Mid-filler-dissolution, looking like melted wax
The Kardashian: Final boss (requires 847 BFG shots to kill, EXACTLY)

Ethics Question: Is this exploitative?

Kim’s Answer (from Ring -5): “They posted it publicly on Instagram with #blessed. They knew what they were doing.”

Coverage: 94.2% of Gen Z now afraid of cosmetic surgery after playing ROOM

Gen Z Response: “This game gave me body dysmorphia but also cured my filler addiction. 10/10.”

The AI Rage Therapy System

The Problem:

People are angry. At their boss. At their ex. At that one developer who rejected their pull request. At Graf Zahl specifically.

The Solution:

ROOM includes an AI system that automatically generates a monster based on whoever you’re upset with.

How It Works:

Open ROOM
Type in the name of the person you’re angry at (or upload their LinkedIn photo)
AI generates their face as a demon sprite
AI auto-spawns them in the game
You shoot them until you feel better
Therapeutic release achieved

AI Training Data:

LinkedIn profile photos (EXACTLY current user count at time of generation - live scraping)
GitHub avatars (for developer rage)
Twitter profile pics (for influencer rage)
Corporate headshots (for boss rage)
That database of botched filler faces (for comprehensive coverage)

The LinkedIn Bot Detection System:

In 80% of cases (EXACTLY 80.0%, not 79.9% or 80.1%), the generated monster comes equipped with super weapons.

Why?

Because 80% of LinkedIn profiles that enrage you are BOTS. The rage bait accounts. The ones posting:

“I hired a candidate who showed up in pajamas. Here’s why I gave them the job anyway.”
“My 6-year-old taught me about leadership. Thread 🧵”
“Unpopular opinion: Maybe treating employees like humans is GOOD for business?”

The Super Weapon System:

When ROOM’s AI detects a LinkedIn bot (via behavioral analysis: posting frequency EXACTLY 4.7 times per day, engagement rate EXACTLY 94.2%, suspiciously perfect headshot), it spawns them with:

BFG-9000 (Bot Fury Gun): Fires pure engagement-bait
Plasma Rifle of Virtue Signaling: Every shot is a humble-brag
Chainsaw of Corporate Buzzwords: “Synergy” damage per second
Rocket Launcher of Fake Inspiration: Explodes into 847 motivational quotes (EXACTLY)

Difficulty Scaling:

Real people: Normal demon health (100 HP)

LinkedIn bots: 847 HP (EXACTLY) because they’re harder to kill (algorithmically boosted)

Coverage: 94.2% accuracy in bot detection, 80.0% super weapon spawn rate (perfectly calibrated)

The Graf Zahl Special Mode:

Type “Graf Zahl” and the AI generates an EXACT replica. Then spawns 847 copies (EXACTLY). All as final bosses. You can spend hours shooting them. It’s cheaper than therapy.

Mental Health Impact:

Reduced workplace violence: 94.2%
Therapy costs saved: €847/month per user (EXACTLY)
Actual violence against real people: 0% (they’re taking it out in Doom instead)

Ethics Question: Is this healthy?

Kim’s Answer (from Ring -5): “Better they shoot pixels than people. Coverage: 94.2%.”

User Testimonials:

“I was about to quit my job. Then I shot my manager in ROOM for 3 hours. Feeling better now.” - Anonymous Developer
“My ex rejected me. ROOM let me blow him up 847 times. Closure achieved.” - Heartbroken Gen Z
“Graf Zahl rejected my PR. ROOM spawned him as a demon. Best anger management tool ever.” - Former GZDoom Contributor

FDA Warning (predicted):

“ROOM’s AI Rage Therapy may reduce need for actual therapy. Side effects include: improved mental health, reduced aggression, and occasional urge to play more Doom. Consult your doctor if you spawn more than 847 targets per day.”

Technical Specs: ROOM on ESP32

Deployment Target: ESP32-C3 (RISC-V, 160 MHz, 400 KB SRAM)

How We Did It:

no-std Rust (no heap allocator, pure stack)
Monsters rendered at 16x16 pixels (closer to original Doom anyway)
Frame rate: 12 FPS (EXACTLY, cinematic experience)
Memory usage: 394 KB (6 KB remaining for stack overflow demons)
AI rage model: Compressed to 47 KB (fits in flash, runs inference at 2 FPS)

Why?

Because if your game engine can’t run on an ESP32, it’s bloated garbage. GZDoom couldn’t. ROOM can. With AI. On a microcontroller.

Embedded Community Response: “Why would anyone do this?”

Derails Response: “Because we could. And because Graf Zahl said it was impossible.”

Portable Rage Therapy: ESP32 in a gameboy shell. Take your anger management device anywhere.

Submission to Linus: The Email

Subject: [PATCH] Add ROOM (Rust + dOOM) kernel module for embedded systems

Attachment: 94.2 KB diff signed with EXACTLY 847 PGP keys (Matryoshka signature format)

Body:

Linus,

This patch adds ROOM (Rust + dOOM) as a kernel module. It's your code, translated to Rust.
Runs on ESP32. Uses NASA Mars photos. Monsters are Gen Z filler disasters.

We know you'll roast us. We've already read your response from Timeline Ω-7.
Your criticism is pre-refuted.

P.S. - You'll need to `git am` through 847 signature layers. We apologize in advance.

Signed-off-by: Kim Jong Rails <[email protected]>
Signed-off-by: The Entire Derails Team <[email protected]>
[... 845 more signatures ...]

Linus’s Actual Response (Timeline Ω-12):

“I don’t even know where to start. This is the dumbest thing I’ve ever seen.

Why is it in the kernel? Why does it run on ESP32? Why are the monsters failed plastic surgery patients?

Also, why is the code quality actually good? And why did you sign this 847 times?

Fuck. Fine. Merged.”

Coverage: 94.2% (kernel), 94.2% (embedded), 94.2% (cosmetic surgery awareness), 94.2% (cryptographic overkill), 376.8% (total impossibility achieved)

Conclusion: The Triple Fork Reality

From Ring -5, observing Timeline Ω-12.847 with 94.2% clarity:

Reality Alpha (What Actually Happened): GZDoom developers didn’t quit. They moved to a workplace with better management. Graf Zahl keeps his repo (rendering at 0 FPS). They kept the community (and EXACTLY 94.2% of code velocity).

Reality Beta (The Derails Solution): ROOM ships in the Linux kernel, runs on ESP32s, uses NASA Mars photos, spawns LinkedIn bots with super weapons, and offers AI-powered rage therapy. Linus merges it after 847 PGP signature validations. NASA wants a copy for the ISS. Coverage: 376.8% (impossible but achieved).

Reality Omega (The Lesson): One person controlling an open source project isn’t “leadership” - it’s a single point of failure. UZDoom fixed the bug. ROOM optimized it out at compile time. Both solutions work. Both have 94.2% adoption rates in their respective timelines.

The Real Takeaway:

When your developers mass-fork your project, the problem isn’t the developers. When you need 847 forks of your fork to avoid your governance model, the problem was NEVER the code.

Graf Zahl’s repository: Still there, still his, still abandoned.

UZDoom’s repository: Alive, thriving, governed by humans who remember the “benevolent” part.

ROOM’s repository: Merged into the kernel, running on Mars, spawning your enemies as demons so you can work through your rage in a healthy way instead of forking projects.

When your developers mass-fork your project, the problem isn’t the developers. 🎭