swift-composable-architecture's newest release is 1.23.3, three minor versions behind its previous one
A library for building applications in a consistent and understandable way, with composition, testing, and ergonomics in mind.
At a glance
- What is it?
- The Composable Architecture is a Swift library that structures an application around four types, a state type, an action type, a reducer and a store, so that features can be split into isolated modules and tested without a running interface. It is MIT licensed and works with SwiftUI and UIKit. The release numbering is the odd part. After two releases in the 1.26 series, the most recent published version is 1.23.3, which suggests a maintenance branch being patched in parallel with the current line.
- Who is it for?
- This fits a team building an Apple-platform application that has grown past a handful of screens and needs state changes to be testable without launching a simulator. The reducer boundary is the reason to adopt it, because it turns side effects into values you can assert on, which is what makes the testing claim on the front page true rather than aspirational.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 10 days ago.
- What is it written in?
- Mainly Swift, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- pointfreeco/swift-composable-architecture15,021 ★ · +92
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| pointfreeco/swift-composable-architecture | 14.9k | 15k |
92 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The newest published tag is behind the newest version number
Read the three most recent releases in order and the version numbers run backwards.
They are 1.26.1 in July 2026, 1.26.2 in August 2026, and then 1.23.3 in September 2026.
So the most recent release has a lower minor version than the one before it. That is not a mistake in the list; it is what happens when a project maintains an older line alongside its current one and publishes a patch to the older line afterwards.
The likely reading is that 1.26 is the current line and 1.23.3 is a maintenance release on a line that is still receiving fixes for users who cannot move yet. The default branch was last pushed on 2026-10-27, after that release.
The consequence is about pinning. If your dependency tooling resolves by most recent release date, you get 1.23.3. If it resolves by highest version number, you get 1.26.2. Those are different versions of the same library, and the difference is three minor releases.
So decide which line you are on deliberately, write it down, and read the changelog between the two before assuming the newer number is what you want. The pattern of parallel maintenance is normal and a good sign; acting on it without noticing is not.
Every supported platform is an Apple platform, and the project leans on observation built into the system
The platform list is short and it is entirely Apple's.
The front page says the library works in SwiftUI and in UIKit, and on any Apple platform, naming iOS, macOS, iPadOS, visionOS, tvOS and watchOS.
So there is no Linux, no Windows, and no server-side story. That is not a limitation the project apologises for; it is a Swift library for Swift applications and the list is complete.
The basic example annotates the state type with a macro whose stated purpose is to take advantage of the observation tools in the library, and the front page notes this is why it was applied.
So the state type is not a plain value type here. It is instrumented so the library can observe it. That instrumentation is what lets state changes in one part of the interface be seen immediately in another, which is a headline claim on the front page.
The build configuration reflects the platform spread. There is a makefile that can target any of six destinations, from an iPhone simulator through a Mac Catalyst build to a watch simulator, and it passes a flag to skip macro validation during the build, which is the compiler checking macros at build time.
So the consequence is that adopting this means adopting a build that needs a current Apple toolchain, and that a team with any non-Apple target in scope is out of luck from the start rather than discovering it later.
The four types are the whole vocabulary, and the reducer returns effects as values
The library's pitch is that it has as few concepts as possible, and the design is legible enough to check that claim.
Four types. State describes the data a feature needs in order to run its logic and render its interface. Action represents everything that can happen in the feature, and the front page is specific that this includes user actions, notifications and event sources, not just taps. Reducer is a function from current state and an action to the next state, and it is also responsible for returning any effects that should run, such as API requests. Store is the runtime that drives the feature, receiving your actions and running the reducer and effects, and exposing state so the interface can update.
The design decision that makes the testing claim work is that effects are values. A reducer returns an effect rather than performing the request. So the code under test describes what it intends to do, and the test asserts on what was described.
The example makes this concrete with a counter. Alongside the increment and decrement actions there is a button that fetches a random fact about the number, and an action for the response arriving from that request. The response is an action, which means the network result enters the feature through the same door as a button tap.
And actions that need no effect return a value representing none, which keeps every branch of the reducer total.
The action type is where the network result enters the same door as a tap:
enum Action {
case decrementButtonTapped
case incrementButtonTapped
case numberFactButtonTapped
case numberFactResponse(String)
}So the consequence is that the cost of adopting this is learning four names, and the benefit is that your network calls become assertable without a server or a stub.
Two package manifests exist so the build can differ by toolchain version
The repository has two package manifest files, and the naming convention explains why.
Alongside the main manifest there is a second one with a toolchain version suffix on its filename. Swift resolves version-specific manifests by looking for the suffixed file first and falling back to the plain one, so this is the standard mechanism for shipping different build requirements for different compiler versions.
That matters for a library like this one because it uses compiler macros extensively. The whole basic example is built on two macros, one on the enclosing type and one on the state, and macros are the feature most tightly coupled to compiler version.
So the project is telling you its requirements differ depending on which Swift you build with, and encoding that in the packaging rather than in prose.
The build also has a dedicated target for building the library with the module interface emission and library evolution flags enabled. Those flags are what make a Swift module's public interface stable across compiler versions, which is what allows a binary to be built once and used later.
That target suggests the project checks that the library builds with library evolution enabled.
So the consequence is that there is a toolchain floor you should determine before you start, and the project has made it possible to pin it in packaging rather than discovering it in an error message.
The makefile leaves a known broken improvement in place with a link to the issue
There is a small piece of the build configuration that tells you how this project handles its own tooling debt.
The build command pipes its output through a log formatter when that formatter is on the path, and the condition tests for it. Without the formatter it runs the command directly.
Above that is a comment marking it as a to-do, saying the project would prefer a quieter mode of the same tool once something is fixed, with a link to the issue tracking that.
So the maintainers know the current invocation is worse than it should be, know exactly why, and have linked the issue rather than leaving a vague note.
The rest of the build configuration is more careful than most. There is a target that boots the simulator before running tests, and it is written to succeed quietly when there is no simulator identifier to boot, which is the case on a machine without one configured. Derived data goes to a path derived from the configuration name so debug and release do not collide. The destination is resolved by indirection through a variable and a function call rather than being hardcoded.
So the consequence is small: the build works on machines without the optional formatter and without a simulator, which is more than a lot of project build files manage.
The library's primary teaching material is a paid video series, with a free tour as the on-ramp
The learning path in the front page starts with the authors' own video series, and it is worth being clear about what that means.
The library is described as having been designed over the course of many episodes of a video series exploring advanced topics in Swift, hosted by two named authors. There is a collection of all those episodes, and separately a dedicated multi-part tour of the architecture built from scratch.
Then, separately, the examples. The repository ships a set of them under a case studies directory, organised as getting started, effects, navigation, higher-order reducers and reusable components. Alongside those are a search example, a speech recognition example, a synchronised meetings app, a tic-tac-toe game, a to-do list and voice memos.
And for something substantial, the front page points at the source of a shipped word search game built with SwiftUI and this library, as the place to see the architecture under real load.
So the free material is genuinely substantial: a set of case studies and several example apps in the repository, plus the source of isowords. What is behind the series is a paid product, and the front page is honest that the design came out of it.
The consequence is that you can evaluate this without paying for anything, and that if you want the reasoning rather than the recipe, the video series is where it lives.
Composition is claimed as the main benefit, and the reusable-components case study is where it is tested
Of the five capabilities listed on the front page, composition is the one that changes how you organise a codebase rather than how you write a feature.
The claim is about breaking large features into smaller components that can be extracted into their own isolated modules and then glued back together to form the feature. The related state claim is that state can be shared across many screens so a mutation in one is immediately observed in another.
Both of those are consequences of the same decision: features become modules with a defined interface, and a parent feature can observe and drive a child's state without reaching inside it.
The front page's own framing is that the benefit is you can break large complex features into smaller domains that can be glued together, and that you instantly unlock testability.
The case studies are where that claim gets examined rather than asserted. Two of the five are directly about this: one on higher-order reducers, which is the mechanism for a reducer that takes other reducers and composes them, and one on reusable components, which is the same problem from the other direction.
So the consequence is that this library's value is cumulative rather than immediate. It costs you a layer of indirection on the first feature and pays back on the tenth, which means it is a decision about the shape of the whole application rather than about one screen.
Editorial conclusion
This fits a team building an Apple-platform application that has grown past a handful of screens and needs state changes to be testable without launching a simulator. The reducer boundary is the reason to adopt it, because it turns side effects into values you can assert on, which is what makes the testing claim on the front page true rather than aspirational. Two things to check before you commit. Which release line you are on, because the newest published tag is behind the newest number, so pinning by recency and pinning by version can give you different code. And whether your whole target set is Apple platforms, because every platform listed is an Apple one and there is no non-Apple path. Read the case studies rather than the quick start if you are evaluating, since the quick start is one counter and the case studies are where the argument actually lives.
Frequently asked questions
What does composable architecture mean?
In this Swift library it means breaking large features into smaller components that can be extracted into their own isolated modules and then glued back together to form the whole feature. The library is built around four types: a state type describing the data a feature needs, an action type covering everything that can happen in it, a reducer function that evolves state and returns effects as values, and a store that runs the reducer and effects and exposes state to the interface.
What is the Composable Architecture used for?
State management across many screens, composition of large features into isolated modules, isolating side effects so parts of the application can talk to the outside world in a testable way, and testing. The testing claim is specific: not only testing one feature built in the architecture, but integration tests for features composed of many parts and end-to-end tests for how side effects influence the application.
Which platforms does swift-composable-architecture support?
Apple platforms only. It works in SwiftUI and UIKit, and the front page lists iOS, macOS, iPadOS, visionOS, tvOS and watchOS. There is no Linux, Windows or server target. The build configuration can target any of six destinations, from an iPhone simulator through Mac Catalyst to a watch simulator, and it passes a flag to skip macro validation.
What is the latest version of swift-composable-architecture?
By date, 1.23.3 from 2026-09-18. By version number, 1.26.2 from 2026-08-28. The three most recent releases are 1.26.1, 1.26.2 and then 1.23.3, so the newest published tag is three minor versions behind the newest number. The default branch was last pushed on 2026-10-27.
Does swift-composable-architecture need network mocking to test side effects?
Not because of the architecture itself. A reducer returns an effect as a value rather than performing the request, and a network result arrives back as an action through the same path as a user action. That is what the front page means by testing side effects in the most testable way, and why it claims strong guarantees about business logic.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/pointfreeco-swift-composable-architecture)Star history chart for your README
[](https://hysenlabs.com/projects/pointfreeco-swift-composable-architecture)Was this useful?