Runtime Lightmap Baker is the sort of Unity tool that sounds unnecessary until your game lets players build a house, generate a dungeon, rearrange a city, or publish their own level. Traditional baked lighting loves scenes that stay put. Procedural and user-built worlds absolutely do not. This new runtime path-traced lightmapper attacks that gap directly, and it is currently $29.99 instead of $59.99, a 50% discount that the developer says ends October 7, 2026. Check the current price on the Unity Asset Store.
The interesting part is not simply “GI, but at runtime.” Runtime Lightmap Baker generates actual lightmaps during gameplay, including soft shadows, ambient occlusion and bounced global illumination, then lets the finished scene render with the efficiency of baked lighting. That creates a very specific production opportunity: build or generate the world first, bake after the geometry exists, then play with lighting that no longer has to be fully dynamic every frame. View the exact product listing.
Runtime Lightmap Baker solves a problem normal baked lighting cannot
Normal baked lightmaps are calculated ahead of time. Unity’s own documentation is explicit that baked lighting data is not designed to react like a fully runtime-generated system after the game has shipped. That is perfectly fine for a fixed corridor, but it becomes awkward when a roguelike assembles rooms from a seed, a city builder lets the player place walls and lights, or an in-game editor creates a map that did not exist when the developer pressed Build. See the runtime-lighting workflow.
Runtime Lightmap Baker moves that bake into the running game. The vendor’s examples include player-built houses, procedural cities and dungeons, user-generated levels, in-game level editors, architectural visualization, and constrained platforms where constantly running expensive dynamic GI is not attractive. You can bake during a loading screen or progressively while the game is running, then keep the resulting lightmap. Open the product page.
What you actually get for $29.99
The current Runtime Lightmap Baker release is version 1.4.0, dated September 24, 2026 on the Asset Store. It supports the Built-in Render Pipeline and URP, with the store listing showing compatibility for Unity 6000.3.10f1. HDRP is explicitly listed as not compatible, so HDRP teams should stop right there rather than buying first and discovering the pipeline mismatch later. Check compatibility before buying.
The runtime baker is progressive and GPU-driven. The developer says the newer ComputeBuffer path can bake roughly 3x to 5x faster on platforms that support it, while a Shader Model 3.5 HLSL fallback remains available. The support thread also reports about a 30% performance improvement to the HLSL path. That matters because the real buyer question is not whether a pretty bake can happen, but whether it can happen quickly enough to fit a loading screen, a level-generation step, or a quiet background update without making the game feel like it went out for lunch. See the current release details.
The workflow is more useful than the buzzword
Imagine a procedural dungeon. Your generator creates the rooms, props and lights. Instead of accepting flat lighting or keeping a costly realtime GI solution active forever, the game sends the generated renderers to Runtime Lightmap Baker, lets the progressive bake converge, and then plays using the baked result. The same logic works for a player-built settlement or a UGC map uploaded by another player. That is where this tool can save real engineering and content-pipeline time, because you do not need to predict every final layout in the Editor. See the procedural and UGC workflow.
The support thread adds a useful detail for games where only part of the world changes. The developer says the package can rebake nearby renderers affected by a changed light instead of forcing a full-scene rebake, and can detect scene changes around a light with a margin for bounced illumination. That does not make runtime baking free, but it gives designers a way to localize the cost when a tunnel light moves or a player modifies one part of a constructed space. Check the localized rebaking use case.
Hardware requirements matter more than the “all platforms” slogan
The official site markets Runtime Lightmap Baker for WebGL, phones, Macs, consoles and PCs, but there is an important hardware floor. The target GPU must support at least four simultaneous render targets, RGBAFloat texture sampling, and renderable ARGBFloat and ARGBHalf render textures. The package checks those requirements at runtime and aborts on unsupported hardware. The vendor specifically notes that GLES 3.0-class devices can fall below the required capability. Review the hardware requirements.
Compute shaders are not required. The core baker can run through fragment shaders, which is a big part of why the vendor can demonstrate it in WebGL. The demo scene uses TextMesh Pro Essentials and Unity’s Input System, but the vendor says those are demo dependencies rather than runtime assembly requirements for the baker itself. For a mobile, VR or browser project, that separation is useful because you can evaluate the lighting tool without inheriting an unrelated package stack. View the technical requirements.
Who should buy it, and who should skip it?
Buyers with the clearest use case are developers building procedural, player-constructed or user-generated worlds in Built-in or URP. If your final geometry genuinely does not exist until runtime, Runtime Lightmap Baker attacks a problem that ordinary pre-baking cannot solve cleanly. A $29.99 seat is easy to justify if it replaces even a day of custom runtime-lighting pipeline work, and much easier to justify if it becomes the lighting bridge for an entire construction or level-editor feature. Check the sale while it is active.
Skip it if your levels are mostly fixed. A traditional Editor bake is simpler when the environment never changes, and established offline lightmapping tools remain better suited to that conventional workflow. Also skip this release if HDRP is non-negotiable, or if your target hardware sits close to the minimum GPU capability floor. Buying a runtime baker for a static game because the screenshots look cool is how a $29.99 deal becomes a $29.99 folder you never open. Review the product before deciding.
Price, deadline and licensing
The Unity Asset Store currently lists Runtime Lightmap Baker at $29.99 USD, down from $59.99, for a 50% discount. The developer announced the two-week promotion on September 24 and says it ends October 7, 2026. Unity calculates regional pricing, taxes and VAT at checkout, so your final amount can differ. Check the live price and sale status.
The listing uses the Standard Unity Asset Store EULA and classifies the package as an Extension Asset. Under Unity’s current EULA, Extension Assets are licensed per seat, so a studio should budget for each person who needs access rather than assuming one purchase covers the entire team. That detail matters more on a $29.99 promotion because the attractive headline price is still a per-user tooling cost. Open the listing for license details.
The caveat: this is still a young tool
Runtime Lightmap Baker does not yet have enough Asset Store ratings for a mature community consensus. The official support thread is active and the developer has shipped meaningful performance improvements quickly, but this is still a young production tool. Teams should run the official WebGL or Windows demo, test their own target hardware, and validate their real scene sizes before committing a shipping lighting pipeline to it. Try the official demos before buying.
There is also a conceptual limitation worth keeping straight: runtime baking is still work your player’s device must perform. The payoff comes after the bake, when the scene can use the generated lightmaps efficiently. If your game constantly destroys and rebuilds the entire world every few seconds, repeatedly baking may be the wrong architecture. If your world changes in chunks, between rounds, during loading, or when a player finishes editing an area, the model makes much more sense. Evaluate the product against your update frequency.
Verdict: one of the more interesting Unity deals this week
There are bigger percentage discounts in the Unity Autumn Sale, but Runtime Lightmap Baker earns attention because it is not just a cheaper pile of content. It opens a workflow that is genuinely difficult to reproduce with standard pre-baked lighting: polished baked GI for geometry created after launch. For procedural generation, UGC, sandbox construction and in-game editors, that can be a production feature rather than a visual luxury. At $29.99 until October 7, it is worth a serious demo test for the right project. View the product on the Unity Asset Store.
