# ImagePicker: A Swift Camera and Library Picker with a Referenced Asset Design

> Hyper's ImagePicker bundles camera capture and library selection into one iOS controller, trading memory for a delegate API that returns referenced assets. The trade-offs show up in customization limits and an aging codebase.

**hyperoslo/ImagePicker** — GitHub describes it as :camera: Reinventing the way ImagePicker works.. The repository metadata lists Swift as its primary language. The metadata lists the NOASSERTION license. This article stays within the project description and details documented in the GitHub repository README.

- Repository: https://github.com/hyperoslo/ImagePicker
- Stars: 4,878 · Forks: 671
- Language: Swift
- License: NOASSERTION
- Published: 2026-08-13 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/hyperoslo-imagepicker

## What ImagePicker Actually Solves

ImagePicker addresses a common iOS annoyance: users often need to pick an existing photo or take a new one in the same flow. The system's UIImagePickerController forces you to choose between the camera and the library, or you build a custom tabbed interface. ImagePicker combines both into a single controller. It presents a bottom bar with camera and library tabs, and a top preview area. The delegate methods tell you when the user presses a wrapper button, the done button, or the cancel button. The target audience is Swift developers who want a ready-made UI without assembling their own camera and photo library views. The README states it is "all-in-one" and gives you the UI "for free, out of the box." That is accurate, but it also means you inherit the design decisions Hyper made.

## The Referenced Asset Mechanism

The core design choice is that ImagePicker does not hand you UIImage objects directly when the user interacts. Instead, it keeps a stack of PHAsset references. The README says it "passes around referenced images instead of the image itself," which makes it less memory consuming. You only resolve actual UIImage instances when you need them. The default resolution is handled by AssetManager.resolveAssets(imagePicker.stack.assets). You can override the imageAssets property to change how assets are converted to images. This is a real architectural advantage for large photo libraries. Loading full-resolution images for every thumbnail in the picker would exhaust memory quickly. By deferring resolution, the picker stays responsive. However, the delegate methods still return [UIImage] arrays. So you must call imageAssets inside each delegate method to get the resolved images. The README shows this as an optional step, but it is effectively mandatory if you want to display or upload the selected photos.

## Getting It Running: Commands and Configuration

Installation is straightforward for CocoaPods users. Add pod 'ImagePicker' to your Podfile and run pod install. Carthage users add github "hyperoslo/ImagePicker" to their Cartfile. There is no mention of Swift Package Manager, which is a notable omission for modern Swift projects. After installation, you instantiate ImagePickerController, set a delegate, and present it. The delegate has three methods: wrapperDidPress, doneButtonDidPress, and cancelButtonDidPress. Each receives an array of UIImage. To limit selection, set imageLimit. To restrict to a single image, the FAQ shows configuration.allowMultiplePhotoSelection = false. Configuration also lets you change the done button title, set a no-images message, and disable location recording. These are the only customization points documented. The API is small, which is good for quick integration, but it also means you cannot alter the camera interface or the layout beyond what Configuration exposes.

## Limitations and Failure Modes

The most obvious limitation is the lack of Swift Package Manager support. The README only lists CocoaPods and Carthage. For a library last pushed in 2024, that is anachronistic. SPM is the default for most new iOS projects. This alone will block adoption for teams that have standardized on SPM. Another limitation is the delegate API's design. The wrapperDidPress method is vague. The README does not explain what a "wrapper" is or when it fires. If you rely on that method, you may need to experiment to understand its behavior. The referenced asset design also has a failure mode: if you forget to resolve assets, you get empty arrays. The README shows the override, but it is easy to miss. Finally, the license field in the repository metadata says NOASSERTION. The README claims MIT, but the actual LICENSE file is not shown. That mismatch is a red flag for legal review. You should inspect the license file before using the library in a commercial product.

## Alternatives and Their Different Approaches

The main alternative is the system's PHPickerViewController, introduced in iOS 14. It is Apple's modern replacement for UIImagePickerController. PHPickerViewController has a built-in limit on selection, supports search, and runs out of process, so it does not load all assets into memory. However, it does not include a camera UI. You would need to present the camera separately. Another alternative is a custom picker built on UIImagePickerController for the camera and PHPhotoLibrary for the library. That gives you full control but requires more code. The key difference in approach is that PHPickerViewController is a system component, so it gets updates with iOS releases and does not require a third-party dependency. ImagePicker, by contrast, bundles a custom UI and the camera into one controller. The trade-off is that you get a unified experience but you inherit a third-party codebase that may not keep pace with iOS changes.

## Maintenance and Upgrade Cost

The repository shows a release 3.3.0 from August 2024, which suggests the project is not completely abandoned. However, the gap between 3.2.0 and 3.3.0 is over four years. That long silence implies the library is in maintenance mode, not active development. The README still references CocoaDocs, a service that is effectively defunct. The project is not archived, but the pace is slow. For a UI component that depends on iOS APIs, this is a risk. Camera and photo library APIs change, and Apple may deprecate methods. If you adopt ImagePicker, you should budget time to fork it or replace it if a future iOS release breaks compatibility. The license is listed as NOASSERTION in the metadata, but the README states MIT. You should verify the LICENSE file before relying on it. MIT is permissive, but the ambiguity is a governance concern.

## Conclusion

Adopt ImagePicker if you need a single, prebuilt UI for camera and library selection in a Swift iOS app and you are comfortable with CocoaPods or Carthage. Skip it if you require deep customization of the camera UI, need Swift Package Manager support, or cannot tolerate a project with no clear license declaration. Before integrating, verify the actual license file in the repository, test the delegate callbacks with your asset resolution logic, and confirm that the last push from August 2024 includes any fixes you rely on. The referenced asset design is a genuine advantage, but the lack of SPM and the NOASSERTION license are concrete reasons to look elsewhere first.

## FAQ

### How many images can an ImagePicker user select at once?

As many as they want, because `imageLimit` defaults to zero, which means no limit. Set `imagePickerController.imageLimit = 5` to cap the count. For a single selection, set `allowMultiplePhotoSelection = false` on a `Configuration` and pass that object to `ImagePickerController(configuration:)`, since that switch does not go through `imageLimit`.

### How do I install ImagePicker in an iOS app?

Add `pod 'ImagePicker'` to your Podfile for CocoaPods, or add `github "hyperoslo/ImagePicker"` to your Cartfile for Carthage. A `Package.swift` file sits in the repository root next to `ImagePicker.podspec`, but the README does not document a Swift Package Manager install, so there is no stated version rule or platform requirement for that route.

### Does ImagePicker work with SwiftUI?

The README documents UIKit usage only: create an `ImagePickerController`, set `delegate`, and present it. No SwiftUI integration is described, so a SwiftUI app has to bridge it itself.

### How do I change the button titles and stop location recording in ImagePicker?

Build a `Configuration`, assign `doneButtonTitle`, `noImagesTitle` and `recordLocation`, then hand it to `ImagePickerController(configuration: configuration)`. The README states these cover text, colors, fonts and camera features, and it does not state the default value of `recordLocation`.

### Why does ImagePicker pass images by reference, and can I change that?

The stated reason is memory: it passes around referenced images instead of the image itself, which the README calls less memory consuming. You can change the resolution by overriding a computed property in your controller that returns `AssetManager.resolveAssets(imagePicker.stack.assets)`, then reading it as the first line of any delegate method that returns images.

## Sources

- [Official README](https://github.com/hyperoslo/ImagePicker#readme)
- [Project repository](https://github.com/hyperoslo/ImagePicker)
- [Release notes](https://github.com/hyperoslo/ImagePicker/releases)

---

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