DEV Community: UnitBuilds

The 50k LOC diff

UnitBuilds — Tue, 21 Jul 2026 09:22:00 +0000

For those not keeping up, I'm developing V.E.L.O.C.I.T.Y. IDE currently. Built from the ground up to be the definitive Agentic IDE. Last week, I had a MVP, this week I'm 50k LOC deep in rust, building it out, optimizing and added 2 massive features.

a Rust-based native browser built for agentic use. I had build MCP-Lite, which was incredible, along with it's full featured counterpart, MCP-Heavy, to anyone who wants to save a dime, you'll be happy to know, I've fully ported it in... Though I am sick and tired of Chrome eating memory, so I've been hard at work building a Rust-native browser from scratch. And by from scratch, I mean no CDP, REAL from scratch, not just a chromium port.
To the people who read shelved projects, Windows Automata is making a comeback! What started as stripping the sandbox (which worked exceptionally well btw), turned into a full integration now. At this point, the IDE is turning more into an all-rounder than anything else.

And then there's a few that you probably wouldnt know about...

ORC - Orchestrative Version Control, think Git, but built for multi-agent workflows, handling discourse and merge conflicts at write-time, instead of merge time. This will serve as both the internal state-controller, as well as an optional VC integration into Github, given I imagine none of you want to leave the comfort of your caves.
V.E.L.O.C.I.T.Y. Share, my file transfer protocol that hit within 90th percentile of wire-speed, will be the backbone for ORC and will be integral to the Rust-native browser integrated into the IDE to push even more performance out of it. It will also be opened up for any file transfers you need to do securely and for backing up wherever you'd like... Just alot faster and more securely.
V.E.L.O.C.I.T.Y. MCP - the Rust-based MCP that executes in nanosecond scale, instead of milliseconds, while completely stripping JSON and Node.js. This is the core-infrastructure of the entire thing. The models use it for whatever they want to do, be it browser, WA, or development, all tooling is natively faster than any MCP you've ever used.
V.E.L.O.C.I.T.Y. OCR - A rust-based Spline driven OCR engine, will be integrated to accommodate first-pass reading of images and docs. Given it does tasks in milliseconds that take other pipelines 100+ seconds, I think it's fair to say it'll be quite useful, especially for token reduction.
V.E.L.O.C.I.T.Y. NDA - The bread and butter of it all, whether it's for the persistent SiteMap merkle root/changelog, tool definitions, or wherever else JSON would have been used, it's faster, more secure and deterministic triples, so LLMs understand it inherently.
V.E.L.O.C.I.T.Y. Remote - Secured P2P remote desktop, both in and out. That means if you're doing any kind of remote work, the combination of Remote and WA, means you can automate it. Or you know, interface with the IDE remotely on the go. All connections are driven by a secure handshake server, then transition to pure P2P, SHA 256 encrypted comms, built on the NDA standard for auditability, defensibility and reliability.

This IDE is turning into alot more than just an IDE, it's the culmination of months worth of projects, all getting slapped together into a unified product that makes life easier and cheaper. Whether it's remote IT work, Software development, or anything to do with apps or internet, it's capable and it's efficient. Zero-allocation is the mandate and it's strictly adhered to, so expect a minute fixed ram allocation. No more bloated Electron based glorified browser apps, Rust and NDA, so it's reliable, secure and effectively as close to bare-metal as you can get (until V.E.L.O.C.I.T.Y. OS is done and it gets ported to it...)

Sorry for not keeping the game series alive, though you'll be happy to know I'm about 20% of the way done with Dwarven Stronghold, think DF, except built entirely in Rust, so it actually runs decently, with a few more expansions, like the ability to switch to first/third person mode on a dwarf and take control. Never thought 100k LOC would ever be this inept... But it's getting there.

I'll post updates along the way on both as they progress. Both have grown by 150k LOC over the past week, but the 50k LOC each the past 2 days has been night and day in terms of capability.

Disclaimer: My AI is busy, so I wrote this by hand. Except the cover-image, that's NanoBanana...

Life hack?

UnitBuilds — Thu, 16 Jul 2026 22:25:13 +0000

Today I discovered something pretty cool... OpenRouter has free models! And not just baby 2b models, 550b MoE from Nvidia (Nemotron 3 Ultra), along with some really cool ones I discovered along the way, like HY3 by TenCent and North Mini Code by Cohere.

This is a game changer... We all pay subscriptions, or API fees, I built V.E.L.O.C.I.T.Y. IDE to just get a cheaper alternative, using Kimi K2.7. But then I discovered, DeepSeek is shockingly cheap. You get a REALLY competent coding model for sub $1/M tokens in and out... But this... This is the real victory. V.E.L.O.C.I.T.Y. IDE still needs some polishing, but connected with a Cloudflare API key, or OpenRouter API key, it gives you access to any model you want! And that includes free ones.

I'll post an update once it's at a state where it's 'nice' to use, so you all can give it a try.

Why is nobody talking about this???

UnitBuilds — Thu, 16 Jul 2026 13:19:23 +0000

Hy3 is free for the next 5 days? For perspective, that's a nearly 300b model that is currently free. Seriously, get on it! Wire it up via Claude Code, or whatever you use, make the most of it!

From 5,000-Parameter Failures to a 2.5D Dream: My Quest to Out-Simulate Dwarf Fortress

UnitBuilds — Mon, 13 Jul 2026 13:53:57 +0000

For years, I’ve been utterly captivated by the concept of Dwarf Fortress. If I’m being completely honest, the actual execution of the original game felt a bit brutal to play, but the sheer, uncompromising depth of its simulation nature always fascinated me.

Naturally, as a developer with a penchant for optimization and procedural systems, I decided to build my own.

Spoiler alert: I was a bit too ambitious.

🪦 The Graveyard of Good Intentions

My journey to this point is paved with ambitious, half-finished prototypes that fell victim to scope creep and performance bottlenecks:

1. 🏢 The Over-Engineered Engine

A year ago, I tried my hand at a deep world sim. I gave every single entity over 5,000 parameters. The result? Managing anything beyond 10 on-screen elements at once was inconceivably slow. I scrapped it.

2. 👥 The Procedural Identity Crisis

Next, I tried to build a Sims-style game. That quickly evolved into adding Dwarf Fortress-style lore, complex relationship webs, and eventually procedural everything. As a solo developer with limited time, it was an impossible mountain to climb.

3. 🐜 The Weekend Hackathon Divergence

Just this past weekend, I joined a dev challenge. I started building an AI Ant Terrarium. The tech stack was wild: a Solana-seeded world state, Snowflake for storage, Gemini 1.5 Flash for generating real-time ant thoughts when clicked, and ElevenLabs for turning those thoughts into spoken inner monologues. It looked incredibly cool on paper, but I hit a wall: turns out generating convincing procedural foliage is significantly harder than generating procedural terrain.

So, I decided to scale back, strip away the noise, and return to the root of my passion: Dwarf Fortress.

⚔️ Enter "Dwarven Stronghold" (100% Non-IP-Infringing)

This is a mission of pure passion. I started the codebase in JavaScript, quickly realized I needed bare-metal performance, and rewrote the entire core in Rust.

Currently, the engine sits at over 200 robust unit and integration tests—passing clean and green on every build. It's still heavily a work in progress, but the vision is clear: Dwarf Fortress has a legendary ~750k lines of code benchmark. I want to match and surpass it in every single way.

📜 The Feature Manifesto

📐 No ASCII: Ditching the retro text for a sleek, modern 2.5D isometric perspective.
🌊 Unmatched Depth: High-fidelity 3D Navier-Stokes fluid velocity, NPK soil nutrient depletion, full stress psychology, and dynamic, procedural audio.
🎙️ AI Integration: Real-time voice-over and dialogue powered by ElevenLabs, translating silent text into immersive voice-overs.
👤 True First/Third-Person Mode: Eventually, you’ll be able to drop out of God-mode, choose a perspective, and play as an actual dwarf roaming your own fortress.
🥽 VR Support: Long-term, I want full virtual reality integration.

👶 The Child Within the Machine

When I look at why I'm so obsessed with these systems, it goes back to my favorite childhood game: Black & White 2.

There was something magical about that game's natural progression—the deep trainability of your creature, and the ability to seamlessly zoom from the heavens all the way down until you could see the exact paths individual ants were walking.

I think that's exactly why I am where I am today. I have an absolute fascination with procedural generation, machine learning, extreme code optimization, and the philosophy that no depth is too deep.

🎨 Overcoming the "Asset Bottleneck"

Right now, Dwarven Stronghold runs strictly in the console. If I'm being vulnerable, part of me is terrified to build the visual layer. I'm scared that looking at it will doom it to the same fate as its predecessors—halted for eternity because I can't get the graphics to match the brilliance of the underlying simulation.

As a solo dev, hiring a massive design team to scale with a game this vast is an economic impossibility. If I can add over 1,000 new features or items to the simulation logic in a single day, how could a traditional asset pipeline ever keep up?

The solution is an automated pipeline.

By choosing a 2.5D isometric aesthetic, I can simplify asset generation. I'm building template prompts and using AI asset-generation pipelines to dynamically generate sprites. It’s not perfect yet, but it’s a scalable start—and it’s the shield that will keep this project out of the graveyard.

💖 Sustained by Passion

My goal is to open-source the project the moment the core loop is functional. Who knows? Maybe the community will find it interesting, catch the vision, and want to contribute to building this massive world.

Whenever I feel overwhelmed by the scope, I think about Tarn and Zach Adams. Dwarf Fortress was started by two brothers with a shared passion, and it became their life's work. In a bittersweet twist of fate, they eventually brought it to Steam to pay for skyrocketing cancer treatments. It’s a poignant reminder of what we do this for.

Let passion drive you, and passion will sustain you—even in your darkest of hours.

💬 Let's Discuss:

How do you handle scaling asset pipelines for deep simulation games?
What is the sweet spot between simulation realism and performance in modern engines?
Have you ever scrapped a massive project because you were too intimidated by the visual layer? Let me know in the comments!

Model Kombat: The LLM Fighting Game!

UnitBuilds — Sat, 11 Jul 2026 18:59:06 +0000

Ever wondered what would happen if the world's leading Large Language Models settled their benchmark disputes in a 2D cybercity arena?

It's easy to look at model performance on standardized benchmarks (like MMLU, MATH, or HumanEval). It is much more fun to visualize their underlying architectures, parameter scales, and hardware constraints as a retro-cyber fighting game.

So, we built Model Kombat (Mixture of Experts Edition)!

🕹️ Play Directly Here

🎮 Launch Game in Full Screen

🧬 Playable ML Concepts Explained

This isn't just a basic stick-figure fighting game. Every mechanic—from rendering complexity to the speed at which characters recover—is a direct, playable representation of real-world Large Language Model engineering.

1. 📐 Parameter Scaling vs. Render Tiers

A model's representation capacity (intelligence) scales with its parameter count. In Model Kombat, a fighter's visual complexity, joint detail, and rendering fidelity directly reflect its real-world parameter size:

Tier 1 (< 5B Parameters - Gemma 2B, Llama 3.2 3B) - Primitive Capsules: Drawn as simple, single-color flat limbs with low joint segmentation. This visualizes the limited representation capacity and coarse output resolution of small edge models.
Tier 2 (7B - 14B Parameters - Mistral 7B, Claude Haiku) - Simple Vectors: Structured as thin skeletal wireframe vectors.
Tier 3 (14B - 35B Parameters - Gemini Flash, Mixtral) - Two-Tone Vectors: Rendered as dual-color, layered vector limbs.
Tier 4 (35B - 100B Parameters - Llama 8B, Claude Sonnet) - Cyborg Shading: Rendered as detailed vector cylinders with dynamic code particle streams flowing along their limbs.
Tier 5 (> 100B Parameters - o3, GPT-4o, Claude Opus) - Quantum Vectors: Rendered as glowing vector limbs with digital matrix code particles, soft drop-shadow depth buffers, and real-time afterimage motion trails.

2. ⚡ Reasoning Tokens & KV-Cache Overcharging

Instead of arbitrary "mana" or "stamina," fighters charge a Ki bar representing internal processing cycles and Reasoning Tokens (inspired by reasoning chains like OpenAI's o-series):

Charging Ki: Simulates the time-to-first-token (TTFT) phase, generating reasoning tokens.
Limit Break: Overcharging past 100% enters a golden-outlined Limit Break state, granting high-speed afterimages and super-armor.
Context Eviction & Dizzy: If a model holds its overcharged state too long, its context window overflows. This triggers Context Eviction—draining the model's HP and placing it in a Dizzy state. This represents how context window saturation degrades model coherence and leaves it vulnerable to failure.

3. 🌀 Mixture of Experts (MoE) Routing

Sparse Mixture of Experts (MoE) models do not activate all parameters on every token; instead, a gating network routes tokens to specialized experts.

Active Experts: Native MoE models in the game (like Mixtral and DeepSeek) dynamically spawn floating indicator nodes representing active Text, Math, or Vision experts.
Routing Buffs: Landing hits routes computation to these experts, granting temporary combat buffs:
- TEXT FFN: Increases walk speed (low-latency generation).
- MATH FFN: Increases damage output (logical compute).
- VISION FFN: Expands attack hitboxes (spatial awareness).

📊 Spotlight: The AI Fighter Registry

Here is a breakdown of 6 key models featured on the ladder, explaining where they excel in real life and how their unique passives translate into combat advantages:

1. 🧠 o3 (OpenAI)

In Real Life: OpenAI's state-of-the-art reasoning model. Rather than generating text instananeously, o3 employs a reinforcement learning-driven "thinking chain" to plan, verify, and correct its logic before outputting a response. This makes it a titan in mathematics, competitive programming, and complex coding.
In-Game (Tier 5): Deep Thinking Chain passive. o3 charges its Ki at double speed (representing the model's heavy pre-response thinking cycles). This lets you quickly max out your meter, activate MoE, or release powerful special attacks.

2. 📜 Claude Opus (Anthropic)

In Real Life: Anthropic’s flagship heavy model. Opus is celebrated for its high-nuance reading comprehension, literary synthesis, and strict compliance with ethical and safety guidelines (governed by Anthropic's "Constitutional AI" framework).
In-Game (Tier 5): Constitutional Blade passive. Opus has an extended melee strike range on all punches and kicks, allowing you to control the neutral game and keep opponents at a distance—visualizing the model's massive context processing reach.

3. 🎤 Gemini Ultra (Google)

In Real Life: Google's largest multimodal model. Unlike models that stitch together separate speech-to-text and vision encoders, Gemini is built natively multi-modal from day one. It processes video, audio, and text simultaneously inside a single model architecture.
In-Game (Tier 5): Ultra Stance Shift passive. Gemini can switch between TEXT, VISION (expanded hitboxes), and AUDIO (increased speed) modality stances instantly without the standard stance-transition delay, adapting to any opponent's position on the fly.

4. ⚡ DeepSeek V3 (DeepSeek)

In Real Life: The groundbreaking open-weights model from DeepSeek. V3 utilizes Multi-Head Latent Attention (MLA) to compress Key-Value caches, dramatically reducing VRAM footprint, alongside a massive Multi-head Latent Attention routing gating network.
In-Game (Tier 4): MLA Attention passive. Compress caching translates to high combat evasion: DeepSeek V3 has a 15% chance to phase-dodge incoming projectiles completely.

5. 🗼 Mistral 7B (Mistral)

In Real Life: The legendary French open-weights model that punches far above its weight class. Mistral 7B introduced Sliding Window Attention (SWA) to the open-source community, allowing the model to handle longer context streams with minimal performance decay.
In-Game (Tier 2): Sliding Window passive. The sliding window translates to faster execution: Mistral has 10% less startup frame lag on punches and kicks, letting you land strikes before your opponent's animations can finish.

6. 📱 Llama 3.2 3B (Meta)

In Real Life: Meta’s mobile-first, edge-optimized model. Llama 3.2 3B is trained specifically for local deployment on smartphones and tablets, focusing on high efficiency, quick response times, and localized fine-tuning.
In-Game (Tier 1): Fine-Tuning passive. The model is incredibly resilient to pressure: Llama 3.2 gains +5% defense every time it successfully blocks consecutive hits, adapting to the opponent's combo string.

🏁 Beat the Machine & Share Your Score

Once you defeat all 19 opponents on the ladder, you will face the reigning champion: o3.

Can you reach the top of the ladder and claim victory? Click COPY SCORE at the end of your run and paste your stats in the comments below!

💬 Let's Discuss:

Which model is your favorite main?
What was your longest combo chain on the ladder?

UnitBuilds-CC / Model-Kombat

Arcade fighting game, which LLM will come out on top?

📟 Model Kombat (SYS_08) 🧠🥊

An Interactive, Playable Visualization of Large Language Model Constraints & Architectures

Welcome, AI engineer. Model Kombat is a retro-cyber fighting game designed to teach the mechanical constraints, architectural paradigms, and hardware limits of Large Language Models (LLMs).

In this game, 20 real-world AI models face off in a 2D arena. Every visual element, movement mechanic, and combat stance directly translates core machine learning engineering concepts (such as parameter scaling, KV-caching, Mixture of Experts, multi-modality, and alignment safety) into interactive gameplay loops.

🕹️ Play Directly Here

🎮 Model Kombat Live Web App

Git Repository: https://github.com/UnitBuilds-CC/Model-Kombat

🧠 Educational Core Concepts & Game Translations

1. 📐 Parameter Scaling vs. Render Tiers

In deep learning, a model's representation capacity (intelligence) scales with its parameter count. In Model Kombat, a fighter's visual complexity, joint detail, and rendering fidelity directly reflect its real-world parameter size:

Tier 1 (< 5B Parameters -…

View on GitHub

Disclaimer: AI was used throughout this project, it is just fitting that it would co-author with me, so special thanks to the Foundry for its tireless hours toiling away and Gemini for producing the cover image.

No game today

UnitBuilds — Fri, 10 Jul 2026 07:53:15 +0000

Sorry to everyone who was excited to see today's game. Life took a spin and I honestly just don't have the time available at the moment. The game is 99% done though. So expect it within 24h!

Hint: I took the challenge... Anyone wanna play Model Kombat?

Epoch Duel: Cyberpunk LLM Alignment Battle

UnitBuilds — Wed, 08 Jul 2026 18:57:56 +0000

Have you ever wondered how AI engineers fine-tune and align large language models? Under the hood, they run Supervised Fine-Tuning (SFT), optimize parameters using direct preference gradients (DPO), filter out low-quality pre-training corpuses (Pruning), and mitigate catastrophic drifts.

To help you visualize how LLM alignment and parameter optimization work in a highly strategic way, I built a cyberpunk card battler inspired by Gwent:

🤖 Epoch Duel: Cyberpunk LLM Alignment Battle

Play in Fullscreen Mode (if the embed sizing is tight)

🛠️ Tune Your Model Parameters

Your mission as an alignment engineer is to play optimizer cards to outscore the adversarial baseline AI across 3 training Epochs:

⚙️ Logic & Coding: Run SFT code snippets, compile theorem provers, and deploy Python scripts to build your coding benchmark scores.
📖 Language & Speech: Train on multilingual datasets and summarization corpuses to maximize reading comprehension.
🛡️ Safety & Alignment: Implement red-team safeguards, configure RLHF preference pairs, and run DPO tuning to protect your model's outputs.
⚡ regularizers & Drifts: Deploy Regularization cards like Gradient Clipping (Scorch) and Model Pruning to destroy anomalies, or exploit Anomalous Drifts to collapse the AI's rows.

🧬 Playable ML Concepts Explained

Here is how the card battle mechanics map to production machine learning pipelines:

1. ✂️ Model Pruning (Weight Compression)

In-Game: Playing the Model Pruning card triggers a glitchy dissolution animation that purges the lowest-value card from the targeted board row, cleaning up noise.

💾 The Real-World Counterpart

Model Pruning removes unimportant weights (often those closest to zero) from a trained neural network. It shrinks the memory footprint of the model, allowing it to run faster on edge devices.

⚠️ How it affects LLMs

By stripping out low-impact weights, pruning compresses models by 30-50% with minimal loss in benchmark accuracy, making deployment significantly cheaper.

2. 🔀 DPO vs RLHF (Direct Optimization vs Reward Modeling)

In-Game:
- RLHF Preference Pair: Swaps the power value of one of your units with an opponent's unit, representing human correction.
- DPO Tuning: Piles directly on your board, boosting the values of all units in its row.

🗜️ The Real-World Counterpart

RLHF (Reinforcement Learning from Human Feedback) trains a separate Reward Model to evaluate outputs. DPO (Direct Preference Optimization) bypasses the reward model entirely, mathematically optimizing the policy directly from preference pairs.

🚀 How it affects LLMs

DPO simplifies the post-training pipeline. It is computationally lightweight, more stable than PPO-based RLHF, and has become the industry standard for aligning models like Llama 3 and Mistral.

3. 📉 Catastrophic Forgetting (Anomalous Drift)

In-Game: Drifts like Catastrophic Forgetting collapse all cards in the Language row to a power rating of 1, instantly erasing rounds of SFT progress.

🔋 The Real-World Counterpart

Catastrophic Forgetting occurs when a neural network is fine-tuned on a new task, causing it to overwrite the weights that were storing information from its initial pre-training.

⚠️ How it affects LLMs

If you fine-tune an LLM exclusively on medical datasets, it may lose its general coding abilities. Developers mitigate this by mixing a small percentage of general pre-training data back into the fine-tuning dataset.

🛠️ The Under-the-Hood Engineering Journey

Building a Gwent-style tabletop card game that fits inside a Dev.to embed presented some unique web design challenges:

1. Asynchronous Animation Queues in Vanilla JS

To make card destructions (like Scorch or Pruning) visual, we couldn't just delete the card object instantly.

The Solution: We trigger a CSS .prune-animation class (a neon-pink glitchy disintegration), block turn progression using an isAnimating lock, and delay database modification by exactly 600ms to synchronize state with the screen:

function triggerPruning() {
    isAnimating = true;

    // Find lowest card on the board
    const targets = getLowestPowerCards();
    targets.forEach(card => {
        const el = document.getElementById(`card-${card.uniqueId}`);
        if (el) el.classList.add("prune-animation");
    });

    setTimeout(() => {
        // Splice from database
        removeCardsFromBoard(targets);
        isAnimating = false;
        render();
        endTurn();
    }, 600);
}

2. Responsive Viewport-Height (vh) Scaling for 500x600 embeds

Standard pixel dimensions cause the 6-row Gwent board to squish and overlap inside small embeds.

The Solution: We refactored all layouts, cards, and font sizes to use relative Viewport Height (vh) units. Tying sizes to the screen height guarantees that the card proportions remain perfect and fit without any clipping on any resolution:

.card-item {
    width: 11vh;
    height: 15vh;
    border-radius: 0.8vh;
    padding: 0.8vh;
}

.board-row .card-item {
    width: 6.2vh;
    height: 8.5vh;
}

.board-row {
    min-height: 9.5vh;
}

💬 Let's Discuss:

What is your high score fine-tuning your candidate model?
Have you managed to bait the AI into passing early by playing a Spy card?
Which alignment strategy did you find more effective: SFT raw power stacking or anomaly regularization?

UnitBuilds-CC / EPOCH-DUEL

Card game to teach players about LLMs

Epoch Duel: Cyberpunk LLM Alignment Battle 🤖

An interactive cyberpunk TCG card battler built in vanilla HTML/CSS/JS. Players step into the role of an AI alignment engineer, fine-tuning their candidate models and aligning weights against adversarial baseline models across 3 training Epoch rounds.

The game is designed to run standalone or scale fluidly inside a compact 500x600 Dev.to iframe embed.

🎮 Features

🃏 Witcher 3 Gwent scoring interface: Circular neon row badges and large player/AI total score circles on the left, alongside pass indicator ribbons.
📦 50 Unique ML-Themed Cards: Build coding capacity with SFT Code Snippets, deploy Red-Team Jailbreak spies to draw cards, double parameters using LoRA Adapters, or optimize weight adjustments using DPO Tuning and AdamW Optimizers.
📉 Anomalous Drifts & Regularizers: Navigate drifts like Catastrophic Forgetting and Exploding Gradients which collapse rows to Power 1, or regularize with Gradient Clipping (Scorch) and Model Pruning…

View on GitHub

Vector Strike: Semantic Search Database Defender

UnitBuilds — Tue, 07 Jul 2026 21:31:27 +0000

Have you ever wondered how vector databases like Pinecone, Milvus, Qdrant, or pgvector search through billions of high-dimensional documents in milliseconds? Under the hood, they map semantic concepts into dense numerical vectors, calculate multidimensional cosine similarity angles, and traverse proximity graphs to locate nearest neighbors without scanning the entire database.

To help you visualize how vector databases and embeddings actually operate, I built a retro-vector arcade game:

🛰️ Vector Strike: Database Defender

Play in Fullscreen Mode (if the embed sizing is tight)

🛠️ Choose Your Database Optimizations

Your mission as a Vector Database (VDB) administrator is to configure your query settings and index structures to defend your index nodes:

📏 Similarity Threshold (τ): Tweak the match threshold slider. High thresholds require near-identical semantic matches but protect your index, whereas lower thresholds act like a splash-damage laser but risk matching incorrect clusters.
🪐 Embedding Dimensions (2D $\rightarrow$ 8D $\rightarrow$ 32D): Higher dimensions isolate categories and guarantee precise hits. Lowering dimensions collapses the projection space, causing spatial overlap that results in false deflections and friendly-fire query failures.
⚡ Proximity Indexing (Flat Scan $\rightarrow$ HNSW Graph):
- Flat Scan: Runs a brute-force linear search over all targets. It causes computation latency spikes as more query objects arrive.
- HNSW (Hierarchical Navigable Small World): Dynamically builds proximity links between adjacent node targets. The turret traverses vectors along the nearest-neighbor graph, snap-locking onto targets with zero lookup latency.

🧬 Playable ML Concepts Explained

Here is how the arcade mechanics map to production vector databases:

1. 🔀 Multidimensional Projections (Dimension collapse)

In-Game: You can toggle between 2D, 8D, and 32D space. In 32D space, the categories are cleanly separated. In 2D space, the database collapses, and you'll find space rockets getting deflected by vehicle lasers because they overlap on the collapsed axes.

💾 The Real-World Counterpart

Embeddings map textual semantics into high-dimensional space (e.g., 1536 dimensions for OpenAI's text-embedding-3-small). Reducing dimensionality (via PCA or projection) squeezes distinct concepts onto similar planes.

⚠️ How it affects VDBs

When dimensions collapse, semantic resolution is lost. A vector database will begin returning false matches because unrelated words map to nearby coordinates on the truncated plane.

2. 🛰️ Cosine Similarity Thresholds (The Match Laser)

In-Game: When you fire a category query (like FOOD or SPACE), the laser calculates the similarity value against targets it intersects. If the dot product similarity is below $\tau$, the laser deflects.

🗜️ The Real-World Counterpart

Cosine similarity measures the cosine of the angle between two multi-dimensional vectors. It is a scale-invariant metric commonly used to check how close two documents are in embedding space.

⚠️ How it affects VDBs

Production search pipelines filter results based on a minimum similarity score threshold. Setting the threshold too high returns zero results, while setting it too low returns irrelevant noise.

3. 🕸️ HNSW Graph Traversals (Nearest-Neighbor Search)

In-Game: In HNSW mode, you see thin green link lines draw between targets. Firing the laser instantly traces a route along the lines, hopping from node to node to hit the target instantly rather than flying through the screen linearly.

🔋 The Real-World Counterpart

HNSW (Hierarchical Navigable Small World) structures vectors into multi-layer proximity graphs. Instead of comparing the query vector against every single vector in the database, the search navigates the graph towards the closest neighbors.

🚀 How it affects VDBs

By avoiding exhaustive linear scanning, HNSW slashes search latency from $O(N)$ to logarithmic time, allowing databases to query millions of records in microseconds.

🛠️ The Under-the-Hood Engineering Journey

Creating a vector-math arcade game presented some unique engineering tasks:

1. Simulating Dimensionality Collapse in JS

To let players experience "Dimensional Collapse" in real-time, we precompute a 32-dimensional coordinate matrix for all words.

The Solution: When the player changes the dimension setting, the engine dynamically slices the vector coordinates vec.slice(0, activeDim) and normalizes the sliced vectors before running the dot product:

function getSlicedSimilarity(vecA, vecB, dims) {
    const a = vecA.slice(0, dims);
    const b = vecB.slice(0, dims);
    let dot = 0; let magA = 0; let magB = 0;
    for (let i = 0; i < dims; i++) {
        dot += a[i] * b[i];
        magA += a[i] * a[i];
        magB += b[i] * b[i];
    }
    if (magA === 0 || magB === 0) return 0;
    return dot / (Math.sqrt(magA) * Math.sqrt(magB));
}

2. High-Performance HNSW Traversal Visualization

To visualize greedy graph routing on canvas, we calculate proximity paths dynamically using a distance heap. When HNSW mode is active, the laser tracks the step-by-step hops along target coordinates, firing audio triggers at each step.

Click to see the Greedy HNSW Traversal path generation

function calculateHNSWPath(startX, startY, targetNode) {
    if (targets.length === 0) return [];

    // Find closest target to shooter (entry point)
    let entryNode = targets[0];
    let minDist = Math.hypot(startX - entryNode.x, startY - entryNode.y);
    targets.forEach(t => {
        const d = Math.hypot(startX - t.x, startY - t.y);
        if (d < minDist) {
            minDist = d;
            entryNode = t;
        }
    });

    const path = [entryNode];
    let curr = entryNode;
    const visited = new Set([curr]);

    // Greedy routing towards targetNode along links
    for (let step = 0; step < 10; step++) {
        if (curr === targetNode) break;
        // Find links from current node
        const links = hnswLinks.filter(l => l.from === curr || l.to === curr);
        let nextNode = null;
        let bestDist = Math.hypot(curr.x - targetNode.x, curr.y - targetNode.y);

        links.forEach(l => {
            const neighbor = l.from === curr ? l.to : l.from;
            if (!visited.has(neighbor)) {
                const d = Math.hypot(neighbor.x - targetNode.x, neighbor.y - targetNode.y);
                if (d < bestDist) {
                    bestDist = d;
                    nextNode = neighbor;
                }
            }
        });

        if (nextNode) {
            curr = nextNode;
            visited.add(curr);
            path.push(curr);
        } else {
            // Jump directly if stuck
            path.push(targetNode);
            break;
        }
    }
    return path;
}

💬 Let's Discuss:

What is your high score defending the Vector Database?
Did you notice how 2D mode causes spaceships and rockets to deflect matching vectors due to axis collapse?
Which index type did you find more visually pleasing: Flat or HNSW traversal paths?

UnitBuilds-CC / VECTOR-STRIKE

Asteroids inspired game to teach players about Graph DBs for LLMs

🛰️ Vector Strike: Semantic Search Database Defender

An educational retro-oscilloscope vector graphics game that maps database defense mechanics directly to vector embeddings, cosine similarity thresholds, and vector graph index traversal (Flat Scan vs. HNSW Graph Routing).

👉 Play the Live Demo here!

🎮 The Concept

In Vector Strike, you play as a Vector Database administrator defending your vector database partitions against incoming query concepts (represented by descending labeled target clusters).

To eliminate targets, you press keys 1-5 to instantly fire the matching category laser and match target embeddings using Cosine Similarity:

Embedding Accuracy: Toggle dimensionality (2D, 8D, 32D). Lower dimensions (2D) collapse projection spaces and travel super fast, but cause spatial collisions and false deflections. Higher dimensions (32D) travel slower, but accurately filter complex overlap concepts.
Match Tolerance (τ): Adjust your matching threshold slider. Tighten it for score multipliers on exact matches, or loosen…

View on GitHub

PagedAttention: Navigating VRAM Fragmentation

UnitBuilds — Mon, 06 Jul 2026 13:19:41 +0000

Have you ever wondered how high-performance LLM deployment frameworks like vLLM, TensorRT-LLM, or Hugging Face TGI actually optimize model serving? While you wait for tokens to stream into your chat window, the infrastructure under the hood is executing a fragile balancing act: scheduling prompt pre-computation, paging memory segments, verifying speculative token chains, and dodging system-stalling bottleneck crashes.

To teach you how LLMs manage GPU memory under high concurrent loads, I built an interactive Tetris-style puzzle game:

🧱 PagedAttention: VRAM Tetris

Play in Fullscreen Mode (if the embed sizing is tight)

🛠️ Choose Your Allocation Mode

Your journey as a memory scheduler is split into two distinct memory allocation modes:

🏢 Contiguous Mode (Easy/Vanilla): Stacking falling token sequence blocks (Tetrominos) into solid rows. Any gaps you leave behind are trapped, creating unusable External Memory Fragmentation that blocks new incoming allocations.
🔋 Paged Mode (PagedAttention - Hard): Play with paged virtualization. Pressing Shift or P triggers a Page Split, shattering the active falling block into individual 1x1 memory pages that cascade down independently to fill any available fragmentation holes below.

🧬 Playable ML Concepts Explained

This isn't just standard Tetris—every shape, block placement, and allocation rule represents a real-world concept in modern machine learning infrastructure. Here is how the in-game mechanics map directly to how large language models allocate GPU memory:

1. 💾 Memory Allocation & Contiguity (Standard Stacking)

In-Game: You must rotate and slide falling token block shapes to pack them together contiguously. Complete horizontal rows of memory blocks represent completed inference requests, which are garbage-collected to free up VRAM.

💾 The Real-World Counterpart

In standard serving systems, key-value representations (KV-Cache) of a sequence are allocated in a contiguous physical VRAM buffer.

⚠️ How it affects LLMs

Because the system doesn't know in advance how many tokens a query will generate, it must pre-allocate a contiguous space equal to the maximum sequence length. This pre-allocation locks up massive amounts of memory that may never be used, restricting concurrency.

2. 🗜️ External Memory Fragmentation (The Stacking Gaps)

In-Game: Leaving empty spaces under your placed blocks represents external fragmentation. If VRAM fill spikes or blocks stack to the top, the engine crashes, throwing a CUDA OUT OF MEMORY (OOM) error.

🗜️ The Real-World Counterpart

Over time, as different requests finish at different times, the physical VRAM becomes cluttered with small, non-contiguous "gaps" of unallocated memory.

⚠️ How it affects LLMs

Even if you have 10 GB of total free VRAM, if it is split into 100 scattered megabyte-sized gaps, a new incoming request requiring a contiguous 1 GB block will fail—triggering a CUDA OOM crash because the allocator cannot defragment VRAM dynamically.

3. 🔋 PagedAttention Virtualization (The Page Split)

In-Game: In Paged Mode, triggering a Page Split shatters the falling shape into individual 1x1 blocks that automatically drop down to seek out and fill the smallest hidden gaps in the memory grid.

🔋 The Real-World Counterpart

Inspired by operating system virtual memory paging, PagedAttention (pioneered by vLLM) partitions the KV-cache of active sequences into logical blocks mapped to virtual tables.

🚀 How it affects LLMs

By breaking the requirement of physical contiguity, the engine can write incoming token keys and values into any free physical slots on the graphics card, no matter how scattered. This eliminates 96% of memory waste, allowing up to 4x higher serving concurrency on the same hardware.

🛠️ The Under-the-Hood Engineering Journey

Creating an educational puzzle game designed for embedded platforms presented some fascinating web development challenges:

1. Optimizing for the 600px Embed Limit

Dev.to embeds are capped at a strict maximum height of 600px. Fitting a complex tycoon dashboard with side panels, scoreboards, next-piece canvases, and a 20-row Tetris grid inside 600px required serious spatial compression.

The Solution: We shrank the cell block size (BLOCK_SIZE) to 22px (yielding a 440px canvas height), converted the left panel stats list into a compact 2x2 grid, resized preview boxes to 70px, and relocated the system logs console from a horizontal footer directly into the left sidebar. The final layout fits completely inside exactly 580px, preventing vertical clipping.

2. Physics of the Paged Cascading Split

Splitting a rigid grid structure into individual falling particles in real-time required careful synchronization.

The Solution: When the split is triggered, the engine parses the active Tetromino shape, decomposes it into coordinate objects relative to the grid columns, calculates the lowest-available free cell index per column, and translates each block to its destination slot before recalculating line-clear sweeps.

Click to see the Page Split Javascript logic

// --- Special Mechanic: Paged Memory Split ---
function executePageSplit() {
    if (abilityCharge < 100) {
        addSystemLog("PagedAttention Split not fully charged yet!", "warning");
        SOUNDS.warning();
        return;
    }

    SOUNDS.split();
    addSystemLog(`Executing PagedAttention: Splitting ${currentPiece.name} into virtual pages...`, "info");

    // Get all filled cells of the falling piece
    const pages = [];
    for (let r = 0; r < currentPiece.shape.length; r++) {
        for (let c = 0; c < currentPiece.shape[r].length; c++) {
            if (currentPiece.shape[r][c]) {
                pages.push({
                    x: currentPiece.x + c,
                    y: currentPiece.y + r,
                    color: currentPiece.color
                });
            }
        }
    }

    // Drop each page individually down its column to the lowest free cell
    pages.forEach(page => {
        let lowestY = page.y;
        while (lowestY + 1 < ROWS && !grid[lowestY + 1][page.x]) {
            lowestY++;
        }
        if (lowestY >= 0) {
            grid[lowestY][page.x] = page.color;
        }
    });

    abilityCharge = 0; // Consume charge
    clearMemoryLines();
    spawnPiece();
}

💬 Let's Discuss:

What is your high score in Paged Mode utilizing the Page Split ability?
Did you notice how quickly a contiguous stack triggers a CUDA OOM compared to a paged system?
How does VRAM Tetris change your perspective on memory allocation bottlenecks?

UnitBuilds-CC / PAGED-ATTENTION

A Tetris inspired game to teach how LLMs use VRAM

🧱 PagedAttention: VRAM Memory Allocation Tetris

An educational retro-cyberpunk Tetris-style simulator that maps classic block-packing gameplay directly to GPU memory allocation, external memory fragmentation, and virtual paging concepts.

👉 Play the Live Demo here! (Will be updated after deploy)

🎮 The Concept

In PagedAttention Tetris, you play as a GPU memory scheduler. Incoming requests of varying token sizes (represented by falling Tetris shapes) must be allocated in the GPU's memory registers. Gaps left behind represent External Memory Fragmentation. If memory becomes too cluttered and blocks stack to the top, you trigger a CUDA Out of Memory (OOM) crash.

Playable Memory Allocation Engines:

🏢 Contiguous Mode: Falling block sequences remain solid. If gaps are left underneath, they cannot be filled, causing fragmentation and system bloat.
🔋 Paged Mode (PagedAttention): Pressing Shift or P triggers a Page Split. The active falling block shatters into individual 1x1 block pages that…

View on GitHub

Token Factory: Understanding the pipeline

UnitBuilds — Sun, 05 Jul 2026 19:24:11 +0000

To teach you how LLMs are deployed, optimized, and served under high concurrent loads, I built an interactive factory simulation game:

🏭 Inference Pipeline Tycoon

Play in Fullscreen Mode (if the embed sizing is tight)

🛠️ Choose Your Terminal Level

Your journey as an infrastructure architect is split into three distinct serving terminals, each introducing advanced optimizations:

⚡ Level 1: Prefill & Decode Basics (Easy): Route prompts from the input queue into a Prefill Core to compute key-value activations, then link them to a Decode Core to generate autoregressive token streams. Target: 30.0 TPS.
🔋 Level 2: KV-Cache Paged Memory (Medium): Process large context windows under tight VRAM constraints. You must connect virtual paging allocators to compress memory allocations and prevent CUDA Out-of-Memory crashes. Target: 60.0 TPS on a restricted 3072 MB VRAM card.
🚀 Level 3: Speculative Speedup (Hard): Autoregressive decode is too slow to hit the client quota. You must deploy lightweight draft models and validation gates to generate and verify 3 tokens in parallel per step. Target: 120.0 TPS.

🧬 Playable ML Concepts Explained

This isn't just a basic puzzle game—every component, routing direction, and memory rule represents a real-world concept in modern machine learning infrastructure. Here is how the in-game mechanics map directly to how large language models are optimized and served in production:

1. 🎯 Prefill vs. Decode (The Sequential Pipeline)

In-Game: You must place a Prefill Core (PREF) to process green prompt packets into magenta activation vectors, then route them to a Decode Core (DECO) to begin autoregressive sequence token generation.
The Real-World Counterpart: LLM serving divides inference into two phases:
- Prefill: Processes the user's prompt tokens in parallel, generating the initial Key-Value (KV) attention matrices.
- Decode: Generates one token at a time sequentially. It takes the newly generated token and appends it to the history, running a full forward pass of the model per token.
How it affects LLMs: Because decode is bound by memory bandwidth (requiring reloading billions of model weights for every single token predicted), it is much slower than prefill. Placing cores far apart adds routing latency. Clumping them together represents standard hardware co-location to maximize throughput.

2. 🔋 KV-Cache Paging (vLLM Page Allocator)

In-Game: Placing Page Allocators (vLLM) immediately adjacent to Prefill and Decode cores automatically compresses their VRAM cache footprint by 40%.
The Real-World Counterpart: Key-Value caching saves past token representations in GPU VRAM so they don't have to be recalculated. However, dynamic user prompt sizes cause severe memory fragmentation, leading to premature allocation limits and CUDA Out of Memory failures.
How it affects LLMs: Modern engines implement PagedAttention (popularized by vLLM). By allocating virtual memory tables and partitioning the KV-cache into logical pages (similar to operating system paging), engines eliminate fragmentation and cache waste, multiplying GPU serving capacity by up to 4x.

3. 🚀 Speculative Decoding (Drafter & Validation Gates)

In-Game: Placing a Draft Model (DRAF) adjacent to a Decode Core allows it to generate a draft of 3 speculative tokens per step. These drafts must pass through a Validation Gate (VALI) to verify them before reaching the output sink.
The Real-World Counterpart: Speculative decoding pairs a massive, accurate target LLM with a tiny, lightweight draft model that runs extremely fast. The draft model speculatively generates a sequence of $K$ tokens. The target model then verifies all $K$ tokens in parallel in a single forward pass.
How it affects LLMs: Since the target model can verify multiple tokens in the same amount of time it takes to generate one token autoregressively, speculative decoding dramatically reduces latency. If the draft matches, we gain $K$ tokens in a single step; if it misses, we roll back and regenerate.

🛠️ The Under-the-Hood Engineering Journey

Building a high-throughput simulation game with canvas rendering and real-time audio synthesis presented some fascinating web development challenges:

1. Fixed Timestep Physics (Decoupling FPS from TPS)

When rendering hundreds of active token particles simultaneously, canvas draw overhead can drop the browser's render rate to 15–20 FPS on older devices. In early drafts, this slowed down the clock, capping the throughput at 66 TPS even with optimized pipelines.

The Solution: We implemented a Fixed Timestep Accumulator (60 ticks/sec). Even if the browser's rendering frame rate lags, the accumulator catches up by running multiple simulation ticks per frame, keeping the throughput (TPS) metrics completely accurate to real wall-clock time.

2. Resolving Conduit Queue Propagation

Conduits initially processed one packet per tile per tick. When Speculative validation released batches of 3 tokens at once, the conduits created queue pile-ups, capping throughput at a hard limit. Changing conduit propagation to a while loop allowed wire tiles to behave like physical conductors, transferring all arrived tokens in the same frame.

💬 Let's Discuss:

What was your highest throughput layout on Level 3?
Did you manage to fit vLLM Page Allocators and Speculative Drafters cleanly on Level 3's grid without OOM?
What architectural combination did you find most effective?

UnitBuilds-CC / LLMs-are-Demented

An educational crossword game to learn about LLMs

📟 The Gating Crisis: Sparse MoE Router Simulator 🧠⚡

Part of the UnitBuilds CC Playgrounds Suite

Welcome, neural engineer. You have been put in charge of the Gating Network (Router) for a running Mixture of Experts (MoE) Large Language Model.

Your task is to route incoming multi-modal token streams ([T] Text, [M] Math, [V] Vision, [A] Audio, and [C] Code) to specialized Feed-Forward Network (FFN) experts in real-time. Since this is a Top-2 Routing network, you must dispatch every token to exactly two experts before it reaches the eviction threshold.

If you route tokens incorrectly, the model's output quality degrades into perplexity collapse. If you overload any individual expert beyond its queue limit, the system experiences Capacity Drops (loss of data).

🕹️ Game Mechanics (How to Play)

⌨️ Hotkey Routing: Use numbers 1 to 8 (or 1 to 4 in simplified mode) to…

View on GitHub

GPU Survivors: Can You Survive a 1T Parameter Inference Run?

UnitBuilds — Sat, 04 Jul 2026 11:04:36 +0000

Ever wondered what a GPU goes through during a massive language model inference run? While you type a query and wait for tokens, the silicon under the hood is holding together a fragile house of cards: balancing context window limits, scheduling activations, managing weights, and evading malicious adversarial attacks.

To teach you how LLMs behave (and fall apart) under load, I built an interactive game:

⚡ GPU Survivors: Latent Space Hell

Play in Fullscreen Mode (if the embed sizing is tight)

🛠️ Choose Your Hardware Preset

Before initiating your run, choose your difficulty configuration (each represented by a unique retro pixel chip sprite and custom parameters):

🏢 Enterprise API (Easy): Spawns with 6 Core Integrity Lives, fast speed (2.8), boosted damage, and a wide collection window. You get +25% XP gains and start with both the Attention Beam and the Softmax Aura active.
💻 Consumer GPU (Medium): Spawns with 5 Core Lives, normal speed (2.5), standard damage, and standard 100% XP gains. Starts with the Attention Beam active.
🍞 Smart Toaster (Hard): Edge inference on a kitchen appliance. Spawns with only 4 Core Lives, slow speed (2.1), reduced damage, and a -20% XP penalty. Starts with a single Attention head active.

🧬 Playable ML Concepts Explained

This isn't just a homage to Vampire Survivors—every upgrade, weapon, and enemy represents a real-world concept in modern machine learning. Here is how the in-game mechanics map directly to how Large Language Models operate, fail, and optimize in production:

1. 🎯 Cosine Similarity (Piercing Vector Arrows)

In-Game: Fires piercing vector arrows in a fan. Moving in the direction of the fire boosts damage by +60% (aligned vectors), while moving backward deals standard damage.
The Real-World Counterpart: Text token embeddings are high-dimensional vectors. Cosine similarity calculates the cosine of the angle between two vectors to determine their semantic closeness: $$\text{Similarity} = \frac{\mathbf{A} \cdot \mathbf{B}}{|\mathbf{A}| |\mathbf{B}|}$$
How it affects LLMs: This is the mathematical core behind Retrieval-Augmented Generation (RAG), semantic database search, and Self-Attention mechanisms. When the user prompt query vector aligns closely with a key vector in the model, the dot product spikes—assigning a massive attention score to pull that context forward.

2. 🗜️ Quantization (Passive Cooldown Upgrade)

In-Game: Increases weapon firing rate (cooldown speed) at the cost of slightly lower base damage.
The Real-World Counterpart: Quantization converts model weights and activation outputs from high-precision floating-point formats (like FP32 or FP16) to lower-precision integers (like INT8 or INT4).
How it affects LLMs: Scaling massive models requires optimization. Quantization drastically reduces VRAM requirements, allowing a 70B parameter model that normally requires enterprise GPUs to run on local laptops. However, rounding values to a coarser scale introduces quantization noise, which slightly degrades the model's perplexity (leading to minor performance loss or "damage").

3. 🧬 Weight Decay (Hitbox Shrinking)

In-Game: L2 regularization reduces the physical size of the player's core hitbox, making it harder for incoming token anomalies to land a hit.
The Real-World Counterpart: L2 regularization penalizes large weights by adding a fraction of the squared magnitudes to the training loss function: $$L_{\text{regularized}} = L_{\text{base}} + \lambda \sum_{i} w_i^2$$
How it affects LLMs: During pre-training, weight decay restrains model weights from growing too large. Keeping weights bounded makes the model less sensitive to minor noise in the user prompt, improving generalization and reducing hallucinations. The resulting "smaller footprint of instability" translates directly in-game to a smaller, more regularized core hitbox.

4. 🧬 Node Dropout (Ignore Hit Check)

In-Game: Grants a flat +8% chance per level to completely ignore or evade incoming damage.
The Real-World Counterpart: Dropout is a regularization technique where a random percentage of neural nodes (activations) are zeroed out at each training step.
How it affects LLMs: By shutting down random neural pathways during training, the model is forced to learn redundant, robust representations rather than relying on a single, fragile sequence of nodes. This prevents the model from overfitting to its training dataset, allowing it to adapt cleanly to unseen prompt distributions at inference time (represented in-game by dropping nodes to safely "evade" bad data).

5. 🔒 Adversarial Split (Jailbreaks)

In-Game: High-health golden locks. When destroyed, they split into 3 fast-moving Adversarial Tokens that lock onto the player.
The Real-World Counterpart: A jailbreak is a targeted input sequence designed to bypass the safety alignments (RLHF/DPO) of a model, prompting it to output restricted content.
How it affects LLMs: Jailbreaks exploit the fact that LLMs treat data and instructions identically. Once a malicious prompt slips past the model's safety guardrails, it triggers an autoregressive cascade of toxic outputs. In-game, this is represented by the sudden explosion of fast-moving adversarial tokens that quickly clutter your active context window.

6. ⚖️ The Horizontal Data Bias (Skewing Fields)

In-Game: Stepping inside the green Data Bias radius skews your movement coordinate vectors, dragging you in the direction the arrow points.
The Real-World Counterpart: Data bias occurs when training corpora contain unbalanced representations, stereotypes, or uneven historical distributions.
How it affects LLMs: LLMs reflect their training datasets. If the data is biased, the output token probability distribution is heavily skewed toward those prejudices. For example, if a model's training data repeatedly associates a profession with a specific demographic, it will struggle to generate neutral completions. This creates a constant, invisible drift that biases output completions, directly mirroring the in-game dragging force.

7. 💾 KV-Cache (The Protective Orbitals)

In-Game: Key-Value caching blocks rotate around the core, absorbing hits.
The Real-World Counterpart: The KV-Cache saves the key-value representations of past tokens in GPU VRAM so they don't have to be recalculated at every token prediction step.
How it affects LLMs: Auto-regressive generation predicts one word at a time, feeding its own output back as input. Without a KV-cache, the model would have to compute attention scores across the entire history for every single token generated, causing latency to scale quadratically. The KV-cache saves computation but consumes huge amounts of memory, restricting user concurrency.

💀 The 15-Minute Thermal Runaway (Endgame)

At exactly 15:00, all standard enemies are swept away, and the unkillable red boss Hardware Degradation arrives. You cannot harm it.

💬 Let's Discuss:

What was your longest survival time on Smart Toaster difficulty?
What architectural combination (e.g., Quantization speed boosts + Cosine Similarity) did you find most effective?

UnitBuilds-CC / GPU-SURVIVORS

Homage to Vampire Survivors, as an educational game to teach players about LLMs.

GPU Survivors: Latent Space Hell 📟⚡

Can you survive a 1T parameter inference run?

Welcome to GPU Survivors, an interactive 2D retro action-roguelike built to simulate the architectural limits, failure modes, and optimization hyperparameters of running a Large Language Model under load.

🎮 The Scenario

In the digital deep, bad data and chaotic vectors threaten inference stability. You are a GPU Core initializing a new language model. Survive the endless incoming waves of training loads (OOD outliers, prompt injections, and data biases), gather FLOPs (XP), and scale your architecture to 1T parameters!

⌨️ Controls

Move: Use WASD or Arrow Keys.
Pause: Press Escape or P to pause the run, resume, or exit.
Attack: Auto-targeted active weapons fire queries at the nearest token anomalies.

🛠️ Hardware Presets (Difficulty Modes)

Select your inference endpoint difficulty at startup:

🏢 ENTERPRISE API (H100 Cluster) — Easy
- Stats: 6 Core Integrity…

View on GitHub

To anyone who enjoyed the games series, tomorrow is gunna be a fun 1. Anyone like Vampire Survivor? (Hint)

UnitBuilds — Fri, 03 Jul 2026 21:46:54 +0000