# ConcentricOnboarding for SwiftUI Walkthroughs

> ConcentricOnboarding is an MIT-licensed SwiftUI library for iOS walkthroughs with animated page changes, tap actions, and customizable navigation. It fits short onboarding sequences, but its documentation leaves persistence, accessibility, and release-version questions unanswered.

**exyte/ConcentricOnboarding** — SwiftUI library for a walkthrough or onboarding flow with tap actions

- Repository: https://github.com/exyte/ConcentricOnboarding
- Stars: 1,567 · Forks: 90
- Language: Swift
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/exyte-concentriconboarding

## The UI Problem ConcentricOnboarding Handles

ConcentricOnboarding addresses a specific iOS interface task: presenting several SwiftUI pages as a guided walkthrough where the user advances or returns with animated transitions. The repository describes it as an iOS library for a walkthrough or onboarding flow with tap actions. That scope matters. It is aimed at app teams that already have page content and need a container for page order, background colors, transitions, and next or previous navigation.

The intended flow begins with SwiftUI `View` types for the individual pages. A host view supplies at least two pages and associates each page with a background color. ConcentricOnboarding then presents those entries as a sequence and supplies a button for moving through it. The README also exposes manual navigation methods, animation callbacks, and replacement closures for the behavior at the sequence boundaries.

This makes the library most relevant to a short introduction, feature explanation, or first-run tutorial whose pages should change as a coordinated visual transition. It is not presented as a general tab controller, modal presenter, authentication flow, permissions coordinator, or persisted onboarding system. The repository contains no documented mechanism for deciding whether a person has completed onboarding, restoring a previously completed flow, scheduling onboarding content, or measuring completion beyond page-change callbacks. Those jobs would remain in the host app.

The visual design is also specific rather than generic. The README credits the Cuberto team for the design inspiration, and the repository includes a demo GIF. Based on the project name and that attribution, the defining interface is a concentric or circular presentation rather than an arbitrary collection of swipeable cards. Teams whose brand requires another transition model may find that the package addresses a different interaction pattern.

## Page Data, Transition State, and Tap Flow

The documented data flow begins in the consuming app. Each page is a descendant SwiftUI `View`, and the app creates an array of tuples pairing a page with its background color. That array becomes the `pageContents` input to `ConcentricOnboardingView`. Since at least two pages are required for a meaningful walkthrough, the library is oriented toward sequence navigation rather than rendering an isolated component.

The container owns the movement between pages and exposes both an internal button path and manual methods. The public methods are `goToNextPage(animated: Bool = true)` and `goToPreviousPage(animated: Bool = true)`. Their defaults enable animation, while callers can request an unanimated transition by passing `false`. The duration can also be adjusted through the documented `duration` argument. The README gives `2.0` as an example value, but it does not state the default duration.

Lifecycle callbacks expose several points in that process. `animationWillBegin` runs before an animation starts, `animationDidEnd` runs after it ends, and `didGoToLastPage` runs after the animation leading to the last page finishes. `didChangeCurrentPage` reports that the current page has changed. These are separate events, which is useful for an app that needs to distinguish a generic animation from arrival at the final page.

Navigation can also be replaced rather than merely observed. `insteadOfCyclingToFirstPage` changes what happens after next is pressed on the last page. `insteadOfCyclingToLastPage` changes backward navigation when previous is pressed on the first page. `didPressNextButton` replaces the default next-button action. That final closure gives the host app control over completion behavior, termination UI, or custom routing, although the README does not document callback parameters or execution context.

## Swift Package Manager Setup and First Integration

The documented installation path uses Swift Package Manager. Add the repository URL to the package dependencies used by the iOS application, then resolve the package through Xcode or the package workflow supported by the project.

```swift
dependencies: [
    .package(url: "https://github.com/exyte/ConcentricOnboarding.git")
]
```

The package requires iOS 14 or later and Xcode 12 or later. Those are the explicit compatibility requirements in the README. The repository has no GitHub releases, so there is no documented release tag to select as a stable upgrade target. Adoption should therefore account for resolving the package from the repository and testing integration through `Package.swift` before relying on it in a shipping application.

For a first use, create at least two SwiftUI `View` types in the application and fill them with the content that belongs on each walkthrough page. Then create the page-and-background-color array and pass it to `ConcentricOnboardingView` from the host view hierarchy. The repository documentation does not provide concrete production page types, so an application-specific example cannot be substituted without inventing names or behavior.

The README gives this host-view pattern. Replace the placeholder page and color with the consuming application's values, then place the container in the application's view hierarchy.

```swift
struct ContentView: View {
    var body: some View {
        return ConcentricOnboardingView(pageContents: [<your_page>, <your_background_color>])
    }
}
```

After the container is visible, use its next and previous controls or call `goToNextPage(animated:)` and `goToPreviousPage(animated:)` from application logic. To adjust the transition timing, attach `duration` with a chosen value. The following is the README's duration example.

```swift
ConcentricOnboardingView(pageContents: [<your_page>, <your_background_color>])
	.(duration: 2.0)
```

To change the button image, use the documented icon example. The icon name must be supplied by the application or another source that makes that image available.

```swift
ConcentricOnboardingView(pageContents: [<your_page>, <your_background_color>])
	.(nextIcon: "chevron.forward")
```

The README's duration and icon examples place a dot before the modifier. Consumers should verify those expressions against the public declarations in `Sources/` because the README does not explain the syntax mismatch.

## CocoaPods and Versioning Constraints

The repository advertises both Swift Package Manager and CocoaPods, but its badges state that the CocoaPods integration is deprecated after version `1.0.5`. Swift Package Manager is therefore the clearer documented installation path. The README gives a package URL but does not provide a CocoaPods command or podspec installation instructions. A team whose dependency policy requires CocoaPods should inspect the podspec and verify compatibility separately rather than assuming parity with the Swift package.

There are no GitHub releases, and the README does not identify a recommended production version, migration guide, semantic-version policy, or changelog. The latest activity fact available for review is the repository's last push on 2026-07-08. That date indicates recent repository activity within the maintenance window, but it does not establish API stability by itself.

The upgrade cost is likely to depend on how deeply an application uses the modifier surface. A minimal integration that only supplies `pageContents` has a narrow adoption surface. More advanced usage can touch `duration`, `nextIcon`, manual navigation, lifecycle callbacks, boundary substitutions, and `didPressNextButton`. Changes to any of those APIs could affect custom navigation logic, but the README does not promise compatibility guarantees or document deprecation procedures.

The MIT license permits use, modification, distribution, and private integration under its conditions, while the application remains responsible for reviewing the complete license text and complying with its notice requirement. This is a license identification, not legal advice. The repository does not document a support policy, response time, or dedicated migration effort for framework upgrades.

## Boundary Closures and Custom Completion Behavior

The assignable closures are the main extension points beyond page content and visual timing. They matter because the default sequence appears to cycle at its boundaries. Forward navigation on the last page invokes `insteadOfCyclingToFirstPage` in place of returning to the beginning. Backward navigation from the first page has the corresponding `insteadOfCyclingToLastPage` hook.

For a common first-run flow, an application may want the last-page button to dismiss onboarding rather than loop back to page one. The repository documents `didPressNextButton` as a replacement for the default button action, which is the appropriate documented mechanism to investigate for that requirement. However, the README does not show a complete closure declaration, the current-page value it receives, or how it interacts with manual navigation. The consuming implementation would need to inspect the public API in `Sources/` before depending on an assumed signature.

Callbacks also expose progress events without making the library responsible for storage. `didChangeCurrentPage` can report a transition, while `didGoToLastPage` identifies completion of the final-page animation. An app could use those events to coordinate its own persistence or navigation, but the README does not say whether callbacks are delivered in a particular execution context or whether changing them can affect the animation. Those details should be verified from source before callbacks are used for analytics or state writes.

This boundary design is a trade-off. It allows the host app to own end-of-flow decisions, yet it also means the library is not a turnkey onboarding coordinator. The app must decide what completion means, where the user goes next, and whether completion should be remembered.

## Limits Compared with a Host-App Page Coordinator

ConcentricOnboarding's closest practical alternative is not another animated onboarding package. It is a small page coordinator built directly in SwiftUI using a page index, a background color array, and conditional view rendering. Such an implementation can choose a different transition, keep the active page in application state, expose progress through custom bindings, and attach persistence logic without depending on this library's callback model.

The difference is concrete. A host-app coordinator starts with an explicit state source such as the current page index. ConcentricOnboarding is documented as a container that receives page content, handles button-driven transitions, and reports selected lifecycle events through closures. The library offers the designed circular animation and less custom state plumbing for a standard walkthrough, while the homegrown route gives complete control over presentation and persistence.

ConcentricOnboarding is the wrong choice when the flow is not fundamentally a short animated walkthrough. It also leaves several production questions unresolved in the README. There is no documentation for accessibility labels, VoiceOver announcements, reduced-motion handling, dynamic type behavior, localization order, remote page configuration, state restoration, or interruption during animation. The absence of documentation does not prove those behaviors are absent, but it prevents an adopter from confirming them from the README.

There is also no stated test strategy, supported-device matrix, or semantic-release history. The repository includes `ConcentricOnboardingExample.xcodeproj`, which gives maintainers a place to exercise the example, but the README does not document automated tests. Before adoption, teams should inspect `Package.swift`, the public declarations under `Sources/`, and the example project to verify exact callback signatures, resource handling, platform compatibility, and accessibility behavior.

## Conclusion

SwiftUI teams with a short, visually ordered walkthrough should evaluate ConcentricOnboarding after checking that its concentric navigation fits the product and that the chosen onboarding state can be persisted elsewhere. Projects needing documented accessibility behavior, analytics beyond the listed callbacks, formal releases, or a CocoaPods-supported dependency path should resolve those gaps first. The concrete adoption boundary is simple: this is a focused iOS presentation library, not a complete onboarding state manager.

## FAQ

### What are the iOS and Xcode requirements for ConcentricOnboarding?

The README lists iOS 14+ and Xcode 12+ as the minimum requirements.

### How is ConcentricOnboarding installed with Swift Package Manager?

Add `https://github.com/exyte/ConcentricOnboarding.git` to the Swift package dependencies. The README does not document an installation method through CocoaPods.

### Can I control ConcentricOnboarding page navigation manually?

Yes. The public interface provides `goToNextPage(animated: Bool = true)` and `goToPreviousPage(animated: Bool = true)`, with animation enabled by default.

## Sources

- [exyte/ConcentricOnboarding on GitHub](https://github.com/exyte/ConcentricOnboarding)
- [Issues](https://github.com/exyte/ConcentricOnboarding/issues)
- [License: MIT](https://github.com/exyte/ConcentricOnboarding/blob/main/LICENSE)
- [README](https://github.com/exyte/ConcentricOnboarding/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/exyte-concentriconboarding