Understanding For Baked Progy
For Baked Progy is one of those terms you'll see pop up in a handful of specialized forums and GitHub repos, but almost nowhere else. It refers to a batch processing workflow that runs on compiled shader output, typically used in game dev pipelines or real-time rendering tools. If you're not working in that space, you won't need it. If you are, it saves you from rebuilding the same asset chain by hand every time you tweak a material parameter. The basic idea is straightforward. You define a set of input assets, point it at a baked output directory, and it runs through your rendering pipeline, caches the results, and only rebuilds what actually changed. Most people try to use it as a catch-all automation tool and then get confused when it misses something.
Getting Started With For Baked Progy
I installed mine on a machine running Ubuntu 22.04, though it works fine on macOS too. You download the latest release from their repo, extract it somewhere in your path, and then run the init command. The first run creates a config file in your home directory. Don't skip that step. A lot of beginners think it auto-detects everything and get tripped up when it doesn't find their shader directory. The config file is where you set your source paths, your output paths, and which render passes you want baked. Here's a minimal working example: source_dir = "~/projects/mygame/shaders/" output_dir = "~/projects/mygame/baked/" passes = ["diffuse", "normal", "roughness"] cache_mode = "incremental"
That's it. Run the bake command, wait for it to finish, and you should see output files in your target directory. My first real run on a medium project — about 400 shader variants — took roughly 22 minutes. That's with incremental caching turned on. Full rebuild without cache would've been closer to an hour.
Get the Full Details
How It Actually Works Under the Hood
For Baked Progy doesn't re-render anything that hasn't changed. It compares checksums of your source files against cached versions and skips the work. That's the whole value proposition. The trick is getting your source tracking right. If you rename files without updating the config, it won't know to rebuild those and will leave stale outputs in your directory. One thing most tutorials don't mention: the cache lives outside your project directory by default, in ~/.for_baked_progy/cache. That's intentional. It means you can move your project, delete the repo, whatever, and the cache stays intact. But it also means disk usage adds up fast if you're baking a lot of variants. I had to clean out about 18 gigabytes of old cache after a few months of heavy use.
A Problem I Hit and How I Fixed It
Last year I was working on a project with some custom GLSL includes — header files pulled in by multiple shaders. For Baked Progy wasn't catching changes to those headers because it was only hashing the main .frag and .vert files. So I'd edit a shared uniform block in an include, run a bake, and get perfectly valid but wrong output. Took me about three hours to figure out what was going on. The workaround was to add the include directory to the watch list in the config. There's a extra_watch_dirs setting you can add. Once I pointed it at my includes folder, it started tracking those files too. Here's what that looks like in practice: source_dir = "~/projects/mygame/shaders/" output_dir = "~/projects/mygame/baked/" extra_watch_dirs = ["~/projects/mygame/shaders/includes/"] passes = ["diffuse", "normal", "roughness"] cache_mode = "incremental"
After that, every header change triggered a rebuild. Total fix time was maybe twenty minutes once I found the setting in the docs, which were buried in a README that didn't mention this use case at all.
Things It Does Poorly
For Baked Progy doesn't handle dynamic asset generation well. If your pipeline produces shader files at runtime or pulls from a procedural generator, the checksum comparison won't catch those. You end up with orphaned cache entries and silent failures. I've seen people try to hack around this by writing pre-bake scripts that force an invalidate, but that's fragile. It also has zero support for multi-GPU workflows out of the box. You can force parallelism with the --threads flag, but there's no native distribution across multiple cards. If you're baking on a machine with dual GPUs, you're leaving performance on the table. The open-source community has discussed adding CUDA/HIP backend support, but as of the latest release, it hasn't landed. Another limitation worth noting: it assumes a linear asset hierarchy. If your project has deeply nested shader folders with hundreds of subdirectories, the file traversal slows down noticeably. I measured about a 40-second overhead just on directory scanning for a project with 800 nested folders. Not catastrophic, but noticeable when you're iterating fast.
Alternatives Worth Considering
If For Baked Progy doesn't fit your setup, there are other options. Unreal's built-in shader compilation cache handles a lot of this natively, though it's locked to the engine. Unity's Shader Variant Collection does something similar but with a more limited feature set. For projects that need cross-engine compatibility, some teams have built custom solutions on top of Make or SCons, but those require significantly more maintenance. For Baked Progy sits in a middle ground — simple enough to set up quickly, flexible enough for most standalone shader workflows. Just don't expect it to solve every problem in your pipeline. Know its boundaries before you invest time in it.
Where to Download
The latest release is available on GitHub. Clone the repo or grab the binary from the releases page. The documentation is sparse but functional. Read the README carefully before you start configuring, because the defaults won't work for most real projects.
