Noureddine RAMDI / Phosphor: an open-source iOS device manager with dual backends and zero dependencies

Created Sat, 23 May 2026 20:41:14 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
1097 Words
github-stars swift swiftui ios macos pymobiledevice3 libimobiledevice mvvm

momenbasel/Phosphor

Phosphor addresses a common frustration for macOS users who want complete local control over their iOS devices without locking into iCloud or expensive subscription services. It’s a fully open-source iOS device manager built in SwiftUI that supports iPhones, iPads, and iPods through a clever dual-backend approach. This lets users manage backups, export messages, browse the file system, and more — all locally and without external dependencies on Swift packages or C bindings.

what phosphor does and how it’s built

Phosphor is an open-source macOS app designed to manage iOS devices locally. It targets macOS 14 Sonoma or later and is written entirely in Swift using SwiftUI with an MVVM architecture. The app is positioned as a free alternative to commercial tools like iMazing, which charges $49.99/year for similar functionality.

The core idea is to provide full access to device backups, file browsing, app management, and diagnostics without relying on iCloud or any subscriptions. It supports iOS versions 17 through 26+ using a primary backend called pymobiledevice3 — a pure Python implementation of the iOS device communication stack. As a fallback, it can also use libimobiledevice, a popular open-source library for iOS device management.

The app wraps both backends as subprocesses rather than integrating them via C language bindings. This separation avoids complex native integrations and keeps the Swift app dependency-free. Under the hood, Phosphor directly parses Apple’s backup format by reading SQLite databases such as Manifest.db and sms.db via macOS’s system sqlite3 CLI tool. This approach eliminates the need for extra Swift dependencies or external database wrappers.

Key features include:

  • Full and incremental backups of iOS devices
  • Exporting iMessage and WhatsApp conversations to CSV or HTML
  • Extracting photos and media files
  • Managing IPA app files
  • Browsing the device file system through Apple File Conduit (AFC)
  • Battery diagnostics and health info
  • Real-time console log streaming
  • Viewing crash reports
  • A unique Time Machine-style 3D backup browser

All these features are integrated into a modern SwiftUI UI that follows MVVM patterns for clean separation of concerns and maintainability.

the dual backend design and technical strengths

Phosphor’s most interesting architectural choice is its dual backend system that uses pymobiledevice3 as the primary backend and libimobiledevice as an optional fallback.

pymobiledevice3 is a recent pure Python reimplementation of the entire iOS communication stack, supporting the latest iOS 17+ tunnel transport protocols. It avoids native C dependencies and works cross-platform, but here it is used exclusively on macOS wrapped as a subprocess. This backend communicates with iOS devices using JSON-based APIs, making integration simpler and more robust against changes in Apple’s undocumented protocols.

Libimobiledevice, on the other hand, is a mature, C-based toolset widely used in the community. It’s used here only as a fallback, wrapped as a CLI subprocess for compatibility with older devices or edge cases where pymobiledevice3 might not yet support a feature.

By wrapping these backends as subprocesses, Phosphor avoids the complexity and brittleness of directly embedding C libraries in Swift, which can introduce dependency hell and maintenance overhead. It’s a clear tradeoff: subprocess calls add some overhead and complexity in interprocess communication, but they significantly simplify the Swift app’s architecture and dependency graph.

Another technical strength is the direct parsing of Apple’s backup SQLite databases using the system sqlite3 CLI rather than any external Swift database libraries. This zero-dependency approach reduces the app’s footprint and makes it more robust against external library changes.

Overall, the codebase is surprisingly clean for a project bridging SwiftUI and Python subprocesses. The MVVM architecture helps keep the UI layer decoupled from the backend logic. However, relying on subprocess wrappers can introduce performance overhead and complicate error handling compared to native bindings.

quick start with phosphor

Phosphor offers straightforward installation options documented in its README:

brew tap momenbasel/phosphor
brew install --cask phosphor

Manual installation

  1. Download the latest .dmg from the Releases page.
  2. Drag Phosphor.app into your Applications folder.
  3. Install the primary backend: pip3 install pymobiledevice3.
  4. (Optional) Install fallback tools: brew install libimobiledevice ideviceinstaller.

Build from source

# Install pymobiledevice3 (primary backend)
pip3 install pymobiledevice3

Requirements:

  • macOS 14.0 (Sonoma) or later
  • pymobiledevice3 (primary backend, supports iOS 17–26+)
  • libimobiledevice and ideviceinstaller (optional fallback)
  • ifuse (legacy file mounting, not needed with pymobiledevice3)

Phosphor automatically detects available backend tools on launch and chooses the best one.

verdict

Phosphor is a solid, no-nonsense open-source alternative to commercial iOS device managers, especially for macOS users who want local control without subscriptions or cloud lock-in. Its dual-backend approach with pymobiledevice3 as the modern primary and libimobiledevice fallback is a pragmatic tradeoff that balances compatibility with maintainability.

The choice to wrap these backends as subprocesses instead of native bindings keeps the SwiftUI app clean and free of heavy dependencies, though it may add some overhead and complexity. The zero-dependency design, including direct SQLite parsing of backups, further reduces the app’s footprint and potential points of failure.

On the downside, Phosphor requires macOS 14 Sonoma or later, which limits its user base. Also, subprocess communication and direct database parsing might not match the performance or robustness of fully native solutions. But for most users, these are reasonable tradeoffs.

If you need a free, open-source iOS device manager for macOS with features like backups, message export, file browsing, and crash logs, Phosphor is worth exploring. It’s especially relevant to technically minded users who appreciate the clean SwiftUI architecture and do not want to rely on subscription services or iCloud.

The project’s active use of pymobiledevice3 also highlights a growing ecosystem of Python-based iOS device tooling that’s worth keeping an eye on.

brew tap momenbasel/phosphor
brew install --cask phosphor

This command is the quickest way to get the app installed and running on a supported macOS system.

→ GitHub Repo: momenbasel/Phosphor ⭐ 313 · Swift