SimpleBake

The 2024 update video attempts to give a brief overview of every feature and option in SimpleBake. It is broken down by chapter so you only need to watch the parts relevant to you. You can find it here.

Around 75% of issues people encounter with SimpleBake stem from poor UV maps. Even when users are convinced their UV maps are fine, closer inspection frequently reveals significant problems.

For good baking results, every point on the surface of your model must correspond to a unique point in UV space — that is the fundamental requirement of baking.

SimpleBake is not a UV unwrapping tool. The built-in unwrap option uses Blender's SmartUVProject, which can sometimes yield usable results, but manually unwrapping your model will almost always produce better bakes. Common UV map problems include:

• Thousands of tiny islands with large margins. Auto-generated maps like this bake poorly — each island needs a margin, and even at the lowest setting there won't be enough texture space to go around.
• Overlapping UVs. This may work for materials but not for baking. Baking requires all UVs to occupy unique space, otherwise results will be incorrect unless you are intentionally overlapping and know exactly what you're doing.
• UVs expanded outside the 0–1 UV space. Commonly done to create a repeating texture effect. While this works for displaying materials, baking requires every surface point to have a unique location within UV space.

Before baking, your material is generated by Blender with effectively infinite detail — calculated dynamically, limited only by the textures used within it. When you bake, you reduce that appearance to a finite number of pixels. Some detail loss is always a trade-off between file size and quality.

Things you can try to improve sharpness:

• Increase your bake texture size — 4K or above gives considerably more pixel budget per UV island.
• Resize UVs to use space efficiently. Minimise dead space. Tools like UV Pack Master are excellent for this. You can even scale up UV islands covering fine detail and shrink islands covering flat, boring areas — this requires practice but yields noticeably better results.
• Consider UDIMs. SimpleBake supports UDIMs in a basic way, which can effectively give you much more texture space across multiple tiles.

In a typical PBR workflow the standard approach is to bake texture maps individually — commonly diffuse, roughness, and transparency — giving you three separate textures. In your target application (Blender, Unreal Engine, Sketchfab, etc.) you then use the transparency map as a mask in your material setup, applied alongside the other textures.

If you prefer to combine transparency into another texture — usually the diffuse — you can use SimpleBake's channel packing feature. For example, pack the diffuse map into the RGB channels and the transparency map into the Alpha channel, resulting in a single RGBA texture. This is especially useful for game engines and asset platforms that support packed textures.

Your UV map is made of islands, and seam issues usually fall into one of two categories: the bake not extending to the island borders, or extending too far and bleeding into neighbouring islands.

The settings to adjust are UV Unwrap Margin (under UV Settings in the panel) and Bake Margin (under Texture Settings). If you are creating your UV map manually or outside SimpleBake, you'll need to manage island spacing yourself.

Baking from high poly to low poly (called Bake to Target in SimpleBake) can be challenging in Blender. SimpleBake automates much of the process and provides more intuitive settings, but it is ultimately wrapping Blender's own Selected to Active baking function — there is no magic involved.

Things to try when you encounter artifacts:

• Adjust cage extrusion and ray distance settings. These are the most common culprits and often need per-mesh tuning.
• Switch the automatic cage type between smooth and hard to see which gives the better result for your mesh.
• Use a proper cage object. This is generally considered the gold standard approach and gives the most control over the baking envelope.

Blender doesn't natively support baking to UDIMs, so SimpleBake uses an effective workaround: it bakes, shifts all UVs one tile to the left, bakes again, shifts again, and repeats until all tiles are covered. This works, but it is basic. There are three common scenarios:

• Baking from normal UVs to UDIMs. Straightforward. Create a dummy tiled texture to position your UVs on the desired tiles (you can delete it afterwards). Then set the UV mode to UDIMs in SimpleBake, enter the number of tiles, and bake.
• Baking from UDIMs to normal UVs. Also easy. Get your materials looking correct using UDIM-based textures, set the UV option to "Normal" in SimpleBake, and bake.
• Baking from UDIMs to UDIMs. Trickier. Because SimpleBake shifts your UVs during the process, and those UVs also drive the material's appearance, the shift causes issues. The solution: duplicate your UDIM UV map, name the duplicate SimpleBake, and enable "Prefer existing UV maps called SimpleBake". From there it's similar to Scenario 1 — set UV mode to UDIMs, enter the tile count, and bake.

Most of the time, spots in your bake are caused by incorrect ray distance and/or cage settings. Behind the scenes SimpleBake is dressing up Blender's Selected to Active baking, and that process often requires careful tuning of these values to produce a clean result.

Dark lines along UV island seams are caused by an ongoing bug in Blender's denoiser. You can read more on this Stack Exchange post and in the official bug report.

Baked images saved externally will often look slightly different compared to how they appear inside Blender. This is due to limitations inherent in various file formats — with the exception of EXR, no format can fully match the fidelity of Blender's internal images.

Several factors influence how your textures look when saved externally:

1. File Format. Lossy formats like JPG will always look worse than PNG. Colors will not be as faithful to the original.
2. "All Internal 32-bit Float" option. Ensures the internal image created by SimpleBake is in 32-bit float format before export. Enabling this maximises pre-export fidelity.
3. "All Exports 16-bit" option. Available for PNG and TIFF formats. Enabling it ensures the highest fidelity for those formats.
4. Compression. For JPG and EXR, SimpleBake lets you adjust compression. Less compression means higher fidelity but larger files.
5. Color Space. For PBR bakes this is set in SimpleBake's addon preferences per bake type. For CyclesBake it is set directly on the panel. Note that EXR files do not store color space data, making them a useful option when troubleshooting color issues — they remove one variable from the equation.

Sample counts in SimpleBake can be confusing because there are several distinct types. Here's a breakdown:

1. CyclesBake Sample Count

Straightforward — the sample count here is the same as your scene's render sample count, because CyclesBake works like a regular render. Set it high enough to reduce noise from light sources in your bake.

2. PBR Bake Sample Count

All PBR maps are baked as emission, meaning there is no lighting or shadows and thus no noise. Because of this, SimpleBake uses a low default of 2 samples for PBR maps — you can usually leave this alone. If you want to change it, the setting is in SimpleBake's preferences.

3. Specials Bake Sample Count

Special bakes such as Ambient Occlusion, Curvature, and Thickness all use the boosted sample count, because the materials SimpleBake uses for these bakes contain nodes that are sensitive to sample counts. Other special bakes use the default PBR sample count since they are essentially PBR bakes even in CyclesBake mode.

4. Specific Special Bakes

Some special bakes allow you to set a sample count for that material specifically. In most cases the boosted sample count handles this fine, but SimpleBake will offer the option when relevant:

• AO — lets you set the sample count on the AO node itself, which is slightly different from the rendering sample count.
• Thickness — uses an AO node internally, so you can similarly set the AO node sample count.
• Lightmap — baking a lightmap is essentially the same as a CyclesBake. In PBR mode you'll see a regular sample count setting; in CyclesBake mode it uses the count set in the CyclesBake section.

Blender is a complex program and crashes can happen during normal use. They may be more likely when using SimpleBake due to the intensive operations involved in baking. Common causes include:

• Addon conflicts. Other addons may perform actions during baking without checking whether it is safe to do so. The first step when a crash occurs is to disable all other addons. SimpleBake includes an option in its preferences to do this automatically during baking. Alternatively, use background baking — all addons are disabled in that mode.
• UV mapping issues. UV islands extending far outside UV space can cause Blender to detect a huge number of UDIM tiles, which may cause it to refuse to save images to disk — often manifesting as crashes with "Image could not be written to <path>" errors. Keep UV islands within the intended UV or UDIM space.
• Blender version. SimpleBake is developed and tested against the current stable Blender release. Older or customised builds may behave differently. If you can't upgrade Blender, stick with a version of SimpleBake that is known to work for you.
• Node group complexity. SimpleBake must ungroup node groups to perform PBR baking. A large number of nested node groups can be demanding and may increase the chance of a crash.
• Geometry node modifiers. SimpleBake must apply geometry node modifiers before baking, as Blender's API only exposes the base object otherwise. Applying many complex modifiers is resource-intensive and can contribute to instability.
• Large baking operations. Baking many objects simultaneously is inherently intensive and can push hardware limits. Consider breaking large tasks into smaller chunks and running each as a background baking task so they complete sequentially.
• Atlas creation. Creating an atlas map from many objects is an additional intensive step that adds strain during the baking process.
• Foreground baking interaction. Interacting with Blender's interface while a foreground bake is in progress will almost always cause a crash. Do not touch Blender during foreground baking. Background baking avoids this entirely.
• Hardware limitations. Ensure your hardware has adequate memory and processing power for the tasks you're running. Blender does not always handle running out of memory gracefully, and may crash without warning.

If you suspect a crash is related to SimpleBake, run Blender from the console or terminal to capture error output. Crashes caused directly by SimpleBake will usually produce a Python traceback referencing SimpleBake's .py files.

If you encounter a Python traceback error, please report it so it can be addressed in a future SimpleBake update.