Derived Data Cache

Where Mowo caches built textures, meshes and audio, how entries are keyed, how to share a cache through a folder or a server, and how to cap or purge it.

Last updated Nov 1, 2026Edit this pageVersion 1.0.0

The Derived Data Cache (DDC) stores the expensive results of processing an asset, such as a texture's compressed mip chain, a decoded audio clip or a cooked mesh, so the work runs once per change instead of once per load. It lives in the project at Intermediate/DerivedDataCache. It is safe to delete at any time and is never committed.

How an entry is keyed

Every entry's key folds in everything that affects its bytes:

  • the type of data, such as a texture cook or an audio decode;
  • a hash of the source file's content;
  • a fingerprint of the import settings;
  • the producer's version, which the engine bumps when its output changes;
  • a build scope of the form <major>.<minor>.<patch>/<platform>/d<N>, where d<N> is the cache's own format revision.

A stale entry is therefore never returned. It simply has a different key. The platform is part of the scope because a BC7 texture and an ASTC texture of the same source are different bytes. The git commit is deliberately left out, so an ordinary engine update does not throw the whole cache away.

  1. Load asset
  2. Build key
  3. Local cache
  4. Shared cache
  5. Produce and store
Shared cache: a shared hit is copied into the local cache
A hit at any tier skips the work. A miss produces the data and writes it to the local cache.

What is cached

DataConsole variableDefaultSettings label
Texture sources cooked to .mtex mip chainsddc.TextureCookOnCache Texture Cooks
Models built from sourceddc.MeshCookOnCache Mesh Imports
Audio decoded to .maudioddc.AudioCookOnCache Audio Decodes

Each variable takes -1 for the code default, 0 for off and 1 for on. With the texture cache on, the editor shows a texture from its cooked mip chain, so the max size and compression you set are what you see in the viewport. The first open of a project pays each texture's encode once.

A .tex texture package, which a model import writes beside its mesh, is block-compressed as it loads: BC7 for color, BC5 for a normal map. The editor uses the same cache entry as the game's model load, so a texture is encoded once for both. Set the texture's compression to uncompressed to keep its RGBA8 pixels. A large level's first open therefore takes longer while its textures encode, and later opens read them from the cache.

With the mesh cache on, a warm load of an unchanged model skips the translation and the build. Mesh distance fields and GI cards baked after a model loads are cached too.

Baked reflection probes are also stored in the DDC, and mbt cook copies them next to the cooked archive so a packaged game loads them.

Cache tiers

The cache reads from up to four roots, in this order:

TierConfigured byWritten?
LocalThe project's Intermediate/DerivedDataCacheYes
Shared folderMOWO_SHARED_DDC=<path>Yes, unless MOWO_SHARED_DDC_READONLY=1
HTTP serverMOWO_DDC_HTTP=<base url>, MOWO_DDC_HTTP_TOKENYes, unless MOWO_DDC_HTTP_READONLY=1
BundledContent/Paks/DerivedDataCache in a packaged gameNo

A hit from the shared folder or the server is copied into the local cache, so the next read does not cross the network. mbt cook and mbt package run the cook in an engine process that inherits the environment, so setting the variables once is enough. These are environment variables rather than project settings because the folder or server differs per machine.

Share a cache through a folder

  1. Pick a shared folder

    Use a network share or a synced folder that every machine can reach.

  2. Set the environment variable

    Set MOWO_SHARED_DDC to the folder's path on each machine, then restart the editor.

  3. Make build machines read-only if needed

    Set MOWO_SHARED_DDC_READONLY=1 on machines that should read the shared cache but never write to it.

Writes to the shared tier use a temp file and a rename, so two machines writing the same key at once is safe. Both results are correct, because the key encodes the content.

Share a cache through a server

mbt ddc serve runs MowoDDC, a small HTTP cache server, over a cache folder:

Shell
./mbt.cmd ddc serve --bind 0.0.0.0 --port 8558 --max-size 200000 --token <secret>

The server listens on 127.0.0.1 by default, so a plain serve is reachable only from the same machine; pass --bind 0.0.0.0 (or a specific interface) to share it with the team.

Then set MOWO_DDC_HTTP=http://<host>:8558 and MOWO_DDC_HTTP_TOKEN=<secret> on every machine. The server stores entries in the same layout as a local or shared cache, so a folder already used as MOWO_SHARED_DDC can be served as it is.

OptionMeaning
--root <dir>Folder to serve. Default: the project's Intermediate/DerivedDataCache
--bind <address>, --port <n>Listen address and port. Default 127.0.0.1 (loopback); pass 0.0.0.0 to serve the network.
--token <t>Bearer token every request must carry. mbt passes it to the server through MOWO_DDC_SERVER_TOKEN, never on its command line.
--readonlyRefuse writes
--max-size <MB>Size cap; least recently used entries go first. 0 is no cap.

After three failed requests in a row, a client skips the server for a minute, so an unreachable server costs one timeout rather than one per asset. A rejected write turns writes off for the rest of the session.

Size cap and eviction

The cache is capped at 4096 MB by default. Set ddc.MaxSizeMB to change it, or 0 for no cap. The cap is read when a project opens and enforced after every write.

Past the cap, the least recently used entries are removed first, down to 85% of the budget, so one sweep makes room for many writes. An entry's age is its file time. A cache hit refreshes it, at most once every ten minutes, so reading a hot entry is not a disk write every time.

Eviction and purge only touch the local tier. The shared and server tiers belong to the team, and the bundled tier ships with the game.

Manage the cache in the editor

Open Project Settings > Engine > Content & Import and scroll to DERIVED DATA CACHE. The section holds the three cache toggles, Bake Mesh Distance Fields, Maximum Cache Size in MB, and a Clear Cache button that shows the current size and entry count. The size is measured in the background, so the row reads "Measuring the cache" for a moment on a large cache; clearing also runs in the background and the row updates when it finishes.

Project Settings window with Engine > Content & Import selected in the left list, scrolled to the DERIVED DATA CACHE section showing Cache Mesh Imports, Cache Texture Cooks, Cache Audio Decodes, Bake Mesh Distance Fields, Maximum Cache Size set to 4096 MB, and the Clear Derived Data Cache row with its Clear Cache button and current size
Cache settings live with the other content and import settings.

Clearing the cache costs the next load the work it would have skipped. Nothing else is lost.

Manage the cache from the command line

Shell
./mbt.cmd ddc info
./mbt.cmd ddc info --top 20
./mbt.cmd ddc prune --max-size 2048
./mbt.cmd ddc purge
CommandWhat it does
ddc infoPrints the cache path, entry count, total size and the largest entries. --top sets how many, default 10
ddc pruneRemoves least recently used entries until the cache fits --max-size MB, default 4096
ddc purgeDeletes every entry
ddc serveServes a cache folder over HTTP (see above)

All of them take --project with a project folder or .mproject file. Without it, mbt walks up from the working directory to find one. prune uses the same order as the engine's own cap, so pruning here and capping in the editor remove the same entries. mbt clean does not touch the DDC, because it cleans the engine tree and the cache belongs to a project.

Integrity

Each entry has a small .chk record beside it with the payload's size and FNV-1a hash. A read that does not match is discarded and counts as a miss, so the next build replaces it. A zero-length entry is never a hit, because it can only be a write that died partway.

Tip

If you suspect a bad cache entry, run ./mbt.cmd ddc purge or click Clear Cache, then reopen the project. The cache rebuilds whatever it needs.

Engine sources

This page describes behavior implemented in these files of the engine repository, checked against commit Infinity.

  • Engine/Source/Runtime/Filesystem/Public/Filesystem/DerivedDataCache.h

Page feedback

Was this page helpful?