ReactorKit: the newest release is 3.2.0 from January 2022 while commits land in 2026
A library for reactive and unidirectional Swift applications
At a glance
- What is it?
- A Swift library for unidirectional application architecture, built on Flux and reactive programming, which a project is meant to adopt view by view rather than all at once. Its release history stopped four years before its commit history, its documentation publishes itself through a git clone, and one source file is deliberately kept out of the generated docs.
- Who is it for?
- ReactorKit still makes sense for a Swift team that wants its view logic testable without a UI and is willing to adopt it one screen at a time, which is the case the project argues for explicitly. Two things to check before you rely on it.
- 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?
- Activity is slowing. The repository last received commits 6 months 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
- ReactorKit/ReactorKit2,787 ★ · +3
| Repository | 2026-10-04 | 2026-11-15 |
|---|---|---|
| ReactorKit/ReactorKit | 2.8k | 2.8k |
3 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The newest tag is from January 2022 and the last commit is from May 2026
The release list has three entries and the newest is 3.2.0, published on 2022-01-13, before it 3.1.0 from October 2021 and 3.0.0 from February 2021. The last push to the default branch is dated 2026-05-07. So the commit history has run more than four years past the newest tag, and the two versions a user can obtain have drifted apart from each other. This matters concretely because the library ships through two package managers, a Swift package manifest and a podspec, and both of them resolve to a tagged release rather than to the head of main. A project that installs the dependency gets 3.2.0. A project that vendors or copies the sources gets whatever the most recent commit produced. Nothing in the repository states which of the two the README is describing, so the honest reading is that the documentation describes the source tree and the release is four years old.
The documented SwiftUI surface has no release to point at
The table of contents carries a whole section for SwiftUI, and it is not a single note. It lists an observable state type, an observed reactor, a reactor observing type, a bindings section, a property wrapper for reactor binding, a binding function with a getter and a sender, an ignored-annotation type, and a testing entry for SwiftUI. All of that sits alongside the classic view and reactor material in the same document, with no version marker separating the two halves. Given that the newest release predates the newest commit by four years, a reader has no way to tell from the repository whether these SwiftUI types are in 3.2.0, in a later commit, or in development. The consequence for an adopter is concrete: if you take the release from a package manager and the SwiftUI types are not in it, the documented path does not exist in the version you installed, and the documentation will not tell you that.
Adoption is meant to be partial, one view at a time
One of the three stated design goals is worth reading before anything else, because it changes how the library is meant to be introduced. It says ReactorKit does not require the whole application to follow a single architecture, that it can be adopted partially for one or more specific views, and that you do not need to rewrite everything to use it on an existing project. The first goal is testability, argued as separating business logic from a view so that a reactor has no dependency on a view, leaving you to test reactors and test view bindings. The third is less typing. So the intended shape is a library you adopt around one feature at a time, which also means it has to coexist with whatever architecture already exists in the codebase rather than displacing it.
The reactor property appears automatically and binding fires when it is assigned
The view side has almost no code in it. A view is anything that displays data, and the project counts both a view controller and a cell as a view. To make a class a view you conform it to a protocol, and the consequence is that a property named reactor appears on it without being written, which is typically assigned from outside the view. Assignment is the trigger: when the reactor property has changed, a binding method gets called, and that method is where you define the mapping in both directions.
func bind(reactor: ProfileViewReactor) {
// action (View -> Reactor)
refreshButton.rx.tap.map { Reactor.Action.refresh }
.bind(to: reactor.action)
.disposed(by: self.disposeBag)
// state (Reactor -> View)
reactor.state.map { $0.isFollowing }
.bind(to: followButton.rx.isSelected)
.disposed(by: self.disposeBag)
}Two things are visible in those lines. The binding style is reactive extension properties rather than target and action, and a dispose bag is required on the view, which the earlier example declares as a stored property.
DeferredReactorView exists because storyboards load views at a different time
There is a second protocol, and its reason is timing. If a view controller is created from a storyboard, assigning its reactor property will not fire the binding method immediately, because the view has not been loaded yet. The deferred protocol is the same thing with the binding postponed until the view is loaded, and the example marks the assignment with a comment saying it will not execute the binding immediately, while the method body carries a comment saying it is called after the view is loaded.
let viewController = MyViewController()
viewController.reactor = MyViewReactor() // will not execute `bind(reactor:)` immediately
class MyViewController: UIViewController, DeferredReactorView {
func bind(reactor: MyViewReactor) {
// this is called after the view is loaded (viewDidLoad)
}
}So a team using storyboards has to reach for the second protocol rather than the first, and the two are otherwise interchangeable. The comments in that example are the entire explanation of the difference.
One source file is excluded from the published documentation
The documentation is generated, not hand written, and the generation step excludes one file from the sources. The rule name is a documentation target and it first builds the package, then runs a documentation indexer over the module into a JSON file, then runs a Ruby documentation generator over that JSON. The generator is told to exclude one specific source file by path, to document only members at public access level, and to build output into a directory that a later target copies to a website branch. So the file that associates objects, which is how the automatic reactor property gets attached to a conforming class, is present in the build and absent from the reference. A reader looking for how that property appears will not find the implementation in the generated docs.
The docs publish step clones the repository and commits with a flag that stages everything
Publishing the documentation is a single make target that depends on generating it, then clones the project's own repository into a temporary directory, checks out the pages branch, copies the generated documentation into it, commits and pushes. The clone is of the same repository at the address in the makefile:
publish: doc
git clone https://github.com/ReactorKit/ReactorKit -b gh-pages tmp-reactorkitThe commit that follows uses a message about generating documentation and a flag that stages every modified file in that working tree rather than only the documentation directory. In a fresh clone of a pages branch that is usually harmless, but it is a publishing step that pushes to a live branch from a local machine with no review step in between. The author name and the author profile link are hardcoded as arguments to the documentation generator rather than being read from the commit being built.
The documentation toolchain is Ruby, and the output directory is not in the tree
A Swift package repository with a Ruby gem manifest and a committed lock file at its root is an unusual combination, and it is there for one purpose: the documentation generator is a Ruby tool. So building the docs needs a Swift toolchain, a documentation indexer, and a Ruby bundle, in that order, and the makefile's clean target exists to remove the intermediate index file, the build directory, the generated documentation and the temporary clone in one line. The generated documentation directory does not appear in the top level listing of the repository, which is consistent with it being produced on demand and then pushed to a separate pages branch. Two further entries at the root say something about how the project is run: a file configuring a code review bot, and a configuration for the Swift package index.
Editorial conclusion
ReactorKit still makes sense for a Swift team that wants its view logic testable without a UI and is willing to adopt it one screen at a time, which is the case the project argues for explicitly. Two things to check before you rely on it. Decide which version you are actually installing, because the newest tagged release is from January 2022 and the repository has moved since, so a package manager install and a source checkout are not the same code. And read the SwiftUI section of the documentation against the release you have, since that surface is described in the README while the release list has not caught up with it. Its testable-reactor design remains the reason to look at it.
Frequently asked questions
What is ReactorKit used for in a Swift project?
It provides a framework for a reactive and unidirectional application architecture, combining Flux with reactive programming. User actions and view states move between layers over observable streams, and the streams are unidirectional: the view can only emit actions and the reactor can only emit states.
How do I install ReactorKit?
The repository ships both a Swift package manifest and a podspec, and the README badged for CocoaPods points at the pod page. It also has an Installation section further down, below the Examples and Dependencies sections, which is not in the part shown here.
Do I have to rewrite my whole app to use ReactorKit?
No. One of its stated design goals is that it does not require the whole application to follow a single architecture, and that it can be adopted partially for one or more specific views. Its stated purpose is to separate business logic from a view so reactors can be tested without one.
What is the difference between a ReactorView and a DeferredReactorView?
Both make a class gain an automatically provided reactor property. With the plain protocol, changing that property calls the binding method. With the deferred protocol the binding is postponed until the view is loaded, which is what you need when the view controller is initialised from a storyboard.
How current is ReactorKit?
The newest release is 3.2.0, published 2022-01-13, after 3.1.0 in October 2021 and 3.0.0 in February 2021. The last push to the main branch is dated 2026-05-07, so commits have continued well past the newest tag. The repository is not archived.
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/reactorkit-reactorkit)Star history chart for your README
[](https://hysenlabs.com/projects/reactorkit-reactorkit)Was this useful?