Quick adds BDD specs to Swift, at the price of a private-API Xcode link
The Swift (and Objective-C) testing framework.
At a glance
- What is it?
- Quick is a behavior-driven testing framework for Swift and Objective-C, inspired by RSpec, Specta and Ginkgo, and it always arrives with Nimble as its matcher layer. Its Xcode integration runs on private APIs, which is why the project insists it must never reach an App Store submission.
- Who is it for?
- Quick fits Swift and Objective-C teams who want RSpec-style describe and it blocks inside Xcode and who can keep a test target separate from the app target. It does not fit a project that wants to stay on XCTAssert alone.
- Can I use it commercially?
- Yes. Apache-2.0 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
- Quick/Quick9,819 ★ · -8
| Repository | 2026-09-22 | 2026-11-15 |
|---|---|---|
| Quick/Quick | 9.8k | 9.8k |
-8 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
A QuickSpec subclass nests describe and it, and Nimble does the asserting
Quick is a behavior-driven development framework for Swift and Objective-C, and its shape comes from RSpec, Specta and Ginkgo. A test is a subclass of QuickSpec that overrides `spec()`, and inside it you nest `describe` and `it` blocks with `context` available for setup cases. The example at the top of the README is exactly that shape: a spec class, a describe for the Documentation directory, an it asserting on `sections`, and a nested context for the case where the directory is missing something.
Assertions are not Quick's job. Quick comes together with Nimble, a separate matcher framework, and both `expect(...)` and the `to(...)` matcher belong to Nimble. The project argues that split in `Documentation/en-us/NimbleAssertions.md`, on the grounds that XCTAssert statements leave your expectations unclear.
The consequence is a paired dependency. Quick and Nimble are versioned as a pair, and the compatibility table moves the two together, and you cannot adopt the specs without the matchers.
The compatibility table stops at Swift 5.2 while the manifest says swift-5.9
Version selection is where a new user loses time. The README pairs Swift versions with Quick and Nimble versions in a table: Swift 5.2 with Quick v3.0.0 or later and Nimble v9.0.0 or later; Swift 4.2 or Swift 5 with v1.3.2 and v7.3.2 or later; Swift 3 or Swift 4 with v1.0.0 and v5.0.0 or later; Swift 2.2 or 2.3 with Quick v0.9.3 and Nimble v4.1.0.
Half of that table describes toolchains nobody builds against any more. The newest row is Swift 5.2, while the repository root carries `Package.swift` next to `[email protected]`, so the manifest side of the project moved past what the table documents.
For anyone on a current toolchain the table cannot answer the question. Resolve `Package.swift` instead and use the table only if you are held to an old Swift.
CocoaPods resolves freely, Swift Package Manager pins two different floors
Two package managers, two different answers. The CocoaPods route is a Podfile that nests the test target inside the app target and inherits its search paths:
# Podfile
use_frameworks!
target "MyApp" do
# Normal libraries
target 'MyApp_Tests' do
inherit! :search_paths
pod 'Quick'
pod 'Nimble'
end
endNo version constraints appear there, so CocoaPods takes whatever it considers current. The Swift Package Manager route pins floors instead, and they differ between the two packages:
dependencies: [
.package(url: "https://github.com/Quick/Quick.git", from: "7.0.0"),
.package(url: "https://github.com/Quick/Nimble.git", from: "12.0.0"),
],Quick starts at 7.0.0 and Nimble at 12.0.0, five majors apart, while the Podfile expresses no opinion about either. The Documentation folder also covers Git submodules and further methods. Choose one and commit it, or your teammates resolve a different matcher layer than you do.
Quick links Xcode private APIs, so App Store rejection follows
The sharpest warning in the documentation is the privacy statement. Quick should never be included in the binary submitted to App Store Connect, and the reason given is not licensing: Quick uses private APIs to better integrate with Xcode, and an app that ships it will be rejected.
That turns target membership into a correctness question. The Podfile example exists in part to show the nesting that keeps `MyApp_Tests` inside `MyApp` with inherited search paths, and a project that adds Quick to the app target instead passes its tests and then fails review.
The same statement claims Quick collects no analytics or tracking of any kind, despite not being shipped to Apple. That is a promise in prose rather than an audit, and nothing in the repository stands in for reading what your test target links.
Ten thousand apps use it, and the README asks you to prove yours
Adoption is stated in an unusual way, and the project explains why. It says over ten-thousand apps use Quick and Nimble, then notes that because neither is included in the app binary, neither appears in the usual Top Used Libraries posts, and asks contributors to compile a list of organizations and projects on a wiki page instead.
For a reader weighing a dependency, that means the figure cannot be corroborated from anything in the repository. There is no download count to check and no company list to read, only an invitation to add your own project to a wiki.
The practical consequence: if the choice matters to you, the wiki list is the only primary evidence the project points at, and being used by ten thousand apps says nothing about whether the API will suit your team.
Tags stopped in July 2024 and pushes carried on
Releases and commits have drifted apart. The three most recent releases are v7.6.0 on 2024-05-12, whose note reads 7.6.0 - QuickLint, v7.6.1 on 2024-07-02 and v7.6.2 on 2024-07-23. The last push to main was on 2026-05-18, and the repository is not archived.
So main has moved for more than a year with no tag to go with it. Pinning a version means pinning something from July 2024, and tracking main means accepting an untagged commit that no release note describes.
The licence is Apache 2.0, and the root carries a podspec, a Gemfile with a lockfile, a Rakefile, a Dangerfile and a .swiftlint.yml, with a CI badge pointing at an Xcode workflow.
Two docs directories, a Ruby toolchain, and a CocoaPods podspec
The layout shows how much of this project predates Swift Package Manager. Alongside `Sources/` and `Tests/` you get `Documentation/` and a second `docs/` directory, an `Externals/` folder, a `Plugins/` directory, `Quick Templates/` with a space in the name, `Quick.podspec`, `Package.resolved`, and both `Package.swift` and `[email protected]`.
Ruby tooling sits right next to the Swift build. A Gemfile, a Gemfile.lock, a Rakefile and a Dangerfile imply that lint and review checks are driven from Ruby, which is work a consumer of the package never has to do but a contributor does.
The README points into `Documentation/`, while `docs/` also exists at the root.
Editorial conclusion
Quick fits Swift and Objective-C teams who want RSpec-style describe and it blocks inside Xcode and who can keep a test target separate from the app target. It does not fit a project that wants to stay on XCTAssert alone. Check before adopting whether your Xcode still exposes the private APIs Quick links, and read the resolution your Package.swift produces rather than the Swift compatibility table, whose newest row is Swift 5.2.
Frequently asked questions
What is Quick in Swift testing?
Quick is a behavior-driven development framework for Swift and Objective-C, inspired by RSpec, Specta and Ginkgo. Tests are QuickSpec subclasses that override spec() and nest describe, context and it blocks, while the expectations themselves come from Nimble, a separate matcher framework.
How do I install Quick and Nimble with Swift Package Manager?
Add two package dependencies to Package.swift: the Quick repository from version 7.0.0 and the Nimble repository from version 12.0.0. Detailed instructions for CocoaPods, Git submodules and Swift Package Manager all live in the Documentation folder, with the CocoaPods route also shown as a Podfile entry.
Which Quick version matches my Swift version?
The README table pairs Swift 5.2 with Quick v3.0.0 or later and Nimble v9.0.0 or later, Swift 4.2 and Swift 5 with v1.3.2 and v7.3.2 or later, Swift 3 and Swift 4 with v1.0.0 and v5.0.0 or later, and Swift 2.2 or 2.3 with v0.9.3 and v4.1.0. Its newest row is Swift 5.2, while the repository also ships a [email protected] manifest.
Can I ship Quick inside my iOS app binary?
No. Quick is only used for testing and should never be included in the binary submitted to App Store Connect, and the project states that an app which includes it will be rejected, because Quick uses private APIs to better integrate with Xcode.
How many projects use Quick?
The project says over ten-thousand apps use Quick and Nimble, and explains that because neither is included in the app binary, neither appears in Top Used Libraries posts. It asks projects to add themselves to a wiki list instead, so the figure cannot be checked from the repository.
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/quick-quick)Star history chart for your README
[](https://hysenlabs.com/projects/quick-quick)Was this useful?