Contents
Why the shape was baked ahead of timeReading baked smoke cheaplyPutting smoke in a boxSkipping empty spaceFour bits are enoughLight, every frame450 volumesReferencesSay Bond throws his smoke gadget in front of a corridor held by a guard. Grey smoke swells up and fills the corridor; the side that catches the light is bright, and the inside of the mass sinks into darkness. It looks less like a flat picture than a mass that really fills the space, and the guard cannot see Bond on the other side.

A scene image from the official 007 First Light page. Image: IO Interactive, official game page.
It is easy to assume the smoke is computed on the spot and spreads from wherever it was thrown. But read the talk that Alexander Mueller, the IOI rendering engineer who built this smoke, gave in the Advances in Real-Time Rendering course at SIGGRAPH 2026, Smolder: Real-Time Volumetric Effect Rendering in Glacier and 007 First Light, and the answer is only half that.
To answer the question in the title first: yes, it does. How the smoke swells and how it disperses was simulated ahead of release in external tools and baked into files. The game just takes one frame out of those files at a time. But which lights the smoke catches, where it is bright and where it is dark, and what shadows it casts on the floor and walls are computed anew every frame. Mueller summed it up like this in a Digital Foundry interview (around 44 minutes in).
for 007 essentially the shape is pre-baked and then all the lighting, all the rendering is happening in real time.
The shape ahead of time, the light every frame. This post is about where that line was drawn, and why it was drawn there.
A few terms first. Drawing an effect that fills its volume, like smoke or clouds, as a volume is called volumetric rendering. To store a volume, you cut space into small cubes and write down for each one how thick the smoke is there (its density). These cells are the 3D version of the pixels in a 2D image, so they are called voxels. To draw that density on screen, you cast a ray from the eye for each pixel, advance it into the smoke one step at a time, and add up the density it passes through. That method is ray marching, and each advance is called a step.
Why the shape was baked ahead of time
Baking the shape was not the plan from the start. According to the talk, this system, called Smolder, was not even meant for 007 at first.
The first attempt went in the opposite direction. A real-time fluid simulation moved GPU particles, and those particles were drawn as smoke (p28–33). Reactions like smoke hitting the floor came for free, but the problems never stopped. With small particles you could see the individual dots; scaled up, they got blurrier than art direction wanted (p31). The shadows cost too much, and above all, it was almost impossible for artists to build effects with it.

The result of the first attempt: flames and smoke drawn from GPU particles moved by a real-time fluid simulation. It comes from a Glacier project other than 007, which is why it was cropped heavily. A frame from the video on the slide. Image: Alexander Mueller, Smolder: Real-Time Volumetric Effect Rendering in Glacier and 007 First Light p31, © 2026 SIGGRAPH Advances in Real-Time Rendering in Games course.
Mueller had one principle he wanted to keep. Early in the talk he says that however amazing a piece of tech is, if artists can't work with it or don't enjoy working with it, the results won't be amazing either, so in the end it doesn't matter. The first attempt, after two and a half months of work, broke exactly that principle (p33–34).
they broke the one golden rule I had. The workflow was miserable.
The following week Mueller went on a ski trip with his family and wrote a ray-marching prototype in Unity on his laptop (p36–39). It was an experiment with a single floating sphere and a single shadow.
In February 2025, Smolder had only just started to run, and there was still no plan to use it in 007 (p50). Then the smoke gadget came up. The smoke the game had at the time had problems with both visuals and performance, and the gameplay director disliked that the shape of the smoke was hard to read. The talk's notes give the reason in a single sentence.
We use that shape for AI line-of-sight calculations, so having a clear visual representation was extremely important for the stealth gameplay.
So the guard AI uses the shape of the smoke when deciding whether it can see Bond. That one sentence is all that has been made public. To me, the point of the sentence is that the smoke on screen and the smoke the AI knows about have to be the same shape, because players trust the smoke they can see and hide behind it. Baking the shape ahead of time probably made that match easier to keep too, but that part is purely my interpretation.
In early March 2025, 007 First Light was in full production. Release was a year away (p51). Smolder was still a single floating sphere, and getting a real-time fluid simulation to a shippable state was a huge job in itself. Mueller could not devote himself to Smolder alone either.
Ultimately I had to make a call, and that was to commit to building Smolder for that smoke gadget, but not to build it on top of the fluid simulation tech. Instead, we would run the simulation offline, and use prebaked density data.
So Smolder would be used for the smoke gadget, but instead of building it on a real-time simulation, it would use density data simulated offline.
Setting this choice next to a game that went the other way makes it clearer. Among the existing examples Mueller cites in the talk are the smoke grenades in Counter-Strike 2 (p8). On the CS2 page, Valve describes its smoke as dynamic volumetric objects that interact with the environment, and react to lighting, gunfire, and explosions, and says bullets and grenades can push the smoke to briefly clear sightlines. The shape of the smoke is itself real-time gameplay. 007 did the opposite: it fixed the shape and kept the light and shadows real-time instead.
Reading baked smoke cheaply
Putting smoke in a box
With the shape to be baked, the next question was what format to store the baked smoke in. The starting point was OpenVDB, a widely used volume file format and C++ library. Mueller cited its being a mature, proven library, along with the workflow (p52–53). Because many tools support it, artists can keep using the tools they know. Most of the volumes in 007 were made in EmberGen and Houdini.
OpenVDB, however, is not suited to being read directly on the GPU. So he first tried NanoVDB, a flattened version of OpenVDB for the GPU, but the performance was not there. The main reason was high register pressure (p54): when a GPU core has to hold many values while it computes, fewer pieces of work can run at the same time. In the end he built a custom runtime format. It took more development time, but he says it gained a lot of performance and flexibility.
The heart of the custom format is the brick (p58). Smoke fills only part of the box around it. So space is split into small blocks of 4×4×4 voxels, and only the blocks that contain smoke are stored. Those blocks are bricks. Above them sits one large grid, and each of its cells holds a number saying 'this is brick number so-and-so'. This lookup table is called the indirection index. A cell with no smoke gets the special number 0xFFFF, and nothing is stored for it.
Skipping empty space
Because ray marching advances a ray step by step and reads the density as it goes, every step taken where there is no smoke is wasted. To cut this down, Smolder keeps one more bitmask (p59). Each brick is one bit: 1 if it holds smoke, 0 if not. The bits for 4×4×2 bricks, that is 32 bricks, are packed into a single 32-bit integer (uint32).
The ray crosses the grid in units of these groups, and if the integer for the group it has just entered is 0, it skips the whole group in one go. With this bitmask, he says, the culling step got noticeably faster than when checking indirection numbers one by one.
Four bits are enough
How is the density inside a brick written down? Smolder uses a simple block compression similar to NanoVDB's fp4 compression (p62). For each brick it stores the faintest value inside (the minimum) and the thickest (the maximum), and each voxel only records, in a few bits, where it falls between those two values. As I understand it, this works because a brick is a small space. The density does not vary much within it, so dividing just that narrow range gives fairly fine steps even with few levels.
The answer was 4 bits per voxel, or 16 levels (p63).
We ended up using 4 bits per voxel, it resulted in basically no quality loss for the density data. I also tried using 2 bits, but as you can see here, we started to lose some details in the shadows and the quality got noticeably worse.
Going down to 2 bits (4 levels), detail in the shadows started to disappear and the quality got noticeably worse. Still, it was not unusable, and he added that it could become an option for low-end hardware later.
The figure above is simplified to one dimension to make the idea easier to follow. The big hill roughly survives even at 2 bits, but the small bump on the right is buried inside a single step. As I understand it, the small bumps inside the smoke are what give the shadows their texture, so this kind of loss leads to the loss of shadow detail Mueller described.

The same smoke stored at 4 bits per voxel (left) and 2 bits (right). The original image has no labels; the slide marks the left 4 bits / voxel and the right 2 bits / voxel. This is the picture Mueller points to with as you can see here. Image: Alexander Mueller, Smolder: Real-Time Volumetric Effect Rendering in Glacier and 007 First Light p63, © 2026 SIGGRAPH Advances in Real-Time Rendering in Games course.
I turned everything so far into the lab below. It stores one puff of smoke as bricks, and draws the screen with ray marching every frame. The shape is fixed and only the light is computed on the fly, so it carries over the line this post is about.
A simplified model of the idea behind IOI's Smolder, not a reproduction of its code or data.
One prebaked smoke puff, stored as 4×4×4-voxel bricks and ray-marched. Each brick keeps an 8-bit min and max, its voxels are coded between them at 8, 4 or 2 bits, and nearly empty bricks are not stored at all. Fewer bits use less memory; down to 4 bits the picture barely changes, at 2 bits the texture inside the smoke and in its shadow on the floor smears out. The shape is fixed and the light can be moved in real time. Look at the stored bricks or the steps each pixel took, and switch empty-brick skipping on and off to compare the mean step count on screen. A simplified model of the idea behind IOI's Smolder.
Try these.
- Switch 'Bits per voxel' between 8, 4 and 2 and look inside the smoke. 8 and 4 are nearly identical. Drop to 2 and the dark texture the smoke casts on its own interior fades and smears. The difference is moderate, not dramatic. The loss of shadow detail on p63 quoted above is what IOI saw in its own data; what this lab shows is a change in the shading inside the smoke that goes in a similar direction. The quantisation error figure at the lower right changes along with it.
- Switch 'View' to 'Stored bricks' and only the bricks that actually hold data appear as boxes. That is just 774 of the 6,144 cells, 25.7 KB at 4 bits. Filling everything, empty space included, at 8 bits would have taken 384.0 KB.
- Switch 'View' to 'Step count' and toggle 'Skip empty bricks'. Each pixel is coloured from navy through teal and yellow to red by how many steps it took. Turn skipping off and even the empty space outside the smoke lights up; turn it on and that space is skipped, so the average step count drops. The rendered image is exactly the same either way.
- Set 'Drag turns' to 'Light' and drag the frame or move 'Light direction' (Shift+arrow keys work too). The shape of the smoke stays put, while the lit side, the shading inside and the shadow on the floor are recomputed every frame.
The lab is a simplified model that carries over only the principle. It is not IOI's data, code or format; instead of a simulation it uses a single frame of procedural noise I made. Shadows come from a second ray march towards the light instead of moment shadow maps, and the lighting is a single sun plus constant ambient light (no GI or multiple scattering). The memory figures count only the voxel data and each brick's minimum and maximum.
Light, every frame
Most of what makes smoke look solid is its shadows. Light weakens as it passes through smoke, so the side facing away from the light and the inside of the mass are dark, and the edges facing the light are bright. To compute this, you need to know how thick the smoke looks from the light. The shadow maps used for ordinary shadows store just one depth, that of the nearest surface as seen from the light. I covered shadow map basics in Why shadows in games aren't black. But smoke has no surface. You need to store a curve of light dimming little by little with depth.
Mueller looked at several methods (p37). The most promising seemed to be Hillaire's Beer Shadow Maps, which are very cheap and use little memory. But that method assumes the density inside the volume is uniform, so the quality of the shadows the smoke casts on itself was not good enough. What he chose instead was moment shadow maps. They summarise the curve of light dimming in a few numbers and pack them into 80 bits per shadow map texel (p44). The zeroth moment holds the total all the way through, so it is read first, and if nothing would be occluded the rest is skipped. Thanks to that, for lights that use both kinds of shadow, reading the volume shadow costs about 30% of an ordinary shadow (p45).
Every light has volume shadows on by default, and lights that do not overlap a Smolder volume are filtered out, which usually leaves 10 to 20 (p86). These shadows run asynchronously, in time when the GPU is otherwise idle alongside its drawing work, so in the talk's words they are essentially free (p89).
Lighting is expensive. For each step a ray takes through the smoke, 80 to 85% of the cost came not from reading the density but from computing the light (p94). So instead of lowering the screen resolution, Mueller lowered how often the light is computed. He calls it Adaptive Sampling Groups (p94–98).
A GPU processes dozens of neighbouring pixels together as one batch (a wave). As a ray goes deeper into the smoke, its transmittance, how much light gets through, falls. When the transmittance of the whole wave drops below a set value, four neighbouring pixels form a team, each computes the light once at a different depth, and they share the results. Drop further and teams of 16 form. The reasoning is that deep regions, already largely hidden by the smoke in front, need less precision. He says this cut the cost by up to about 50% in some heavy smoke-gadget scenes (p98).
Computing the light every frame makes a certain kind of scene possible. It is one of Mueller's favourite tricks: a single volume can darken an entire area. And it works in the shipped game too (p88).
the player can just throw that at a light source and you'll get this effect.

A Smolder volume in front of a light blocks it and the whole hall goes dark. This is a development build, and the camera moves a little between the two shots. Two frames from the talk video. Image: Alexander Mueller, Smolder: Real-Time Volumetric Effect Rendering in Glacier and 007 First Light p88, © 2026 SIGGRAPH Advances in Real-Time Rendering in Games course.
The light is blocked by the smoke and everything around it goes dark. The shape of the smoke was baked ahead of time, but which light the smoke ends up in front of is up to the player, and the result is computed on the spot.
450 volumes
The technology built for the smoke gadget did not stop there. Once the runtime format was in shape, Mueller tried Smolder in a real 007 environment for the first time and posted it in the team chat, and he says a lot of artists got excited about the tech (p65).

Smolder running in a 007 First Light environment for the first time. A frame from the talk video. Image: Alexander Mueller, Smolder: Real-Time Volumetric Effect Rendering in Glacier and 007 First Light p65, © 2026 SIGGRAPH Advances in Real-Time Rendering in Games course.
The next day, the tech art director asked whether it could also be used for the volumetric clouds in the gameplay trailer (p65). When he counted just before launch, there were more than 450 Smolder volumes in the game (p110). Mueller's one-line verdict: so much for building some tech for the smoke gadget.
Low-end hardware went with the same technology. 007 First Light uses Smolder as is on Xbox Series S, Steam Deck and low-end PCs too (p110). For the memory-tight Series S, each volume was baked a second time at half resolution, which cut the memory of a single animation by about 80 to 85% (p101–102). To me, this is another place where baking the shape paid off. Low-end smoke was just one more set to bake before release.
Even so, Mueller was firm that this is still very much a first version (p110). His to-do list includes real-time fluid simulation (p111). The very thing he put down in March 2025 for lack of time is now on his list as a major upgrade coming to Smolder.
What stayed with me after reading the whole talk was where the line fell. A year before launch, they gave up on smoke that moves on its own, and kept smoke that catches the light real-time to the end. When a player throws the smoke gadget, what they see is a prerecorded shape, but what shading that shape makes in front of which light is computed fresh every time.
References
Primary sources
- Smolder: Real-Time Volumetric Effect Rendering in Glacier and 007 First Light (Alexander Mueller, SIGGRAPH 2026 Advances in Real-Time Rendering in Games, 21 Jul 2026): PDF including the speaker notes. Page numbers in this post refer to this PDF.
- Inside 007 First Light - A Deep Dive Into The Evolved Glacier Engine (Digital Foundry, 20 May 2026): an interview sponsored by IOI. Checked against the auto-generated captions.
- 007 First Light launches globally (IOI, 27 May 2026)
Comparison
- Counter-Strike 2 (Valve): description of the dynamic smoke grenades
Techniques