<!-- mobian-agent-page publisher="dailydev" canonical="https://daily.dev/posts/the-physics-of-build-systems-jp9ocfyl5" -->

---
title: The physics of build systems | daily.dev
description: Build performance is governed by fundamental constraints: the task graph, incremental change patterns, and the physics of moving data between caches and...
canonical: https://daily.dev/posts/the-physics-of-build-systems-jp9ocfyl5
twitter:card: summary_large_image
twitter:site: @dailydotdev
og:type: website
og:site_name: daily.dev
og:title: The physics of build systems | daily.dev
og:description: Build performance is governed by fundamental constraints: the task graph, incremental change patterns, and the physics of moving data between caches and...
og:url: https://daily.dev/posts/the-physics-of-build-systems-jp9ocfyl5
og:image: https://api.daily.dev/og/posts/JP9OcFYl5.png
og:image:alt: The physics of build systems
og:image:width: 1200
og:image:height: 630
og:locale: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# The physics of build systems

**[
      Tuist
    ](https://daily.dev/sources/tuist-blog)** · 20 min read · 0 upvotes · 0 comments

## Summary

Build performance is governed by fundamental constraints: the task graph, incremental change patterns, and the physics of moving data between caches and machines. More processor cores only help when the graph exposes enough independent work; the longest dependency chain sets a hard floor regardless of hardware. Incremental builds shrink the graph but can't turn dependent work into parallel work, and the real cost of a build depends on which files change most often, not a single clean-build number. Worktrees complicate incrementality: tools like Xcode keep state tied to a build directory (incrementality by location), while Bazel and Xcode's compilation cache use content-addressed identity so results can be reused across checkouts. Sticky volumes can approximate incrementality in CI but introduce scheduling and correctness complexity. Remote caching is bounded by latency and bandwidth, not just storage cost, which motivates collocating cache and compute; Tuist is building Kura, a decentralized cache mesh, and Once, a prototype for adding remote caching/execution to existing build setups without replacing the build system.

## Full article

daily.dev links to this article rather than hosting it. Read it at the original source: <https://tuist.dev/blog/2026/08/25/the-physics-of-build-systems>

## Questions this post answers

### Why doesn't adding more CPU cores make my build faster even though I have a large machine?

More cores only help when the build graph exposes enough independent, ready tasks to fill them. If only a few tasks are ready at any moment (for example two compilations feeding one link step), the rest of the cores sit idle regardless of how many are available, because no scheduler can start a task before its required input exists. The longest chain of dependent tasks sets a floor on build time that extra cores cannot lower.

_Understanding graph bottlenecks helps before spending on bigger machines; daily.dev surfaces build-system deep dives like this for that decision._

### What is the difference between incrementality by location and incrementality by identity in build systems?

Incrementality by location keeps mutable build state in a fixed directory (like Xcode's DerivedData, Cargo, or Mix), so only builds returning to that exact directory benefit, meaning a second worktree or checkout starts cold. Incrementality by identity, used by Bazel's action cache and Xcode's compilation cache, names a task's result by its inputs, toolchain, and settings, so any worktree or machine asking for the same result can reuse it without needing the original directory.

_Choosing between these caching models shapes CI setup; daily.dev helps engineers track build-tooling trade-offs like this one._

### What's a good formula for estimating remote cache hit time in terms of latency and bandwidth?

A useful lower bound treats cache hit time as latency multiplied by the number of non-overlapping request-response steps, plus artifact size divided by effective bandwidth. When the request-count-times-latency term dominates, the cache is latency-bound, hurt by many small blobs unless batching, connection reuse, and parallel downloads are used; when transfer size dominates, it's bandwidth-bound, governed by artifact size and network throughput.

_Engineers weighing cache infrastructure options can follow this kind of technical breakdown on daily.dev._

## Similar posts on daily.dev

- [what is a build system, anyway?](https://daily.dev/posts/what-is-a-build-system-anyway--60rzwtsj1) · Lobsters · 0 upvotes · 0 comments
- [How to Achieve Significant Build Performance Gains With TeamCity](https://daily.dev/posts/how-to-achieve-significant-build-performance-gains-with-teamcity-bg4eizwoz) · JetBrains · 0 upvotes · 0 comments
- [The postmodern build system \(updated 2025\)](https://daily.dev/posts/the-postmodern-build-system-updated-2025--t57bcgqul) · Lobsters · 0 upvotes · 0 comments
- [Essential Tips for Gradle on Ephemeral CI Environments - Part 3](https://daily.dev/posts/essential-tips-for-gradle-on-ephemeral-ci-environments---part-3-xiakaebnz) · Gradle Blog · 0 upvotes · 0 comments
- [Inside Turbopack: Building Faster by Building Less](https://daily.dev/posts/inside-turbopack-building-faster-by-building-less-ghfdclpag) · Next.js · 25 upvotes · 0 comments

---

Tags: [#xcode](https://daily.dev/tags/xcode), [#build-systems](https://daily.dev/tags/build-systems), [#bazel](https://daily.dev/tags/bazel)

[View this post on daily.dev](https://daily.dev/posts/the-physics-of-build-systems-jp9ocfyl5)

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]}
{"@context":"https://schema.org","@type":"TechArticle","headline":"The physics of build systems","url":"https://daily.dev/posts/the-physics-of-build-systems-jp9ocfyl5","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/the-physics-of-build-systems-jp9ocfyl5"},"datePublished":"2026-08-25T15:17:19.037Z","dateModified":"2026-09-14T07:32:15.162Z","description":"Build performance is governed by fundamental constraints: the task graph, incremental change patterns, and the physics of moving data between caches and...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/2c9760448fdb18cf44f0a6018f87b5cd?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/2c9760448fdb18cf44f0a6018f87b5cd?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"\n      Tuist\n    ","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"\n      Tuist\n    ","logo":"https://media.daily.dev/image/upload/s--3AYDH23h--/f_auto,q_auto/v1787487506/logos/tuist-blog?_a=BAMAMicg0","url":"https://daily.dev/sources/tuist-blog"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/the-physics-of-build-systems-jp9ocfyl5","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"xcode,build-systems,bazel","timeRequired":"PT20M"}
{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"\n      Tuist\n    ","item":"https://daily.dev/sources/tuist-blog"},{"@type":"ListItem","position":3,"name":"The physics of build systems"}]}
{"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/the-physics-of-build-systems-jp9ocfyl5#faq","mainEntity":[{"@type":"Question","name":"Why doesn't adding more CPU cores make my build faster even though I have a large machine?","acceptedAnswer":{"@type":"Answer","text":"More cores only help when the build graph exposes enough independent, ready tasks to fill them. If only a few tasks are ready at any moment (for example two compilations feeding one link step), the rest of the cores sit idle regardless of how many are available, because no scheduler can start a task before its required input exists. The longest chain of dependent tasks sets a floor on build time that extra cores cannot lower. Understanding graph bottlenecks helps before spending on bigger machines; daily.dev surfaces build-system deep dives like this for that decision."}},{"@type":"Question","name":"What is the difference between incrementality by location and incrementality by identity in build systems?","acceptedAnswer":{"@type":"Answer","text":"Incrementality by location keeps mutable build state in a fixed directory (like Xcode's DerivedData, Cargo, or Mix), so only builds returning to that exact directory benefit, meaning a second worktree or checkout starts cold. Incrementality by identity, used by Bazel's action cache and Xcode's compilation cache, names a task's result by its inputs, toolchain, and settings, so any worktree or machine asking for the same result can reuse it without needing the original directory. Choosing between these caching models shapes CI setup; daily.dev helps engineers track build-tooling trade-offs like this one."}},{"@type":"Question","name":"What's a good formula for estimating remote cache hit time in terms of latency and bandwidth?","acceptedAnswer":{"@type":"Answer","text":"A useful lower bound treats cache hit time as latency multiplied by the number of non-overlapping request-response steps, plus artifact size divided by effective bandwidth. When the request-count-times-latency term dominates, the cache is latency-bound, hurt by many small blobs unless batching, connection reuse, and parallel downloads are used; when transfer size dominates, it's bandwidth-bound, governed by artifact size and network throughput. Engineers weighing cache infrastructure options can follow this kind of technical breakdown on daily.dev."}}]}
```

