Swift Stories

During a recent WWDC 2025 session, I caught something that made me pause: a test accessing a static shared instance. It reminded me how these seemingly innocent patterns become the silent killers of test parallelization. Here's the thing about tests—while some developers see them as productivity drains, they become indispensable as codebases and teams grow. A single change can cascade through your system in ways you'd never anticipate, surfacing as bugs that only comprehensive testing can catch. Manual testing simply can't cover the exponential complexity of mature products. The variability of scenarios increases exponentially as features multiply, making automated testing not just helpful, but essential.

Most of us develop on Apple Silicon, which means multiple cores sitting there, ready to run tests in parallel. Add the fact that many tests spend time waiting for IO operations, and you've got a recipe for serious concurrency gains. In theory, your test suite should fly. But practice tells a different story. Swift isn't a pure functional language, which means shared state creeps in everywhere—often without you noticing. Those static shared instances I mentioned? They're perfect hiding spots for global state. Add some without thinking, increase parallelism, and watch your test suite become a flaky mess. Data races emerge. Debugging becomes a nightmare. I've yet to see a codebase that hasn't fallen into this trap, Tuist included.

So you want faster tests through parallelism, but can't because shared state makes everything unreliable. Retries pile up. Your "optimized" test suite runs slower than before. The solution sounds simple: avoid shared state. Pass everything through function signatures. But that boilerplate adds up, and nobody wants to write it. This is where two recent Swift improvements change the game entirely. First, task locals let you propagate state down a tree of tasks without the ceremony of passing parameters everywhere. Think React context or SwiftUI's Environment, but for your test tasks. Each test gets its own isolated state bubble without the boilerplate overhead.

Second, Swift Testing's custom traits turn state management into elegant annotations. Need a mocked environment? Add @Test(withMockedEnvironment) to your test. The state stays perfectly scoped to that test. This kind of scoping blew me away when I first encountered it at Elixir. I'm surprised it's not a bigger conversation in the Swift community. We're at a moment where test parallelization isn't just possible—it's essential. Pair it with our upcoming content-addressable store, and we're looking at build and test runs that aren't just fast, but rock-solid reliable. The tools are here. The question is whether we'll use them.

The content has been written by a human and the grammar reviewed with Claude Sonnet 4

Food for thought