# The smoke in 007 First Light already has its shape before it goes off?

> 2026-11-09 · Graphics · rendering, lighting, voxels, optimization, physics simulation, conference talks
> https://hyna.dev/en/posts/007-smoke-shape-before-it-blows

Say 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 rocky volcanic slope under a dark night sky. Red lava light leaks from a crack in the slope on the left, and above it a column of black smoke rises into the sky. Red specks like embers are scattered across the sky, and a black rock sits in the foreground.](/images/posts/007-smoke-shape-before-it-blows/first-light-iceland-smoke.webp)

*A scene image from the official 007 First Light page. Image: IO Interactive, [official game page](https://ioi.dk/007firstlightgame).*

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](https://advances.realtimerendering.com/s2026/content/AlexanderMueller_Smolder_Siggraph26.pdf), 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](https://www.youtube.com/watch?v=m0SJ9i9RtRg) (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 flowchart in two rows. The top row, in teal, is what happens 'Before release, once, on a dev PC': a smoke simulation (EmberGen, Houdini) leads to OpenVDB files, which lead to a custom runtime format (4×4×4 bricks, 4 bits per voxel, an empty-space bitmask). A dashed line in the middle reads 'the shape is decided up to here' and 'lighting is computed from here on'. The bottom row, in orange, is what happens 'While the game runs, every frame': picking this frame, ray marching, then light, shadows and GI.](/images/posts/007-smoke-shape-before-it-blows/pipeline-en.svg)

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.

![A stone pillar like a chimney stands under a blue sky, and an orange flame shoots sideways from its lower left. To the right of the flame, smoke lit orange hangs low over the ground, and pale grey smoke drifts up into the sky. Engine debug text remains at the top and bottom of the frame.](/images/posts/007-smoke-shape-before-it-blows/slide-first-particles.webp)

*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](https://advances.realtimerendering.com/s2026/content/AlexanderMueller_Smolder_Siggraph26.pdf) 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.

![A horizontal timeline from late 2024 to mid-2026. The hatched bar at the front is the real-time fluid simulation and particle attempt, dropped after 2.5 months; its exact dates are not given. It is followed by a ray-marching test in Unity on a ski trip in January 2025, the first Smolder work in February 2025 (no plan to use it in 007), the decision in March 2025 to bake the shape for the smoke gadget (highlighted in teal), the reveal trailer in June 2025, the State of Play gameplay reveal in September 2025, and release on 27 May 2026 (originally planned for March 2026, highlighted in orange).](/images/posts/007-smoke-shape-before-it-blows/timeline-en.svg)

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](https://www.counter-strike.net/cs2), 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](https://www.openvdb.org/), 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`).

![Two grids side by side. On the left, the indirection grid is 8×6 cells; only the cells at the lower right, where the smoke is, hold brick numbers 0 to 13, and the rest hold FFFF. Below it are the notes 'Empty cells hold 0xFFFF and no data', '16-bit indices cap a frame at 65,535 bricks' and 'One cell = one brick = 4×4×4 voxels (a slice)'. On the right, the bitmask grid has 1s and 0s in the same cells, grouped by thick lines into 4×2 blocks. An orange ray runs from the upper left to the lower right; the two groups holding only 0s are hatched as 'skipped whole', and the ray goes inside to read bricks only in groups that contain a 1.](/images/posts/007-smoke-shape-before-it-blows/bricks-en.svg)

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.

![Two graphs side by side. Both show the same grey density curve (one big hill and a small bump to the right), with the minimum and maximum marked by dashed lines. On the left, in teal, '4 bits per voxel (16 levels)' has fine steps that follow the original curve, small bump included, almost exactly. On the right, in orange, '2 bits per voxel (4 levels)' has only four steps, so the small bump is buried in a flat step and disappears. A note below says it is a 1D illustration.](/images/posts/007-smoke-shape-before-it-blows/quantize-en.svg)

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.

![Two scenes of a test room surrounded by blue tiled walls, side by side. In both, a dark grey column of smoke floats diagonally in light coming in at an angle from the upper left, casting shadows on the floor and the right wall. The left one is stored at 4 bits per voxel and the right one at 2 bits. On the right, the dark shading under the smoke and the texture of the shadow on the right wall are a little fainter and less distinct.](/images/posts/007-smoke-shape-before-it-blows/slide-4bit-vs-2bit.webp)

*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](https://advances.realtimerendering.com/s2026/content/AlexanderMueller_Smolder_Siggraph26.pdf) 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.

> Interactive demo: 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. — https://hyna.dev/en/posts/007-smoke-shape-before-it-blows

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](/en/posts/why-game-shadows-arent-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).

![At the top, a graph in which a teal transmittance curve falls from 1 to near 0 along the depth of the ray. Two thresholds, shown as dashed lines, divide it into three zones: 'Full: every pixel', 'Half: 4 pixels share' and 'Quarter: 16 pixels share'. Below are three 8×8 pixel grids. 'Full' has an orange dot in every cell; 'Half (2×2)' numbers each 2×2 group from 1 to 4, and 'Quarter (4×4)' numbers each 4×4 group from 1 to 16. The number is the depth slot that pixel lights, and the results are pooled and shared within the group. At the very bottom it says the cost dropped by up to about 50% in some heavy smoke-gadget scenes.](/images/posts/007-smoke-shape-before-it-blows/shared-samples-en.svg)

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.*

![Two views looking down into a dark stone hall with a statue. On the left, a smoke volume placed above the statue glows brightly in the warm light inside, and the black-and-white floor tiles below are clearly lit. On the right, the smoke has spread further towards the statue and blocks the light, and the floor and the area around the pillars are noticeably darker. A character in a suit stands in the middle of the floor, and an engine debug menu is visible at the top of the frame.](/images/posts/007-smoke-shape-before-it-blows/slide-smoke-on-light.webp)

*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](https://advances.realtimerendering.com/s2026/content/AlexanderMueller_Smolder_Siggraph26.pdf) 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).

![A dark underground storeroom seen from behind a character. In the foreground is the black back of a character in a suit, with shelves holding boxes on the left and a stone pillar in the middle. White smoke bursts to the right from a red fire extinguisher on the pillar, billowing and spreading, and the smoke casts a dark shadow on the tiled floor. The game HUD is visible at the lower left and lower right.](/images/posts/007-smoke-shape-before-it-blows/slide-hello-smolder.webp)

*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](https://advances.realtimerendering.com/s2026/content/AlexanderMueller_Smolder_Siggraph26.pdf) 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)](https://advances.realtimerendering.com/s2026/content/AlexanderMueller_Smolder_Siggraph26.pdf): 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)](https://www.youtube.com/watch?v=m0SJ9i9RtRg): an interview sponsored by IOI. Checked against the auto-generated captions.
- [007 First Light launches globally (IOI, 27 May 2026)](https://ioi.dk/007firstlightgame/news/2026/007-first-light-launches-globally)

Comparison

- [Counter-Strike 2 (Valve)](https://www.counter-strike.net/cs2): description of the dynamic smoke grenades

Techniques

- [OpenVDB](https://www.openvdb.org/)
- [A Fast Voxel Traversal Algorithm for Ray Tracing (John Amanatides, Andrew Woo, 1987)](http://www.cse.yorku.ca/~amana/research/grid.pdf)
