LNPopupUI: SwiftUI popups in the style of the Apple Music app

A SwiftUI wrapper over a UIKit framework

The README describes LNPopupUI as a SwiftUI library for presenting views as popups, much like the Apple Music and Podcasts apps, and immediately adds the sentence that shapes everything else: it is a SwiftUI wrapper of the LNPopupController framework, adapted to work with SwiftUI.

That distinction matters for anyone evaluating it. LNPopupController is a UIKit framework with its own release cadence, and this project is the SwiftUI-shaped layer on top of it. The table of contents ends with a section titled `LNPopupController` SwiftUI additions, which is the giveaway that the wrapper exposes parts of the underlying framework directly rather than hiding it.

The interaction model is the one people recognise from the Music app. A popup bar is presented with a content view, the user swipes or taps the popup bar at any point to present the content view, and after finishing the user dismisses the popup by either swiping the content view or tapping the popup close button. The bar sits at the bottom of the container, above the container's own bottom bar such as a tab bar or a toolbar, or directly at the bottom of the screen, and it presents at-a-glance information while allowing interaction.

The library extends SwiftUI's `View` with new functionality for presenting and customising popups, and with setters for the bar's title, image and bar button items. It also states that when a popup bar is presented, it automatically adapts to the view it was presented on for best appearance, which is the piece that makes the effect look native rather than bolted on.

Five concepts, and a modifier to wire them up

The README defines the vocabulary of a popup presentation carefully, and this is the section to read before writing any code.

The popup container view is the `View` that hosts the presentation, normally the outer-most tab or navigation view, though it can be any view. The popup content view is the view representing the content when the popup is open. The popup bar is the bar docked to the bottom of the container, and it can be a default system style or a completely custom implementation. Popup items are the source of data displayed on the bar at any given time. And the custom popup bar view is the optional piece for when you present a custom bar.

The API surface is small. To add a popup presentation to a scene you use the `popup(isBarPresented:isPopupOpen:content:)` modifier, and after that the user can interact with the bar and the content. To present and dismiss the bar programmatically you toggle the `isPopupBarPresented` bound boolean, and to open or close the popup itself you toggle `isPopupOpen`.

Two bound booleans is a deliberate design, and it is the part that differs from a sheet. A sheet has one state, presented or not. Here the bar can be visible with the content closed, which is the whole point of the pattern, since the bar is a persistent summary and the content is the detail that opens above it. Being able to control both states separately is what lets an app drive the presentation from a player or a download, rather than only from a gesture.

For the deeper documentation, the README points to LNPopupUI.swift in the Sources directory.

Present the bar on the outermost view

The placement advice is short and specific: it is recommended to present the popup bar on the outermost view, such as `TabView` or `NavigationStack`. The example given is a view contained in a navigation stack, which is in turn contained in a tab view, where the recommendation is to present the popup bar on the tab view.

The reason is structural rather than stylistic. A bar docked to the bottom of a container wants to sit above the container's own bottom bar, and the container that has a bottom bar is the outermost one. Present it deeper in the hierarchy and the bar ends up inside a pushed view, where it is anchored to a screen that is about to be covered by a navigation push, and the layout maths of the tab bar and the toolbar both have to be negotiated with the popup.

The automatic adaptation the library advertises works on the same principle. The bar adjusts itself to the view it was presented on, which only means something sensible if it is presented on the view that actually defines the bottom edge of the screen.

For a quick reference point, the README points at the demo project for a recreation of Apple's music app, which is the fastest way to see how the pieces are meant to fit together. To run that example project there is one prerequisite that catches people out, because the example depends on submodules that have to be fetched first, and the README asks you to update them with the recursive submodule update command.

Adding the package, three lines of Swift

LNPopupUI supports SPM versions 6.0, which is Xcode 16, and above. In Xcode you click File, then Add Package Dependencies, enter the repository URL and select the version you want to use.

For a project that manages its dependencies in a file, the package is added like any other:

.package(url: "https://github.com/LeoNatan/LNPopupUI.git", from: "2.5.0")

and the target then depends on it by name:

.target(name: "MyExampleApp", dependencies: ["LNPopupUI"]),

and the module is imported where you need it:

import LNPopupUI

The version floor in that snippet is from 2.5.0, which is worth noting against the release history. The current releases are in the 4.0 line, 4.0.4 on 2026-10-03, 4.0.3 on 2026-09-18 and 4.0.2 on 2026-09-12, so the snippet in the README is a minimum rather than a recommendation, and a project pinning from 2.5.0 would resolve to the newest allowed 4.x release.

The package is distributed with a Swift Package Manager compatible badge in the README, and the repository root holds a Package.swift, a Sources directory and the example project.

iOS 14 and up, adapting to the newest design

The feature list has two lines that tell you what kind of maintenance this library does.

The first is platform coverage. There is full support for iOS, iPadOS and Mac Catalyst, and the Mac Catalyst support is spelled out in terms of the windowing options, with Optimize for Mac, Scaled to Match iPad and Designed for iPad all named. The library is available for iOS 14 and above as an SPM package for SwiftUI.

The second is window behaviour, and the detail level is unusual. It supports window resize on iPadOS, Mac Catalyst and iOS, on iPhone Duo and in iPhone Mirroring, and iPhone Duo is fully supported when targeting the iOS 27.1 SDK and later.

The third line is the design one. It supports iOS 27 and iOS 26 glass design, while maintaining an appropriate look and feel on previous iOS versions. That is the sentence that matters most for an adopter, because the visual language of the newest system releases is not the visual language of iOS 14, and a popup bar that looks native on the current release and wrong on an older one is the classic failure of a component library that only targets the latest device.

The README also says that for UIKit, the thing to check out is the LNPopupController framework. That is the division of labour: SwiftUI applications use this wrapper, UIKit applications use the framework underneath.

A long customisation list, from bar style to right-to-left

The table of contents is the best evidence of how much of the surface is exposed, and it is long.

Presentation management is covered first, with popup items and their variants: a single popup item, multiple popup items with paging support, and a default popup item. The appearance and behaviour block then covers the bar style, including legacy bar styles for older system versions, the interaction style, the progress view style, the close button style, text marquee scroll, popup bar minimisation, split views and popup transitions.

The customisation block goes lower. There is popup bar customisation, context menus, ProMotion support, full right-to-left support, a custom popup bar view, and a low-level bar customisation section for the cases where the SwiftUI layer is not enough.

Two of these deserve a note. Text marquee scroll is the behaviour where a long title in the bar scrolls rather than truncating, which is the kind of small thing that separates a bar that looks like the Music app from one that does not. Full right-to-left support is the one that tends to be missing, because mirroring a custom bar is not a matter of flipping a frame.

The low-level section is the escape hatch, and the presence of a `LNPopupController` SwiftUI additions section alongside it confirms the model: the SwiftUI wrapper is a convenience layer, and the framework's own API is reachable when you need to reach it.

MIT licensed, with a 4.0 line shipping every few weeks

The licence is MIT, with the LICENSE file at the root of the repository and a matching badge in the README.

The release cadence is what stands out. Three releases in a month, 4.0.2 on 2026-09-12, 4.0.3 on 2026-09-18 and 4.0.4 on 2026-10-03, and the repository is not archived with the last push on 2026-10-06. The numbering suggests a 4.0 line that is being adjusted for the current platform releases rather than a stable line in the strict sense, so a project that adopts it should expect to move with it, and should decide deliberately when to move.

The repository layout is a standard Swift package. There is a Package.swift, a Sources directory, an LNPopupUIExample directory for the demo application, a Supplements directory holding the images and animations used in the README, a .gitmodules file for the example's dependencies, and two small shell scripts, releaseVersion.sh and update_copyright.sh, which point to a release process that is at least partly scripted.

The topics attached to the repository name the pieces, `lnpopupcontroller`, `lnpopupcontroller-framework`, `popup`, `spm` and `swiftui-library`, which is a fair summary of a project that is one SwiftUI wrapper around one UIKit framework, with a demo app and a scripted release process.

Editorial conclusion

LNPopupUI fits a SwiftUI team that wants the now-playing style popup bar without hand-rolling the presentation, gesture handling and bar adaptation, and that targets recent Apple platforms. It is the wrong choice for a UIKit codebase, where the README points you at the LNPopupController framework directly, and the wrong choice if you need the bar behaviour to differ fundamentally from the original. Verify first which iOS version you support, since the library supports iOS 14 and above while adapting its look to the newest glass design, and read the LNPopupController SwiftUI additions section, since the wrapper exposes the framework underneath.

Frequently asked questions

Official sources

1. Issues
2. LeoNatan/LNPopupUI on GitHub
3. License: MIT
4. README
5. Releases