# ifuse: mounting an iPhone's media directory as a normal filesystem > ifuse is a FUSE filesystem that exposes parts of an iOS device as a local mount point, using libimobiledevice to talk to the phone. It can mount the media partition, an app's document container, or the whole filesystem on a jailbroken device. The first thing in its README is a warning that version 1.2.0 corrupts data and that 1.2.1 is the version you want. **libimobiledevice/ifuse** — A fuse filesystem to access the contents of iOS devices - Repository: https://github.com/libimobiledevice/ifuse - Website: https://libimobiledevice.org - Stars: 1,030 · Forks: 158 - Language: C - License: LGPL-2.1 - Published: 2026-10-19 · Updated: 2026-10-19 · Language: en - Canonical page: https://hysenlabs.com/projects/libimobiledevice-ifuse ## Four directories, and one of them needs a jailbreak ifuse is a FUSE filesystem implementation to access the contents of iOS devices, and it lets you mount various directories of a device locally through the FUSE file system interface. The feature list names four things it can reach. Media means mounting the media directory of an iOS device locally, which is the everyday case, the photos and the music that live in the device's own chroot. Apps means mounting the sandbox container or the document directory of an individual app, which is what you want when an app stores files you need to read. Jailbreak means mounting the root filesystem on jailbroken devices, and the feature list flags that it requires the AFC2 service. And Browse is a way to retrieve a list of the installed file-sharing enabled apps, so you can find out what is available before trying to mount it. The implementation detail that ties it together is the last bullet, that ifuse uses libimobiledevice for communication with the device. That library handles the pairing and the service negotiation, and ifuse is the part that turns the resulting file access into a filesystem. The practical consequence is that ifuse inherits libimobiledevice's requirements, including usbmuxd, which is the daemon that routes USB traffic to the right service. The project is written in C, licensed under LGPL-2.1, and is part of the libimobiledevice project, with the homepage at libimobiledevice.org. The last push to the repository was on 2026-04-22, the same day as the release that matters. ## The 1.2.0 regression that silently corrupts data The README opens with a warning, and it is the first thing anyone installing this should read. Version 1.2.0 has a serious bug that results in data corruption. The regression was introduced in a specific commit, 36956a, and fixed in version 1.2.1 with commit 903a29. What makes this worth dwelling on is not that there was a bug. Every project has bugs. It is that the bug is silent. A filesystem that corrupts files does not announce itself, and a user who mounts a phone, copies a few photos off it, unmounts and finds the originals unreadable has a very bad afternoon, and may not connect it to the tool version. The commit references in the warning are there so that a user can check exactly what changed and whether their build contains the fix. So the version rule is simple. Use 1.2.1 or later, released on 2026-04-22, and if you are on 1.2.0, which came out on 2025-10-14, upgrade before you mount anything. The wider history is worth noting too, because it explains the version numbers. The release before 1.2.0 is 1.1.4 from 2020-06-15, so there was a long stretch where the project was barely releasing, and then 1.2.0 arrived in October 2025 with a change that broke the one thing a filesystem must not break, and 1.2.1 arrived six months later to fix it. That is the shape of a project that came back from dormancy, and it is a reasonable thing to keep in mind when deciding how much to trust the next release. ## Building on Linux means usbmuxd and the fuse group The build is autotools based, and the Linux prerequisites are listed as one command. ```shell sudo apt-get install \ build-essential \ pkg-config \ checkinstall \ git \ autoconf \ automake \ libtool-bin \ libplist-dev \ libimobiledevice-dev \ libfuse3-dev \ usbmuxd ``` The two entries that are not obvious are usbmuxd and libfuse3-dev. The README states that usbmuxd must be properly installed for ifuse to be able to communicate with devices, which is the daemon that multiplexes the USB connection to the right service, and without it ifuse has nothing to talk to. The FUSE permissions are the other classic stumbling block, and the README has a specific fix for it. ```shell sudo modprobe fuse sudo adduser $USER fuse ``` You can then check your membership of the fuse group, and the check is written as a shell one-liner that prints a cheerful message or a less cheerful one. ```shell id | grep fuse && echo yes! || echo not yet... ``` And there is a detail that wastes an hour if nobody told you: if you have just added yourself, you need to log out and log back in for the group change to become visible. The same membership is what the usage section warns about, since the system may complain that /etc/fuse.conf is not readable when you mount as a regular user. ## macOS needs macFUSE and a system extension approval The macOS route is longer, and the reason is that FUSE is not part of the operating system there. The first step is the Xcode command line tools, and then automake, autoconf and libtool from either MacPorts or Homebrew. ```shell brew install libtool autoconf automake ``` After that comes the part that eats an evening. ifuse has a few dependencies from the libimobiledevice project, and on macOS you have to build and install four of them yourself: libplist, libimobiledevice-glue, libusbmuxd and libimobiledevice, with their own readme instructions for building each one. Then the FUSE layer. You download the macFUSE disk image, mount it and run the Install macFUSE installer, which also installs the libfuse library and the development files. The final step is worth reading carefully. For macFUSE to work, you have to allow the macFUSE system extension in Settings, then Privacy and Security, then Security, and the README says that changes will require a system restart. The README notes that changes will require a system restart. So the macOS build is: four libraries from source, an installer, a settings toggle and a reboot. The Linux build is one apt command. That asymmetry is the honest cost of FUSE on macOS. ## Configuring from git or from a tarball, then make The source tree has to be configured before it can be built, and the procedure differs depending on where you got the code. From a git checkout you clone and change into the directory, then run the autogen script, which generates and calls configure. ```shell git clone https://github.com/libimobiledevice/ifuse.git cd ifuse ./autogen.sh ``` From an official release tarball the procedure is slightly different, because the configure script is already there. ```shell tar xjf ifuse-x.y.z.tar.bz2 cd ifuse-x.y.z ./configure ``` Both scripts accept options such as --prefix for a different target folder, and the README shows the invocation. ```shell ./autogen.sh --prefix=/usr/local ``` When the configuration succeeds, the last few lines of output tell you what was configured and what to do next, listing the install prefix and telling you to type make to build and then make install for installation. The build itself is the standard pair. ```shell make ``` And the install depends on whether the current user can write to the destination directory. ```shell make install ``` Or, with sudo, if they cannot. The repository is a classic autotools tree, with configure.ac, Makefile.am, autogen.sh and a git-version-gen script that derives the version from the git metadata. ## Mounting the media directory, and the root filesystem option Usage is one command. To mount the media partition from the device you run ifuse with a mount point, and the device appears there as an ordinary directory. ```shell ifuse ``` Unmounting as a regular user is fusermount with the -u flag and the same mount point. ```shell fusermount -u ``` The default behaviour is the safe one, and the README says so. By default, ifuse via the AFC protocol gives access to the /var/mobile/Media/ chroot on the device, containing music and pictures, and the README calls this the right and safe way to access the device. The other mode is for jailbroken devices. If the device has been jailbroken, a full view of the device's filesystem might be available with the --root flag. ```shell ifuse --root ``` The caveat is in the same paragraph and it is a practical one. Only older jailbreak software installed the necessary AFC2 service on the device to enable root filesystem usage, and the README names blackra1n as an example that does not install it. So --root on a modern jailbroken phone is likely to fail for reasons that have nothing to do with your command line. The whole design rests on the fact that a mount is a filesystem, so a copying script, a backup tool or a media player sees the same thing any other tool would. ## Conclusion ifuse fits a Linux or macOS user who needs to get files off an iPhone, or to script something that reads an app's document container, without going through iTunes or a desktop application. It does not fit anyone running version 1.2.0, which corrupts data, and it does not fit a workflow that needs the full device filesystem on a modern jailbreak, since that requires the AFC2 service that only older jailbreak software installed. Verify three things before you mount anything: that you are on version 1.2.1 or later, that the fuse kernel module is loaded and your user is in the fuse group, since a mount that appears to work without the group membership is the classic failure here, and that usbmuxd is running, because without it ifuse cannot talk to the device at all. ## FAQ ### What can ifuse mount from an iOS device? Four things, per the feature list: the media directory of the device, the sandbox container or document directory of an app, the root filesystem on jailbroken devices when the AFC2 service is available, and a listing of installed file-sharing enabled apps. Communication with the device is handled by libimobiledevice. ### Which version of ifuse should I install? Version 1.2.1 or later. The README warns that version 1.2.0 has a serious bug that results in data corruption, introduced in commit 36956a and fixed in 1.2.1 with commit 903a29. Older binaries always mount without complaining, so the version has to be checked deliberately. ### How do I mount and unmount an iPhone with ifuse? Run ifuse with a mount point, for example ifuse , and unmount as a regular user with fusermount -u . By default the mount exposes the /var/mobile/Media/ chroot through the AFC protocol, which the README describes as the right and safe way to access the device. ### How do I get the full filesystem from a jailbroken iPhone? Mount with the --root flag, ifuse --root . This requires the AFC2 service, and the README notes that only older jailbreak software installed it, naming blackra1n as an example that does not, so the option frequently fails on modern jailbreaks for reasons unrelated to the command. ### What are the build dependencies for ifuse? On Debian and Ubuntu the list is build-essential, pkg-config, checkinstall, git, autoconf, automake, libtool-bin, libplist-dev, libimobiledevice-dev, libfuse3-dev and usbmuxd, and usbmuxd must be running for the tool to reach a device. On macOS you need the Xcode command line tools, automake, autoconf and libtool, the libimobiledevice libraries built from source, and macFUSE installed and approved in Privacy and Security, which requires a restart. ## Sources - [libimobiledevice/ifuse on GitHub](https://github.com/libimobiledevice/ifuse) - [License: LGPL-2.1](https://github.com/libimobiledevice/ifuse/blob/master/LICENSE) - [Project website](https://libimobiledevice.org) - [README](https://github.com/libimobiledevice/ifuse/blob/master/README.md) - [Releases](https://github.com/libimobiledevice/ifuse/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/libimobiledevice-ifuse