# Zebra: a graphical APT front end for jailbroken iPhones, built on Theos and a Debian package system

> Zebra is a Swift package manager for jailbroken iOS devices that puts APT, the Debian package tool, behind a phone interface, so tweaks and themes install the way software installs on a desktop. The current branch is Zebra 2, which requires iOS 14 and macOS 11, and the build is a Theos project with a Mac Catalyst target and a set of preprocessor-driven alpha and beta identities.

**zbrateam/Zebra** — 🦓 A Useful Package Manager for iOS

- Repository: https://github.com/zbrateam/Zebra
- Website: https://getzbra.com
- Stars: 1,282 · Forks: 203
- Language: Swift
- License: GPL-3.0
- Published: 2026-10-19 · Updated: 2026-10-19 · Language: en
- Canonical page: https://hysenlabs.com/projects/zbrateam-zebra

## The package format underneath is Debian's

Zebra, formerly AUPM, is a package manager for jailbroken iOS devices, and it allows you to install tweaks, themes and other utilities that are not available through the App Store.

The important technical fact is the one in the second sentence of the description. Zebra uses the Advanced Packaging Tool, APT, originally developed by the Debian project. That is not a loose analogy. It means the repositories, the package format, the dependency metadata, the version pinning and the upgrade mechanics on an iPhone are the same machinery that a Debian server uses, and the topic list records it plainly with apt and debian among the tags.

The consequences of that choice run through the whole design. A package is a .deb, an install is an unpack into the right paths on the device, and a repository is a signed index the client fetches and trusts. When a tweak is updated, the mechanism is the same as apt-get upgrade. When a tweak has a dependency, the dependency is expressed in the same way and resolved by the same tooling. None of that is the iOS way, and all of it is why the project needs Theos and Procursus rather than a normal Xcode application.

The project is Swift, licensed under the GNU General Public License version 3.0, with the homepage at getzbra.com. The last push was on 2026-08-07, and the releases are v1.1.37 from 2026-08-07, v1.1.36 from 2023-09-10 and v1.1.35 from 2023-06-18, so the current version of the package manager jumped ahead after a long gap.

Zebra was originally developed by Wilson Styres and Andrew Abosh, and the repository root still carries a `control` file, which is the Debian package control file, sitting alongside the Xcode project.

## Two branches, two iOS floors, and the difference matters before you install

The README opens the version discussion with a blockquote that a new user has to read carefully, because the two branches are not interchangeable.

This branch corresponds to Zebra 2, which is currently in active development. Zebra 2 supports iOS 14 and macOS 11. If you are looking for Zebra 1, that is the current stable release supporting iOS 9 to 14, and it lives on the v1 branch.

So the default branch of the repository is the unstable one. That is unusual for a package manager and it is worth internalising before you install anything, because the two branches have different system requirements and different stability, and a device on iOS 15 or later has only one of them available.

The macOS situation is the other half of that. A stable release of Zebra for macOS is not yet available, and the README says you can build Zebra from source to try out the latest unfinished state of Zebra on macOS. To do that you need Procursus installed on your Mac, which the README describes as similar to Homebrew or MacPorts but based on the APT package management system that Zebra is built for.

That is a coherent arrangement. Since the package format and the tooling are Debian's, the natural way to run a Zebra client on a Mac is inside a Debian-derived package manager, and Procursus is exactly that. The README frames the Mac path as a developer route, for trying out an unfinished state, and the iOS path is the one with a stable release.

The installation routes on iOS are simple by comparison. Visit getzbra.com on the device and it guides you through the process, or download from the GitHub releases directly. There is also a Crowdin badge for translations and a build badge pointing at a GitHub Actions workflow.

## The build is a Theos project with a Mac Catalyst path and a macOS APT passthrough

The build instructions are four steps and split into two routes, and the macOS route has a detail that says a lot about how the project is put together.

You need a Mac with Xcode installed. To install on an iOS device you need Theos, and to install on a macOS device, including the iOS Simulator, you need Procursus.

```bash
git clone --recursive https://github.com/zbrateam/Zebra.git
cd Zebra
```

The clone is recursive because the repository carries a .gitmodules file, so the dependencies come with it.

For macOS, you open Zebra.xcworkspace, select Mac Catalyst, and click Run. You can also test the app on iOS by selecting an iOS simulator. The README then says this will pass through to the APT and dpkg installation on your Mac, which is the crux of the design. The graphical application is the client, and the actual package work is done by APT and dpkg running in the Procursus environment on the same machine. The Mac Catalyst build of the Swift app drives a Debian package manager running natively on macOS.

For an iOS device, the step is make do, which is a Theos target that builds and installs a Debian package onto a jailbroken device through the Theos toolchain.

The repository root shows what the build produces. There is a Zebra.xcodeproj, a Zebra.xcworkspace, a Makefile, a Vendor/ directory for the vendored dependencies, and three Swift components with names that say what they do: Zebra/ is the app itself, Relaunch/ is a component that restarts the application after an install, and Supersling/ is a component whose name matches the file extension format used by the jailbreak tooling. There is also a Catalyst Helper/ directory, which is the piece that makes the Mac Catalyst route work, and a control file, a layout/ directory and a crowdin.yml.

The README is also unusually candid about the code quality, inviting pull requests that fix awful code and noting there is likely a lot of it.

## The Makefile switches between Zebra, Zebra-Beta and an alpha build

The Makefile is short and it is where the release identity is decided, which is a useful thing to understand before building.

Three variables control it, and the first is a TODO comment that says to remove it when the project advances to beta:

```make
ALPHA := 1

ALPHA ?= 0
BETA ?= 0
```

The default is ALPHA set to 1, so a plain build produces the alpha. The three branches assign three different identities. The alpha build gets the app name Zebra with the library execution folder zebralpha. The beta build gets the app name Zebra-Beta with the folder zebeta. The default build, with both flags at 0, gets the app name Zebra with the folder zebra. The bundle identifier is com.getzbra.zebra2 in all three cases, so the identity is distinguished by app name and install path rather than by bundle id.

The platform condition is the other half:

```make
ifeq ($(PLATFORM), mac)
	export TARGET = uikitformac:latest:14.2
else
	export THEOS_PACKAGE_SCHEME = rootless
	export TARGET = iphone:latest:15.0
	export ARCHS = arm64
endif
```

The rootless package scheme is the modern jailbreak layout, where the package installs under /var/jb rather than at the system root, and restricting ARCHS to arm64 matches current iPhones. The mac target is a UIKit-for-Mac image, which is a different approach to the Catalyst build described in the README, since it builds the UIKit application natively for macOS rather than running the iOS build through Catalyst.

The after-stage hook then does something worth noting:

```make
after-stage::
	chmod 6755 $(THEOS_STAGING_DIR)/usr/libexec/$(LIBEXEC_FOLDER)/supersling
```

The setuid bit on the Supersling helper is what allows the package manager to perform the privileged filesystem operations that installing a tweak on a jailbroken device requires. The helper is a separate binary with elevated rights, and the rest of the app talks to it.

The commented-out before-package block shows the same idea for naming: it would rewrite the Name and Package lines in the staged control file to mark a build as alpha or beta, and that code is disabled in favour of the separate APP_NAME and LIBEXEC_FOLDER values.

## The scam warning is the most important paragraph in the README

One paragraph in the installation section is set apart from the rest, and it is the kind of thing that tells you what the project's real problems are.

Zebra and jailbreaks are always free. Anyone suggesting you can install Zebra without a jailbreak, or accepting payment to download Zebra, is a scam. If you paid for Zebra or a jailbreak, contact your bank to file a chargeback.

That is a direct warning about a real and recurring fraud in the jailbreak community, where a paid installer or a paid download of a free package manager is a common scam, and the response it recommends is a chargeback rather than a support request. The README also states that Zebra requires a jailbroken iOS device, defines jailbreaking as the process that gives access to the tweaks, themes and other tools you can install through Zebra, and points at ios.cfw.guide for how to jailbreak.

The second half of the scam is the one that touches the software boundary. A claim that you can install Zebra without a jailbreak is not a misunderstanding, it is a product that is doing something different from what Zebra does, usually something that exploits a vulnerability or a misconfiguration, and it is the thing most likely to be sold under this project's name.

For a reader deciding whether to install, that paragraph is the one to read twice. The legitimate route is getzbra.com on the device, or the GitHub releases, and the requirement is a jailbroken device.

One more detail from the same area: the bug reports and feature requests are tracked in the GitHub Discussions tab rather than in issues, and the README asks for the required fields to be filled in to give a bug a chance of being fixed, saying that additional information may be required to isolate the issue. There is also a Discord server, and you can email a report from within Zebra itself if you do not have a GitHub account.

## Where Zebra is the wrong tool

The limits are clear, and most of them come from the platform rather than from the project.

The first is the jailbreak requirement. Zebra is a package manager for jailbroken iOS devices, and it cannot run on an unjailbroken phone at all. That is not a limitation of the implementation, it is the point of the tool, and it means every user is also a user of an unrooted, unreviewed operating system modification. A company that manages iOS devices for its staff will have policies against that, and a project with a compliance requirement will not be adopting this.

The second is the branch situation. The default branch is the in-development Zebra 2 and the stable line is on a separate v1 branch, and the macOS build has no stable release at all. Anyone who wants a stable package manager on a Mac has to build an unfinished version from source against Procursus, and anyone on the main branch is running a build whose identity the Makefile calls alpha by default.

The third is that the macOS route needs a Debian package manager on a Mac. Procursus is a large installation, and it exists so that the APT client that does the real work has the environment it expects. That is a coherent design and a heavy dependency for a Mac user who just wants a nicer interface over a package format.

The fourth is the scope of the package sources. Zebra installs from APT repositories, and the quality and safety of what it installs is a property of the repositories it is pointed at, not of Zebra. The project is a client, and the README does not describe a curated or signed repository of its own beyond what the existing package sources provide.

The fifth is that this is a client, not a publishing tool. Nothing in the README describes how to package and sign a tweak for distribution through Zebra, so a developer who wants to ship a tweak is looking for documentation that is not in this repository, and a user who wants to install an arbitrary .deb is relying on the repository it came from.

The sixth is the build dependency footprint. Compiling from source means a Mac with Xcode, Theos for a device build, Procursus for a Mac build, a recursive clone, and a Makefile whose platform and channel variables have to be set the way you want. The README's own invitation to fix awful code is a fair signal of how much of this is a single small team's work.

## Conclusion

Zebra is worth adopting for anyone with a jailbroken iPhone who wants the App Store out of the picture, because it is a real package manager with dependency resolution, repositories and a native interface rather than a settings panel with a list of tweaks. It is the wrong tool for an unjailbroken device, where it cannot run at all, and the wrong tool for a developer who wants to ship a tweak rather than install one, since the release and signing path is not described here. Before installing, read the jailbreak guidance at ios.cfw.guide, decide whether you want the stable v1 branch or the in-development Zebra 2, and note that the macOS build has no stable release, so Mac users are building from source with Procursus.

## FAQ

### What is Zebra and what does it do?

Zebra, formerly AUPM, is a package manager for jailbroken iOS devices that lets you install tweaks, themes and other utilities not available through the App Store. It uses the Advanced Packaging Tool, APT, originally developed by the Debian project, and is written in Swift under GPL-3.0.

### Which iOS versions does Zebra support?

Zebra 2, which is the branch this repository is on and which is in active development, supports iOS 14 and macOS 11. Zebra 1, the current stable release supporting iOS 9 to 14, is on the separate v1 branch. There is no stable release of Zebra for macOS yet.

### How do I install Zebra on an iPhone?

Visit getzbra.com on the device and follow the guided installation, or download from the GitHub releases. Zebra requires a jailbroken device, and the README notes that Zebra and jailbreaks are always free, so anyone asking you to pay for Zebra is running a scam.

### What do I need to build Zebra from source?

A Mac with Xcode, plus Theos to install onto an iOS device, or Procursus to install onto macOS or the iOS Simulator. Clone the repository recursively, then for macOS open Zebra.xcworkspace and select Mac Catalyst, or for a device run make do.

### How do I report a bug in Zebra?

Zebra tracks bugs and feature requests through the Discussions tab on its GitHub repository, and the README asks that the required fields are filled in so the report has a chance of being fixed. You can also email a report from within Zebra or use the Discord server.

## Sources

- [License: GPL-3.0](https://github.com/zbrateam/Zebra/blob/main/LICENSE)
- [Project website](https://getzbra.com)
- [README](https://github.com/zbrateam/Zebra/blob/main/README.md)
- [Releases](https://github.com/zbrateam/Zebra/releases)
- [zbrateam/Zebra on GitHub](https://github.com/zbrateam/Zebra)

---

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