The Bullet Holes That Quietly Disappear

You shoot a wall. A ragged impact crater appears, plaster dust and all. You shoot it seventeen more times, back away to reload, and when you glance at the wall again, the first few holes are simply gone. Not faded. Not smeared. Gone, as if you never fired.

This isn't a bug. It's a memory management system doing its job, and it's more deliberate than most players ever suspect.

Surface decals, the projected textures that represent bullet holes, scorch marks, blood splatter, tire tracks, explosion burns, are one of the most memory-hungry cosmetic features in real-time rendering. Each one is a small texture, a mesh or projection matrix, and a slot in the renderer's draw list. Stack up a few hundred in a chaotic firefight and you're looking at serious VRAM and CPU overhead. So every major engine sets a budget: a hard ceiling on how many decals can exist at once. When you hit that ceiling, something has to go. The question is what, and the answer is more interesting than a simple timer.

The Four Rules Engines Use to Decide

Most modern engines, including Unreal Engine 5 and Unity's HDRP pipeline, use some version of a priority queue for decal eviction. Think of it like a bouncer working from a clipboard with exactly four criteria, applied roughly in this order.

Age. The oldest decal goes first. This is the baseline rule, sometimes called FIFO (first in, first out), and it's the one responsible for those vanishing bullet holes. A decal placed four minutes ago in a room you've already left has almost no perceptual value. Removing it costs you nothing you'll notice. Engines track a timestamp or frame-count marker for each decal instance and sort the eviction queue accordingly.

Distance from the camera. A scorch mark thirty metres behind you, outside your field of view, ranks lower than one you're staring at directly. Some engines combine this with frustum culling, so decals outside the camera's view cone are already invisible and therefore prime candidates for silent removal, even if they're relatively young.

Surface type and visual importance. Not all decals are equal. Blood on a floor reads louder than a faint grease smear on a wall. Some engines let designers tag decal types with a priority weight. A scripted, story-critical burn mark, say the scorched outline of a body in a cutscene room, can be flagged as permanent and excluded from the eviction pool entirely. Gameplay-generated decals from player weapons usually sit at the lowest priority. As they should.

Overlap and redundancy. If six bullet holes cluster within a thirty-centimetre radius, the system may treat them as a group and cull the oldest members first. The visual result looks identical: a pocked surface. But the decal count drops without the player perceiving any loss. Id Software's work on the DOOM (2016) engine leaned heavily on this spatial clustering logic to keep arena floors visually rich without the count ballooning.

A Scenario That Shows the Maths

Picture a mid-range PC running a shooter at high settings. The engine's decal budget is set to 256 simultaneous instances, a common ceiling in shipped titles. A player tears through a corridor, firing constantly, and triggers an explosion. Forty seconds in, they've generated 180 decals. They enter a large arena. A five-minute firefight begins.

By the two-minute mark, the total hits 256. The eviction system wakes up. The first decals placed in that original corridor are now over three minutes old and thirty metres behind the camera. They go first, silently, in batches of eight. The player never looks back. The arena floor stays visually consistent. The budget holds.

Now run the same scenario on a console with a tighter budget of 128 decals. Eviction starts much sooner, roughly ninety seconds in. If the player backtracks quickly, they might actually catch the first holes disappearing. This is why console and PC versions of the same game can feel subtly different in ways that never show up in resolution comparisons. It's not the pixels. It's the memory.

What People Consistently Misread About This

The common assumption is that decals disappear on a timer, a fixed lifespan baked into each instance. Some engines do use timers as a secondary mechanism, particularly for decals on dynamic objects like moving vehicles, where the projection math gets expensive fast. But the primary driver in most engines isn't time. It's pressure.

Decals survive indefinitely if the budget isn't stressed. Load into an empty level, shoot a hundred holes in one wall, walk away. Come back ten minutes later. They'll all still be there, because nothing forced an eviction.

The timer misconception makes the system sound dumber than it is. It's actually running a continuous cost-benefit calculation, the kind of quiet arithmetic that keeps the whole thing from falling apart. Age is a proxy for value, not a clock. Distance is a proxy for visibility. The engine isn't forgetting your bullet holes like a goldfish. It's deciding they're not worth remembering anymore.

Found a level where decals seem to last unusually long? You're probably in a low-population scene with headroom to spare.

The Budget Is a Design Choice, Not a Hardware Limit

This is the part that surprises people. The decal ceiling isn't usually set by what the hardware can physically hold. Modern GPUs can handle far more simultaneous texture projections than most games allow. The ceiling is set by the performance contract the team has signed with themselves: stable frame time, predictable memory allocation, no surprise spikes.

Raising the budget from 256 to 512 decals might cost two to four milliseconds per frame in a busy scene. That's the difference between a locked 60fps and a stuttering 55fps. Most developers won't trade that for cosmetic gore, and honestly, they're right not to.

So the next time a wall forgets you were there, consider what actually happened. The engine weighed age against visibility against redundancy, ran the numbers, and quietly cleaned house. The bullet hole was always borrowing time from a fixed account. The account ran dry, and the engine moved on without you.