Understand Unity lightmap baking: the steps to bake indirect lighting

Lightmap baking precomputes lighting into textures so static geometry renders with indirect illumination without heavy real-time work. In Unity, mark objects as static, open the Lighting window, tune lightmap resolution and GI, then bake. Remember, GI alone won’t generate lightmaps.

Lightmap Baking in Unity: The Quiet Hero of Realistic Scenes

If you’ve ever stood in a game scene and noticed softer shadows, warmer indirect glow, or surfaces that look convincingly “lit” even when the sun would have to be everywhere at once, you’ve tasted the magic of lightmaps. Lightmap baking is a process that precomputes lighting and stores it in textures so static geometry can render with indirect lighting without dragging a heavy real-time calculation engine along for the ride. It’s like packaging the scene’s lighting into a set of ready-made textures so your GPU can focus on moving things around and keeping the frame rate snappy.

Let me explain the core idea in a way that sticks. Real-time lighting tracks every ray of light as it bounces around the environment. That’s powerful, but it’s also a lot of math for every frame. In contrast, baked lighting does the heavy lifting ahead of time. The computer simulates how light would interact with static surfaces, calculates the results, and stores those results in textures called lightmaps. When the game runs, Unity simply applies those textures to the surfaces. No per-pixel light tracing, no costly real-time global illumination. The result? Rich, believable illumination with a performance cost that’s front-loaded during development rather than paid at runtime.

A quick note before we jump into steps: baked lighting works best for static or mostly-static elements. If a door swings, a lantern sways, or a character runs through a room, those dynamic elements will need real-time or mixed lighting to react naturally. Unity makes that balance approachable with light modes like Baked, Realtime, and Mixed. The trick is to know which parts of the scene participate in the bake and which don’t, and that’s where the practical steps come in.

The basic steps you’ll follow to bake lightmaps in Unity

1. Decide what’s static and what isn’t

• Why it matters: Lightmaps are meant for surfaces that don’t move. If you mark something as static, you’re telling Unity, “Hey, this object’s lighting will be baked once and then used repeatedly.” If you keep moving a static object or forget to tell Unity it’s static, you’ll end up with mismatched lighting after you bake.

• How to do it: In the Inspector, toggle the Static checkbox for objects that should participate in the bake. In many scenes, the majority of architecture, furniture, and other inanimate elements get the static tag, while characters and other moving pieces stay dynamic.

2. Open the Lighting window and pick a method

• Why it matters: Unity’s Lighting window is your control center for bake settings. It’s where you choose what gets baked, how light interacts with surfaces, and how detailed the lightmaps will be.

• How to access it: Window > Rendering > Lighting (or Lighting Settings in newer versions). Here you’ll find the environment lighting, lightmaps settings, and the bake button.

3. Configure lightmap resolution and global illumination (GI) settings

• Lightmap resolution: This setting determines how many texels per unit are used in the lightmap. Higher resolution means crisper shadows and more detail, but it also increases texture memory usage. A practical approach is to start with a moderate value and adjust based on the scene’s scale and the device targets. For indoor scenes with tight corners, a higher resolution helps reveal subtle lighting nuances; open spaces might get away with a bit less.

• Global Illumination settings: Unity offers several GI methods (like Enlighten or Claire-based approaches in newer versions). The choice affects bounce quality, indirect lighting accuracy, and bake times. You’ll often see options for bounce lighting, irradiance, and ambient occlusion contributions. Tuning these gives you a sense of how soft or how sharp indirect lighting should feel.

• Light modes: Bake, Realtime, and Mixed. For static geometry, Bake is the go-to. Realtime adds dynamic responsiveness but costs performance. Mixed mode allows a blend—static objects get baked lighting, while dynamic objects receive real-time lighting where needed. This blend is especially useful for interiors with moving people or doors.

4. Add light sources and mark them for baking

• Why it matters: Lights are the engines of your bake. You’ll typically set lights to Baked or Mixed in their Inspector. Real-time lights won’t contribute to baked lightmaps, so you’ll want to align the lights with your bake strategy.

• Tips: For warm interiors, ensure key lights (like lamps or overhead fixtures) have baked contributions. For windows and skylights, you can use a combination of baked global illumination and real-time bounce to achieve a natural look without sacrificing performance.

5. Bake the lightmaps

• The moment of truth: Once static objects are marked, the Lighting window is configured, and lights are set to the appropriate modes, you hit Bake (or Generate Lighting). Unity will process the scene, simulate how light bounces and scatters, and create lightmap textures that sit in your project’s library.

• What you’ll see: After baking, you’ll notice the scene looks more cohesive—shadows are consistent, colors feel coherent, and indirect lighting adds depth to surfaces that previously looked flat.

6. Review, tweak, and rebake

• It’s rarely a one-and-done moment. You’ll want to inspect corners, dark rooms, and high-contrast areas. If something looks too grainy or too smooth, adjust the lightmap resolution, tweak GI parameters, or refine the placement and intensity of your lights, then bake again.

• A practical habit: bake small, representative sections of your scene first. It saves time and gives a quick feedback loop before you commit to a full-bake of a large environment.

A few practical tips that save time and improve results

• Balance quality and performance: Lightmap resolution is a dial you’ll tune. In cramped spaces with lots of texture detail, push the resolution up a notch. In open environments or on mobile targets, scale it down to preserve memory and maintain frame rates.

• Use secondary bounce settings with care: Global illumination often features multiple bounces. The first bounce creates the most noticeable effect; subsequent bounces add depth but contribute less dramatic changes. If bake times are creeping up, consider reducing the number of bounces or lowering bounce quality slightly.

• Leverage light probes for dynamic elements: If you have moving objects that should look like they’re part of the baked world, light probes can help them catch a light color and intensity from the scene without forcing a full bake for every moving piece.

• Station it with reflection probes: Reflection probes complement baked lighting by giving reflective surfaces an environment-aware response. They can give glossy surfaces a believable shimmer aligned with the scene’s lighting mood.

• Observe edge cases: Transparent or glass materials sometimes behave oddly with baked lighting. Make sure you test how these materials respond to the bake and adjust the material settings or light contributions if needed.

Common misunderstandings and how to sidestep them

• “Global Illumination alone lights everything” — Not quite. Global Illumination adds bounce lighting, but it won’t bake textures for you unless you’re baking the geometry and setting your lights to Baked or Mixed. In other words, you still need to run the Bake step and mark static objects.

• “All objects should be static” — That’s not practical. Real scenes have doors that move, chairs that get moved, and props you may want to rearrange during play. The sweet spot is static for the things that stay put, dynamic for the rest. If you bake everything, you’ll miss the key dynamic moments.

• “Baked lighting is a silver bullet for realism” — It’s a powerful tool, but it’s not a substitute for good design. Materials matter, texture work matters, and the scene’s composition—how textures, colors, and shapes work together—matters just as much as the lighting.

Why lightmap baking matters for the overall feel

Think of baked lighting as a frame for the scene’s mood. It’s the quiet, faithful backdrop that lets the main act—the characters, the animations, the gameplay—shine without fighting against heavy computations every frame. In architectural visualizations, baked lighting can convey a sense of time and place, preserving the warm glow of a sunset or the cool hush of dawn. In games, it’s what makes a hallway feel lived-in—the subtle variations on plaster walls, the way sunlight spills across a rug, the gentle color shift on a wooden floor as the day passes.

A gentle digression into workflows and collaboration

In a larger project, you’ll often find a dedicated lighting artist collaborating with level designers. The lighting artist maps out the scene’s emotional arc—how light should guide the eye, where contrast should sharpen, where subtle color shifts can tell a story. The level designer focuses on gameplay readability and pacing, ensuring that the baked shadows don’t obscure critical interactions. It’s a balancing act, and lightmap baking is the trusted tool that makes the collaboration feel natural rather than forced. When you bake, you’re delivering a consistent visual language that everyone can rely on, from the artist’s vision to the player’s instinct.

A quick look at common Unity-era settings and terms you’ll encounter

• Static: A toggle for objects that will be included in the bake. If you’re unsure, start with most architecture and fixtures set to static and keep moving pieces non-static.

• Light mode: Bake, Realtime, or Mixed. Bake gives you static lighting, Realtime handles dynamic lighting, and Mixed blends both approaches.

• Lightmap resolution: The density of texels in lightmaps—higher quality but more memory.

• Global Illumination (GI): The indirect lighting model—how light bounces around the scene.

• Bake button: The moment you commit to generating the baked textures.

• Light probes and reflection probes: Extra tools that help with dynamic elements and reflective surfaces without needing to bake everything.

If you’re new to Unity’s baked lighting, the process can feel a bit like tuning a guitar: you tweak a string here, adjust a knob there, and listen for the harmony. It takes a little patience, but once you get the hang of marking static geometry, configuring lightmap resolution, and running the bake, you’ll start recognizing that warmth in scenes, the way corners hold light, and the soft glow that makes interiors feel alive.

In the end, lightmap baking isn’t about clever tricks; it’s about thoughtful preparation. It’s about asking questions like: Which parts of my scene stay put, and which parts move? How bright should the indirect light be in a cozy corner? What’s the right balance between texture detail and performance for the target platform? When you answer those questions well, the baked results become a trustworthy partner in building immersive, believable worlds. And that, honestly, is the essence of good lighting in Unity: a quiet, reliable foundation that lets everything else shine.