Library / SDK
QuickBirdEng/XCoordinator avatar
QuickBirdEng/XCoordinator

XCoordinator's newest tag is from 2023 and its badges point at another organisation

🎌 Powerful navigation library for iOS based on the coordinator pattern

2,392 stars190 forksSwiftMIT

At a glance

What is it?
XCoordinator is a Swift navigation library that applies the coordinator pattern to iOS apps using MVVM-C. Its last release was 2.2.1 in February 2023 while the repository was pushed to in July 2026, all five badges resolve to a different organisation name, and the app launch example is written in the pre-Swift-5 spellings.
Who is it for?
XCoordinator suits an iOS team that has already chosen the coordinator pattern and wants the router ownership rules written down rather than reinvented, since the split between unowned and strong routers is the part that removes a class of retain cycle.
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 136 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.

From daily snapshots

Star history

  • QuickBirdEng/XCoordinator2,392 ★ · +0
Star history
Repository2026-09-292026-11-15
QuickBirdEng/XCoordinator2.4k2.4k

0 Stars in the last 47 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The newest tag is from February 2023 while the branch moved in July 2026

The release history stops well before the commit history. Three tags are visible: 2.2.1 on 2023-02-28, 2.2.0 on 2022-03-29 and 2.1.0 on the same day an hour earlier. The default branch is `master` and its last push is dated 2026-07-02, so the working tree has moved more than three years past the newest published version, with no tag in between. The migration notice at the top of the page is written in the present tense about a version that has not been new for years: it says the project has recently released XCoordinator 2.0, then explains that all `AnyRouter` uses should be replaced by `UnownedRouter` in view controllers, view models and references to parent coordinators, or by `StrongRouter` in the AppDelegate and for references to child coordinators, and that `rootViewController` is now injected into the initializer rather than created inside `Coordinator.generateRootViewController`. There is no statement anywhere about which of those changes the unreleased work contains, so the only safe reference point is the 2.2.1 tag.

All five badges resolve to the quickbirdstudios organisation

The repository is QuickBirdEng/XCoordinator. Not one of the five links in the badge row points at that name. The build badge goes to travis-ci.com/quickbirdstudios/XCoordinator, the package badges go to cocoapods.org/pods/XCoordinator and Carthage, the documentation badge goes to quickbirdstudios.github.io/XCoordinator, and the two repository links, one of them the license badge, go to github.com/quickbirdstudios/XCoordinator, the second ending at a LICENSE file in that repository. So a build status, a package registry entry and the license text are all being read from a different organisation's namespace than the one the code is in. The CI configuration in the tree matches the first of those, since the repository carries a Travis config and no GitHub Actions directory, which means the build status the badge reports comes from a service configured for the older name.

The 2.0 change splits one router type into two ownership rules

The substantive migration is about who keeps a reference. Before 2.0 there was a single `AnyRouter`. After it there are two types, and the choice is positional rather than stylistic. `UnownedRouter` is what view controllers, view models and references to parent coordinators hold, so nothing in the view layer keeps a coordinator alive. `StrongRouter` is what the AppDelegate holds and what you use for references to child coordinators, so the object that owns a flow keeps it alive. Getting the assignment the wrong way round produces either a retain cycle or a deallocated router, which is why the page puts the rule at the very top rather than in a migration chapter. The second change is smaller and mechanical: the root view controller is injected into the initializer rather than produced by a method on `Coordinator`, which removes the static factory from the construction path.

The launch example carries the older entry point spellings

The AppDelegate sample is explicit about the setup and about one thing you have to remove. Create the `window` programmatically, delete `Main Storyboard file base name` from Info.plist, set the coordinator as the root of the window's view hierarchy in `didFinishLaunching`, and hold either a strong reference to the initial coordinator or a `strongRouter` reference. The code itself is written in the pre-Swift-5 forms:

swift
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    let window: UIWindow! = UIWindow()
    let router = AppCoordinator().strongRouter

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any?]) -> Bool {
        router.setRoot(for: window)
        return true
    }
}

The entry point is marked with `@UIApplicationMain` rather than the newer attribute, and the launch options are typed `[UIApplicationLaunchOptionsKey: Any?]` with an Optional inside the generic. The screens in the other examples go the other way and are instantiated from nibs with `instantiateFromNib()`, so the sample app builds its window in code while loading screens from nib files.

A route case can carry a dependency injection container

The worked example defines a flow as an enum, and one of its cases carries a container type:

swift
enum UserListRoute: Route {
    case home
    case users
    case user(String)
    case registerUsersPeek(from: Container)
    case logout
}

So a route payload is not limited to a value like a user name; it can be a whole dependency injection container, and any type you can construct on that side of the boundary can be one. The division of labour is stated in two sentences: the `Route` describes which routes can be triggered in a flow, and the `Coordinator` is responsible for preparing the transitions those routes cause. That separation is what lets you prepare more than one coordinator for the same route, differing only in which transition each route performs. The rule of thumb for when to add a new pair is structural rather than functional: create a new Route and Coordinator whenever a new root view controller is needed, such as a navigation controller or a tab bar controller.

Every coordinator owns a root view controller, and that is the destination

An app's structure in this library is a nesting of coordinators and view controllers. Within a flow you transition between view controllers with `push`, `present`, `pop` and `dismiss`, and when the app changes flow you transition to a different coordinator. Each coordinator therefore holds its own `rootViewController`: a `UINavigationController` for a `NavigationCoordinator`, a `UITabBarController` for a `TabBarCoordinator`, and something else for other cases. When a transition targets a coordinator or router, that root view controller is used as the destination, which is the rule that makes nesting work without any coordinator knowing about its parent's presentation style. The example uses it twice: a `.user` route inside the user list flow changes to a different route type entirely, and the `.logout` route dismisses a view controller, which switches back to the previous flow, in that case the home route. Routes are triggered from inside coordinators or from a view model, and the view model receives its flow's router injected at initialisation as an `UnownedRouter`.

Four build entry points, generated docs committed, Travis as the only CI

The repository carries four ways in, which is normal for a library of this age and worth knowing before you pick one. `Package.swift` with a committed `Package.resolved` covers Swift Package Manager and pins the versions the author resolved. `XCoordinator.podspec` covers CocoaPods. `XCoordinator.xcodeproj/` is the Xcode project, which is what a Carthage consumer builds against, and Carthage is one of the five badges. Documentation is generated rather than hand written: a `.jazzy.yaml` configuration sits at the root next to a committed `docs/` directory, so the published API pages and their generator config travel together. Continuous integration is the Travis config alone, matching the badge that reports it. There is no `.github/` directory in the root listing, so there are no GitHub Actions workflows and no issue templates to file against, and a `scripts/` directory sits beside `Sources/` and `Tests/` for whatever the release process runs.

Editorial conclusion

XCoordinator suits an iOS team that has already chosen the coordinator pattern and wants the router ownership rules written down rather than reinvented, since the split between unowned and strong routers is the part that removes a class of retain cycle. Before adopting it, check the badge links, because the CI, package and documentation badges resolve to the quickbirdstudios organisation rather than to the repository you are reading, and check the entry point in your own AppDelegate, because the example still carries the older attribute and signature spellings. Version 2.2.1 is the last tag, so pin it explicitly rather than tracking the branch. It is a navigation layer, not an architecture you can adopt piecemeal, since routes and coordinators are expected to nest from the window down.

Frequently asked questions

What is XCoordinator?

It is a Swift navigation library for iOS built on the Coordinator pattern, aimed at MVVM-C architectures where a model, a view, a view model and a coordinator each hold part of the responsibility. It is published under the MIT license and its default branch is master.

What changed in XCoordinator 2.0?

The single AnyRouter type was split into UnownedRouter, used by view controllers, view models and references to parent coordinators, and StrongRouter, used in the AppDelegate and for child coordinators, so ownership of a flow is explicit. The root view controller is now injected into the initializer instead of being created by Coordinator.generateRootViewController.

How do I start using XCoordinator from AppLaunch?

Create the window programmatically in AppDelegate.swift, remove Main Storyboard file base name from Info.plist, then set the coordinator as the root in didFinishLaunching with router.setRoot(for: window). You have to hold a strong reference to the initial coordinator or keep its strongRouter, and the example uses the older @UIApplicationMain attribute.

How do I get XCoordinator into a project?

The repository carries four entry points: Package.swift with a committed Package.resolved for Swift Package Manager, XCoordinator.podspec for CocoaPods, the Xcode project for Carthage, and a Jazzy configuration with a committed docs directory for API pages. Its only continuous integration configuration is a Travis file.

Does XCoordinator support deep linking and custom transitions?

Yes. Animation objects are specified in prepareTransition(for:) for present, dismiss, push and pop, where nil leaves previously set animations alone and Animation.default resets to what UIKit offers. Deep linking chains routes and can identify routers based on earlier transitions, unlike the .multiple transition, and there are also RxSwift and Combine extensions and options for splitting large route enums.

Official sources

  1. Issues
  2. License: MIT
  3. QuickBirdEng/XCoordinator on GitHub
  4. README
  5. Releases
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.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/quickbirdeng-xcoordinator.svg)](https://hysenlabs.com/projects/quickbirdeng-xcoordinator)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/quickbirdeng-xcoordinator.svg)](https://hysenlabs.com/projects/quickbirdeng-xcoordinator)

Was this useful?