Atlas Bake - A blender Add-on for Texture Baking

Bake clean, engine-ready textures (BaseColor, Normal, Metallic, Roughness, AO, Opacity), build custom channel packs, handle UVs, project High→Low, and export FBX, all in a safe background subprocess so your open .blend stays untouched.

Blender 4.2+ Windows · macOS · Linux GPL-3.0-or-later
Atlas Bake Landing

What's New

Overview

Texture baking condenses complex, multi-material shaders into a compact set of textures ready for engines like Unity and Unreal. Engines expect specific color spaces and often packed channels (Unity’s Metallic+Smoothness, Unreal/glTF’s ORM).

Typical manual steps
  • Pick Cycles + samples
  • Ensure correct UVs
  • Create images & color spaces
  • Handle scalar reroutes (Metal/Rough)
  • Normals (OpenGL/DirectX)
  • AO / Opacity
  • Packed outputs (ex. MS/HDRP/ORM)
  • Build atlas material & export
Atlas Bake solves this

Automates end-to-end with safe defaults and clear status.

  • Correct color spaces per map
  • OpenGL (Y+) / DirectX (Y−) normals
  • Custom channel packs with presets
  • Smart UV or Use Selected UV
  • High→Low baking (max ray, cage, extrusion)
  • Atlas material & optional FBX export
  • Runs in a background headless Blender subprocess
A simple baking process
A simple baking process.

Key features at a glance

  • Per-map baking: Base Color (sRGB), Emission (sRGB), Normal (Non-Color), Metallic (Non-Color), Roughness (Non-Color), AO (Non-Color), Opacity (Non-Color). Metallic & Roughness use a safe temporary Emission reroute for scalar accuracy.
  • Material selection (whitelist): Only included materials are processed in Atlas/Smart-UV.
  • Custom Packs: Build your own packs, or use the presets MS, HDRP Mask, ORM. Dependency-aware and reusable via a preferences folder (absolute and // relative paths supported).
  • UV handling: MANUAL (pick existing UV) or SMART (auto-create & unwrap AtlasBakedUV with Angle Limit & Island Margin; applied to included materials).
  • High→Low projected baking: Selected→Active (one source mesh) with Max Ray Distance, Cage Object, or Virtual Cage Extrusion.
  • Exports: Optional FBX per mesh (UV0 enforced) with sub-options for Include Armature, Include Shape Keys, and Include Animations. Option to Keep Final .blend (all baked meshes in one file, relative or packed paths).
  • Normals: OpenGL (Y+) or DirectX (Y−) with optional Flip Normal Y.
  • Performance & Quality: GPU Compute (optional), Resolution, Bake Margin (px) vs UV Island Margin.
  • Multi-mesh baking: Select multiple meshes and bake them all in a single job - each gets its own textures, UV pass, and material whitelist configurable per mesh.
  • Parallel task queue: Start bakes on multiple objects simultaneously. The Tasks panel tracks every job (Running / Done / Error / Canceled) with a live progress bar. Jobs persist across Blender sessions; if Blender closes mid-bake the task is restored as an error with the last known progress.
  • Clear status & safe operation: Work runs in a background, headless Blender subprocess using a temporary copy. Your open file remains responsive and unmodified while it receives regularly updates about the progress.

Installation

  1. Download the packaged .zip.
  2. In Blender: Edit → Preferences → Add-ons → Install… and select the file.
  3. Enable Atlas Bake.
  4. Find it in 3D View → N-Panel → Atlas Bake.
Add-on Preferences
  • Enable Logs: write detailed bake logs (e.g., logs.txt) into the output folder.
  • Custom Channel Pack Folder: where your pack definitions live (absolute or // relative to the current .blend).
Add-On Preferences
Add-On Preferences.

Quick Start - Simple model baking

  1. Select one or more source meshes. All selected meshes bake in the same job, each producing its own set of textures.
  2. In Textures, enable the maps you want.
  3. Choose UV Mode:
    • MANUAL → a UV map dropdown appears per mesh (defaults to the first available UV layer). The Bake button stays disabled until every selected mesh has a UV map assigned.
    • SMART → set UV Angle Limit & UV Island Margin.
  4. In Materials to Include, check materials to process. Materials are grouped by mesh - each group has All / None shortcut buttons (default: all included).
  5. Pick Normal Convention (OpenGL vs DirectX); optionally Flip Normal Y.
  6. Set Resolution, Samples, Bake Margin (px), and optionally Use GPU.
  7. (Optional) Add Custom Packs (or use the presets: MS/HDRP/ORM.)
  8. Choose a valid Output Folder. Click the home icon next to the path field to auto-set it to the folder of the current .blend.
  9. (Optional) Enable Export FBX (one file per mesh) and/or Keep Final .blend (all baked meshes in one file). When Export FBX is on, three sub-options appear:
    • Include Armature (on by default) - exports skeleton & vertex weights.
    • Include Shape Keys (on by default) - preserves blend shapes/morph targets.
    • Include Animations (off by default) - bakes and exports all NLA actions.
  10. Enter a Task Name in the field above the Bake button. This identifies the job in the Tasks panel and becomes the output subfolder (e.g. Output Folder/MyTask/). The Bake button stays disabled until a name, output folder, and (in MANUAL mode) a UV map for every mesh are provided.
  11. Click Bake Atlas. The job appears in the Tasks panel with a live progress bar. Your open file stays safe and responsive - you can start additional bakes while this one runs.
Result: Game ready asset packed with the selected basic textures.
Result: Game ready asset packed with the selected basic textures.

Custom Channel Packing, a Metallic–Smoothness example

Why pack channels? Engines often require packed maps to reduce sampler count and bandwidth, and to match expected inputs: Unity Standard/URP uses Metallic + Smoothness (A), glTF/Unreal use ORM (R=AO, G=Roughness, B=Metallic), and Unity HDRP uses a Mask Map (typically R=Metallic, G=AO, B=Detail, A=Smoothness).

Key concept: Metallic–Smoothness means R = Metallic, A = 1 − Roughness (Smoothness). ORM means R = AO, G = Roughness, B = Metallic.

  1. Follow the Quick Start steps to set up your bake.
  2. Open Custom Packs → New Pack, name it MetallicSmoothness_Unity, set Output Format = RGBA (8-bit).
  3. Map channels:
    • R → Metallic
    • G → None (0)
    • B → None (0)
    • A → Roughness with Invert (Smoothness)
    Ensure Metallic and Roughness inputs are enabled for the pack. Alternatively, use Add Presets to append MS / ORM / HDRP mask in one click.
  4. Click Bake to generate the packed texture.
  5. Assign in-engine (Unity): set Base Map = BaseColor; Metallic Map = the packed Metallic–Smoothness (A channel drives Smoothness).
Custom channel pack settings for Metallic Smoothness
Custom pack settings for Metallic–Smoothness.
Result: one RGBA packed map driving Metallic (R) and Smoothness (A).
Result: one RGBA packed map driving Metallic (R) and Smoothness (A).

High → Low poly baking, a keyboard / keys scenario

Goal: Bake the High keyboard (with text meshes) into the Low keyboard (no text meshes) so the low-poly keycaps get textures containing the legends.

The high-poly and low-poly models
The high-poly and low-poly models.
  1. Follow Quick Start to prepare your settings.
  2. Select Source & Target: Select High (source - exactly one mesh when using Bake to Target), enable Bake to Target, set Target = Low (receiver). Selecting more than one source mesh while Bake to Target is active will block the bake with an error. Keep both objects aligned with identical origins.
  3. Projection control:
    • Start with Max Ray Distance ≈ 0.2–0.5% of model size.
    • For tight gaps/decals, use a Cage or Cage Extrusion (~0.2–0.5% outward).
    • Thin legends: add slight thickness on High (e.g., 0.2–0.5 mm) or rely on a cage to capture shallow relief.
  4. Click Bake and monitor the progress UI.
  5. Assign the baked textures to the Low model and verify the result.
High to Low Poly Bake Settings
High→Low bake settings.
Bake process completed. The low-poly result model with the assigned textures.
Bake completed - Low-poly with assigned textures.

Output & naming

Each bake writes its files into a named subfolder inside your Output Folder, using the Task Name you provided. When multiple meshes are baked in a single job, each mesh produces its own set of textures - all written into the same subfolder:

Output Folder/
└── <Task Name>/
    ├── <Object1>_BaseColor_2048.png
    ├── <Object1>_Normal_2048.png
    ├── <Object1>_MS_2048.png          (if a Custom Pack is enabled)
    ├── <Object2>_BaseColor_2048.png   (second mesh, if multiple were selected)
    ├── <Object2>_Normal_2048.png
    ├── <Object1>.fbx                  (if Export FBX is enabled - one file per mesh)
    ├── <Object2>.fbx
    ├── <Task Name>_baked.blend        (if Keep Final .blend is enabled)
    └── logs.txt                       (if logging is enabled)

Typical texture file names:

<Object>_<Map>_<Resolution>.png
  # e.g., Crate_BaseColor_2048.png, Crate_Normal_2048.png

Packed outputs follow their pack name:

<Object>_MS_2048.png
  <Object>_HDRPMask_2048.png
  <Object>_ORM_2048.png
Tasks panel

The Tasks section at the bottom of the panel shows all jobs for the current session and any restored from a previous one:

ColumnDescription
State icon⏱ Running · ✓ Done · ✗ Error · ⊘ Canceled
Name (Object)The task name and source mesh(es); multiple meshes are shown comma-joined
Progress barLive step count from the background worker
⚙Opens a popup with the full settings snapshot for that job
?Hover to read the error message (Error jobs only)
✕Cancels a running job; removes a finished one
🗑 (header)Removes all Done / Error / Canceled jobs at once

Jobs survive Blender being closed: when you reopen the file, any job that was running is restored as Error with the message "Blender was closed before the bake completed." and its last known progress. Completed and errored jobs persist until you explicitly remove them.

FAQ / Tips

This has been improved in the latest version. Atlas Bake now supports selecting and baking multiple mesh objects in one task. Each bake runs through the new task system, with its own Task Name, output subfolder, progress tracking, and saved results. Just make sure all selected objects are valid mesh objects. Note: when Bake to Target / High->Low baking is enabled, only one source mesh is allowed.

Yes. Atlas Bake now supports multi-mesh baking, so you can select multiple mesh objects and bake them in a single job. Each mesh gets its own textures, UV pass, and material setup. When Export FBX is enabled, you can also choose to include Armature / skeleton & weights, Shape Keys / blend shapes, and Animations / NLA actions.

Check the Normal Convention: OpenGL (Y+) vs DirectX (Y−). Try toggling Flip Normal Y if your target engine uses the opposite convention.

Increase UV Island Margin and/or Bake Margin (px). For tight assets, consider MANUAL UVs or limit Smart UV to specific materials via the whitelist.

No. Baking runs in a background headless Blender subprocess on a temporary copy of your scene. Your open file stays responsive and unmodified.

Atlas Bake runs the bake in a headless Blender subprocess so your open file remains safe. If that worker crashes, the UI may appear to be “stuck on Baking…”.

Quick recovery:
  1. Click Cancel Bake. This drops a cancel.flag into the worker folder and the UI should clear within a few seconds.
  2. If the UI still looks stuck, press Cancel Bake again, then toggle the panel (collapse/expand) or switch tabs to force a refresh.
  3. Open the Worker folder path shown in the panel (if displayed) and delete the temporary worker directory to clean up.
  4. As a last resort, save your .blend and restart Blender (your open scene was never modified by the worker.)
Tip: Check the bake.log inside the worker folder for the crash reason (GPU memory, missing textures, etc.).

Baking performance depends on scene complexity, texture size, and device setup.
  • Use GPU: In Preferences → System, enable your GPU (CUDA/OptiX/Metal). In Atlas Bake, enable Use GPU.
  • Lower samples for scalar maps: BaseColor/Normal might need more samples in some pipelines, but Metallic/Roughness/AO usually look identical at 1–4 samples.
  • Reduce texture size: Try 2K instead of 4K while iterating.
  • Limit included materials/objects: Bake only what you need.
  • Apply Scale/Rotation on high/low before high→low baking to avoid projection re-tries.
  • Disable heavy modifiers (or use a duplicate export mesh) to reduce geometry the worker has to process.
  • Close other heavy apps to free VRAM/RAM.
If you still see stalls, check bake.log in the worker folder for time sinks (UV unwrap, subdivision, memory).

Currently Atlas Bake exports PNG (lossless, RGBA). This is a solid default for engines and DCC tools.

Recommended color spaces in Blender:
  • sRGB: Base Color (albedo).
  • Non-Color: Metallic, Roughness, AO, Opacity, packed channels, Normal maps.

Atlas Bake currently exports FBX and a baked .blend copy of the result.
  • FBX: Engine-ready (Unity/Unreal friendly). Textures are written to your output folder; materials are set up to reference those files.
  • .blend: A saved baked scene you can re-open and tweak.

Use the Output directory in Atlas Bake’s panel.
  • Paths starting with // are relative to your .blend (e.g., //atlas_bake_packs/).
  • If the .blend is unsaved, Atlas Bake resolves to a safe temporary location and shows the raw string in the UI so you can adjust it.
  • Each job creates a worker folder for logs and intermediates; final textures and exports go to the output directory.

Open the worker folder path (shown during a bake, if available). You’ll find logs.text. These logs capture device selection, UV unwrap, image saves, and exporter output. It's the fastest way to spot missing textures or GPU memory errors.

Click Cancel Bake. Atlas Bake writes a cancel.flag to the worker folder and stops the job cleanly without touching your open scene. If you’ve mapped Esc to call the same operator, pressing Esc will do the same. Once canceled, the status changes to “Cancel requested…” and the UI clears when the worker exits.

Contact

Questions or issues? Email: john.deligiannis1@gmail.com.

License

GPL-3.0-or-later. See the LICENSE file for details.

Back to top ↑