I break things. A lot.
When you’re constantly tinkering with system configs, testing new tools, and treating your daily driver like a development sandbox, it’s inevitable. One misconfigured service, one bad command, one “let me just try this” experiment, and suddenly you’re staring at a system that won’t boot or a desktop that won’t start.
If you’re a developer on Pop!_OS—or any Linux distro—and you don’t have BTRFS with snapshots configured, you’re living dangerously. One wrong move and you’re looking at hours of recovery work or a clean reinstall.
That’s why I converted my Pop!_OS installation to BTRFS even though System76 doesn’t ship it by default. And that’s why I built btrfs-assistant from source—because managing BTRFS snapshots through CLI commands is like maintaining paper ledgers in 1981. It works, but why would you?
Why BTRFS Matters for People Who Tinker
I’ve wanted BTRFS on Pop!_OS since the beta days. System76 uses ext4 by default, which is rock solid and boring—exactly what most users need. But for developers who constantly experiment? BTRFS snapshots are a safety net that lets you actually break things without fear.
Here’s what BTRFS gives you:
Automatic snapshots before updates. With Snapper configured on your root filesystem, you get automatic pre and post snapshots every time you install or update packages. No manual intervention. No remembering to take a snapshot. It just happens.
Instant rollback capability. Broke your system with a bad config or update? Roll back to right before it happened. No reinstall. No rescue USB. Just boot into a snapshot and you’re back.
Copy-on-write efficiency. Snapshots don’t duplicate your entire filesystem. They only store what changes. A fresh snapshot uses almost no disk space.
Subvolume snapshots. You can snapshot just your home directory, just your root filesystem, or both. Surgical precision instead of full system backups.
I followed Willi Mutschler’s excellent guide to convert my Pop!_OS installation to BTRFS. It’s comprehensive, well-tested, and works perfectly on Pop!_OS 24.04. If you haven’t done the conversion yet, start there.
Important note about the guide: Mutschler’s guide includes instructions for installing Timeshift and timeshift-autosnap. Those are valid options, but if you’re planning to use Snapper and btrfs-assistant (which I recommend), skip the Timeshift installation steps. Timeshift and Snapper can conflict with each other, and honestly, Snapper has much better native BTRFS support. It was designed specifically for BTRFS, while Timeshift was originally built for rsync backups and added BTRFS support later.
Instead, install Snapper:
sudo apt install snapper
Snapper integrates directly with BTRFS subvolumes and provides the automatic pre/post snapshot functionality that makes the whole system worthwhile. btrfs-assistant is essentially a GUI frontend for Snapper—they work together beautifully.
But here’s the problem with managing Snapper manually: the command-line interface is tedious. You can do everything through CLI tools, but for someone who just wants snapshots to work without ceremony? There had to be a better way.
Enter btrfs-assistant
btrfs-assistant is a Qt6 GUI application that makes BTRFS snapshot management actually pleasant. It integrates with Snapper, lets you browse and restore snapshots with a few clicks, and handles all the complexity behind a clean interface.
The catch? It’s not in the Pop!_OS 24.04 or Ubuntu 24.04 repositories. So if you want it, you’re building it from source.
And honestly? That’s fine. It’s a straightforward build, and once it’s done, you have a genuinely useful tool that makes BTRFS snapshots feel like a first-class feature instead of something you need to script around.
Building btrfs-assistant from Source
This guide assumes you’ve already:
- Converted Pop!_OS to BTRFS using Mutschler’s guide
- Installed Snapper (not Timeshift) with
sudo apt install snapper
If you haven’t done both of those, do them first. btrfs-assistant is a frontend for Snapper, so without Snapper installed, it won’t have much to manage.
Time required: 10-15 minutes
Difficulty: You need to be comfortable with terminal commands and building from source
Step 1: Enable Universe Repository
The build dependencies live in Universe, so make sure it’s enabled:
sudo add-apt-repository universe
sudo apt update
Step 2: Install Build Dependencies
This is the kitchen sink of development packages. Qt6, cmake, BTRFS libraries, polkit for privilege escalation—everything needed to compile a modern Qt application:
sudo apt install -y \
qt6-base-dev \
qt6-base-dev-tools \
libqt6core6t64 \
libqt6gui6t64 \
libqt6widgets6t64 \
qt6-svg-dev \
qt6-l10n-tools \
qt6-tools-dev \
qt6-tools-dev-tools \
libgl1-mesa-dev \
cmake \
build-essential \
git \
btrfs-progs \
libbtrfs-dev \
libbtrfsutil-dev \
libbtrfsutil1t64 \
policykit-1 \
libpolkit-gobject-1-dev \
libpolkit-agent-1-dev \
diffutils \
util-linux
This will pull in a lot of packages. That’s normal. Qt6 has a lot of pieces.
Step 3: Clone and Build
Download the source and compile it:
cd ~/Downloads
git clone https://gitlab.com/btrfs-assistant/btrfs-assistant.git
cd btrfs-assistant
mkdir build
cd build
Configure the build with cmake:
cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release ..
If cmake completes successfully, you’ll see “Configuring done” and “Generating done”. If it fails, you’re missing a dependency—check the error message and install whatever package it’s complaining about.
Compile with all available CPU cores:
make -j$(nproc)
This takes 1-3 minutes depending on your CPU. Modern systems will breeze through it.
Step 4: Install
sudo make install
This installs:
- Binary to
/usr/bin/btrfs-assistant - Desktop entry for your application menu
- Config files to
/etc/
Step 5: Verify It Works
which btrfs-assistant
btrfs-assistant
The application should launch. You’ll see your BTRFS subvolumes, any existing Snapper snapshots, and a clean interface for managing them.
You can also find btrfs-assistant in your application menu under System Tools.
What It Actually Does
btrfs-assistant gives you a GUI for:
Automatic pre/post snapshots. This is the killer feature. When Snapper is properly configured on your root filesystem, it automatically takes snapshots before and after package installations or system updates. Break something with an update? You have a snapshot from right before it happened, automatically.
Browsing snapshots. See all your Snapper snapshots in one place, with timestamps and descriptions.
Creating snapshots. One-click snapshot creation before you do something risky.
Restoring snapshots. Roll back to a previous snapshot without touching the terminal.
Managing subvolumes. View your BTRFS subvolume layout and properties.
Configuring Snapper. Adjust snapshot retention policies, automatic snapshot schedules, and cleanup rules.
It’s the GUI layer BTRFS deserves but never really got. Once you have it installed, snapshot management stops being a chore and becomes something you actually use.
Troubleshooting
CMake can’t find Qt6
Make sure you installed all the Qt6 packages and that Universe is enabled:
ls -la /usr/lib/x86_64-linux-gnu/cmake/Qt6/Qt6Config.cmake
If that file exists, cmake should find it. If not, reinstall Qt6:
sudo apt install --reinstall qt6-base-dev
CMake can’t find BTRFSUTIL
Install the BTRFS development libraries:
sudo apt install -y libbtrfsutil-dev libbtrfsutil1t64
Application won’t launch or shows permission errors
btrfs-assistant needs polkit for privilege escalation. Verify it’s running:
systemctl status polkit
If polkit isn’t running, that’s your problem. It should be running by default on Pop!_OS.
“Package polkit-1 not found”
The package name is policykit-1, not polkit-1:
sudo apt install policykit-1 libpolkit-gobject-1-dev libpolkit-agent-1-dev
Keeping It Updated
To update btrfs-assistant when new versions are released:
cd ~/Downloads/btrfs-assistant
git pull
cd build
rm -rf *
cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Release ..
make -j$(nproc)
sudo make install
Rebuilding from a clean build directory ensures you don’t have any stale artifacts from the previous version.
Why This Matters
I’ve been using BTRFS with snapshots for months now, and it’s changed how I work on my system. I experiment more freely because I know I can roll back instantly. I take snapshots before system updates without thinking about it. When I break something—and I will break something—recovery takes seconds instead of hours.
Is BTRFS perfect? No. It’s heavier than ext4, and you need to understand subvolume layouts. Is btrfs-assistant necessary? Also no—you can manage everything through CLI tools if you’re comfortable with that.
But if you’re a developer who tinkers constantly, who experiments with system configs, who occasionally runs commands you shouldn’t—BTRFS with Snapper and proper snapshot management is a safety net worth having. And btrfs-assistant makes that safety net actually pleasant to use.
A final note on Snapper vs Timeshift: Yes, Timeshift can work with BTRFS, and many people use it successfully. But Snapper was built specifically for BTRFS from the ground up. It understands subvolumes natively, integrates seamlessly with package managers for automatic pre/post snapshots, and pairs perfectly with btrfs-assistant. For native BTRFS support, Snapper is the better choice.
Hardware got fast enough that we stopped caring about consequences. BTRFS snapshots let you care about experimentation instead of fear.
Build it. Use it. Break things confidently.
Additional Resources
