If you’ve spent any real time babysitting audio playback on a Linux desktop, you already know the story: Rhythmbox feels abandoned, Clementine hasn’t seen a meaningful commit in years, and VLC, while reliable, was never really built for people who obsess over tag metadata, gapless playback, and layout customization. Fooyin fills that gap. It’s a Qt6-based, lightweight, and genuinely fast music player that behaves more like foobar2000’s spiritual successor on Linux than anything else currently in the ecosystem.

The timing matters too. Ubuntu 26.04 LTS ships with a newer Qt6 stack, updated PipeWire defaults, and a leaner base image than its predecessor—which means the usual friction points around audio backend compatibility and missing shared libraries are mostly gone. That doesn’t mean installation is foolproof, though. Depending on which repository you pull from, you can still hit dependency mismatches, especially if you’re running a minimal server install or a hardened desktop image stripped of GUI toolkits.

This guide walks through every practical installation path—native .deb packages, Flatpak, Snap, and compiling from source—because in a production or semi-production environment, the “best” method depends entirely on your constraints. A workstation with unrestricted internet access and Flathub configured will have a very different optimal path than an air-gapped build server or a locked-down corporate desktop image. Along the way, we’ll cover dependency resolution, systemd/MPRIS integration, common installation errors, and the kind of performance tuning that actually matters once Fooyin is handling large libraries or streaming over network-mounted storage.

Whether you’re setting this up on a personal Ubuntu 26.04 LTS desktop or standardizing a media workstation image across a fleet of machines, the approach below reflects what actually works—not just the sanitized happy path you’ll find in most quick-start guides.

What Is Fooyin and Why It’s Worth Installing

Fooyin is an open-source, customizable music player built on Qt6 and C++20, designed around the idea that a media player shouldn’t force a rigid layout on you. It supports gapless playback, a built-in tag editor, waveform seekbars, powerful library filtering, playlist management, and native MPRIS support for desktop integration. For anyone coming from foobar2000 on Windows, the UI philosophy will feel immediately familiar—deeply modular panels you can rearrange to match your workflow rather than a fixed player chrome.

From a systems perspective, what makes Fooyin attractive isn’t just the feature set—it’s the resource footprint. Unlike Electron-based media apps that quietly eat 300-400MB of RAM for a glorified playlist, Fooyin’s native Qt6 implementation keeps memory usage lean even with libraries in the tens of thousands of tracks. That matters if you’re deploying it on lower-spec hardware, VDI environments, or thin clients where every megabyte of RAM overhead compounds across sessions.

Prerequisites Before You Start

Before touching any install command, confirm your environment. A five-minute sanity check here saves you from chasing phantom dependency errors later.

• Confirm your exact Ubuntu version and codename with cat /etc/os-release—this matters because .deb packages are often built against specific codenames.
• Verify you have at least 200MB of free disk space for the native package, more if you’re going the Flatpak route since it pulls in its own runtime.
• Make sure your audio backend (PipeWire or PulseAudio) is running: systemctl --user status pipewire or pactl info.
• If you’re on a headless or minimal server install, confirm you actually have a display server and audio hardware attached—Fooyin is a GUI application, not a daemon.
• Update your package index first: sudo apt update && sudo apt upgrade -y.

Skipping that last step is one of the most common reasons people report broken installs. An outdated apt cache means you’re often resolving dependencies against stale metadata, which triggers version conflicts that look like Fooyin’s fault but really aren’t.

Method 1: Installing Fooyin via Native .deb Package

This is the fastest path if a build matching your Ubuntu release—or a close enough one—exists on the project’s GitHub releases page. Fooyin’s maintainers publish pre-built .deb packages for Debian and Ubuntu-based systems targeting x86_64 architecture.

Step-by-Step .deb Installation

Step 1: Check your architecture.

uname -m

You should see x86_64. Fooyin’s official packages currently only target Intel/AMD 64-bit systems, so if you’re on ARM (Raspberry Pi, some ARM-based cloud instances), skip ahead to the Flatpak or source-build sections.

Step 2: Download the appropriate .deb from the releases page.

wget https://github.com/fooyin/fooyin/releases/download/v0.11.1/fooyin_0.11.1-noble_amd64.deb

Replace the version number and filename with whatever is current when you’re reading this—Fooyin ships frequent point releases. Note the noble tag in the filename; that’s the Ubuntu 24.04 codename the package was built against. Ubuntu 26.04 LTS wasn’t necessarily the target build environment at release time, but in practice these packages install cleanly on newer LTS releases because the underlying Qt6 and codec libraries maintain ABI compatibility across adjacent LTS cycles.

Step 3: Install using apt, not dpkg directly.

sudo apt install ./fooyin_0.11.1-noble_amd64.deb

This is the detail a lot of tutorials get wrong. Running sudo dpkg -i will install the package but leave you to manually resolve missing dependencies one at a time. Using apt install ./package.deb (note the leading ./) tells apt to treat it as a local package while still pulling in any missing dependency chain from your configured repositories. That single difference saves you from the classic “dpkg: dependency problems – leaving unconfigured” loop.

Step 4: Launch and verify.

fooyin

Or find it through your desktop’s application launcher. If it opens without a crash and you can see the default layout, you’re done.

Step 5 (optional): Pin the version if you manage this via configuration management.

sudo apt-mark hold fooyin

Useful if you’re deploying a standardized image and don’t want an unattended-upgrades job silently bumping the version mid-release-cycle on a fleet of workstations.

Uninstalling the .deb Package

sudo apt remove --purge fooyin

The --purge flag also removes local configuration files. If you want to keep your saved layouts and library database for a future reinstall, just use sudo apt remove fooyin instead.

Method 2: Installing Fooyin via Flatpak

Flatpak is the more portable option and arguably the safer default recommendation for most desktop users, because it isolates the application in a sandbox and ships its own runtime dependencies—meaning you’re not at the mercy of whatever Qt6 version happens to be sitting in Ubuntu’s repos.

Step 1: Install Flatpak if it’s not already present.

sudo apt install flatpak

Step 2: Add the Flathub remote.

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

Step 3: Install Fooyin from Flathub.

flatpak install flathub org.fooyin.fooyin

Step 4: Run it.

flatpak run org.fooyin.fooyin

One practical note from real-world deployment: if this is the first Flatpak app you’ve installed on a fresh Ubuntu 26.04 LTS session, log out and back in before launching. The desktop integration hooks (application menu entries, MIME associations) don’t always register until the session environment variables refresh.

Updating and Removing the Flatpak Build

flatpak update org.fooyin.fooyin
flatpak uninstall --delete-data org.fooyin.fooyin
flatpak uninstall --unused

That last command matters more than people realize—Flatpak runtimes accumulate over time, and on a machine with several sandboxed apps, unused runtimes can quietly consume gigabytes of disk space. Run it periodically as part of routine maintenance.

Method 3: Installing via Snap

Fooyin also has a Snap package, maintained under what’s listed as the “Kyu version” on the Snap Store, compatible with Ubuntu 16.04 and later. This is worth mentioning for completeness, though in practice most sysadmins gravitate toward either the native .deb or Flatpak for tighter control over update cadence.

sudo snap install fooyin

If you need access to removable media (external drives, USB storage) for your music library, you’ll need to manually connect the interface:

sudo snap connect fooyin:removable-media

Snap confinement is stricter by default than Flatpak in some respects, so if Fooyin can’t see your music files stored on an external drive, this is almost always the fix.

Method 4: Building Fooyin From Source

This is the method you reach for when you need a specific unreleased feature, you’re on an unsupported architecture, or you’re building a custom, stripped-down image where pulling in Flatpak or Snap infrastructure isn’t acceptable from a footprint or security-hardening standpoint. It’s more involved, but it’s not difficult if you follow the dependency chain carefully.

Step 1: Install Build Dependencies

sudo apt update
sudo apt install \
  g++ git cmake pkg-config ninja-build libglu1-mesa-dev libxkbcommon-dev zlib1g-dev \
  libasound2-dev libtag1-dev libicu-dev libpipewire-0.3-dev \
  qt6-base-dev libqt6svg6-dev qt6-tools-dev qt6-tools-dev-tools qt6-l10n-tools \
  libavcodec-dev libavformat-dev libavutil-dev libavdevice-dev libswresample-dev \
  libsndfile1-dev libopenmpt-dev libgme-dev libarchive-dev libebur128-dev

That’s a long list, and it’s long for a reason—Fooyin supports a wide range of audio formats and tagging systems out of the box, and each of those libraries backs a specific codec or metadata capability. If a package fails to resolve, it usually means Ubuntu 26.04 LTS renamed or split a dev package; check with apt-cache search <partial-name> before assuming the build is broken.

Step 2: Clone the Repository

git clone --recurse-submodules https://github.com/fooyin/fooyin.git
cd fooyin

Don’t skip --recurse-submodules. Fooyin pulls in several vendored dependencies as git submodules, and a shallow clone without them will fail at the CMake configuration stage with cryptic “target not found” errors that have nothing to do with your actual system libraries.

Step 3: Generate the Build Environment

cmake -S . -G Ninja -B build

Step 4: Compile

cmake --build build -j$(nproc)

The -j$(nproc) flag parallelizes the build across all available CPU cores—on a modern 8-core desktop this cuts build time from roughly 12-15 minutes down to under 4. On resource-constrained VMs, drop this to -j2 or -j4 to avoid OOM kills during the linking phase, which is genuinely the most memory-hungry part of a Qt6 build.

Step 5: Install

sudo cmake --install build

By default this installs to /usr/local. For a custom prefix—useful if you’re managing multiple versions side by side or deploying to a non-standard directory structure—pass --prefix:

sudo cmake --install build --prefix /opt/fooyin

Uninstalling a Source Build

cmake --build build --target uninstall

Keep your build directory around if you plan to do this later; CMake’s uninstall target relies on the install manifest generated during the original build.

Troubleshooting Common Installation Errors

Every real-world install eventually hits friction. Here’s what actually shows up in practice, and how to fix it without guesswork.

Error: “dpkg: dependency problems – leaving unconfigured”

This happens when you install the .deb directly with dpkg -i instead of apt install ./package.deb. Fix it by running sudo apt --fix-broken install, which resolves the dangling dependency chain, then re-run the original install command.

Error: Fooyin launches but no audio output

Usually a PipeWire/PulseAudio backend mismatch. Check which backend is active with pactl info | grep "Server Name". If Fooyin was compiled against PipeWire but your session is running plain PulseAudio (or vice versa), audio output silently fails. Restarting the audio session with systemctl --user restart pipewire pipewire-pulse resolves this in most cases.

Error: “cannot open shared object file” during launch

Common on minimal server installs or containers missing GUI-adjacent libraries. Run ldd $(which fooyin) | grep "not found" to identify exactly which shared library is missing, then install the corresponding -dev or runtime package via apt.

Error: Flatpak app icon or menu entry missing after install

As mentioned earlier, log out and back in. If that doesn’t resolve it, run flatpak update and restart the xdg-desktop-portal service:

systemctl --user restart xdg-desktop-portal

Error: CMake fails with “Could not find a package configuration file for Qt6”

This means qt6-base-dev either didn’t install correctly or your CMake isn’t finding the Qt6 config path. Explicitly point CMake at it:

cmake -S . -G Ninja -B build -DCMAKE_PREFIX_PATH=/usr/lib/x86_64-linux-gnu/cmake/Qt6

Error: Build succeeds but tag editing doesn’t persist changes

Almost always a file permissions issue, especially on network-mounted music libraries (NFS/SMB shares). Fooyin needs write access to both the audio file and its containing directory to rewrite tags in place. Check ownership with ls -la on the target directory and adjust with chown or mount options (uid=, gid= for SMB mounts) as needed.

Performance and Optimization Considerations

Once installed, a few tuning decisions genuinely affect day-to-day responsiveness, particularly with large libraries.

Library scanning and disk I/O

If your music collection lives on spinning disks or a network share rather than local SSD/NVMe, the initial library scan can take a noticeably long time and hammer disk I/O. Monitor this with iostat -x 1 while Fooyin performs its first scan. If I/O wait spikes and stays elevated, consider staging the library scan during off-peak hours, or if this is a shared workstation, ionice -c3 fooyin will run Fooyin’s I/O at idle priority so it doesn’t starve other processes.

Memory usage with large libraries

For libraries north of 50,000 tracks, Fooyin’s SQLite-backed metadata database benefits from periodic maintenance. If you notice slowdowns in search/filter operations over time, this is worth checking rather than assuming the application itself is at fault.

CPU governor on laptops

If you’re running Fooyin on a laptop and notice audio dropouts during playback under load (compiling in the background, for instance), check your CPU governor:

cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor

If it’s set to powersave and you’re hitting dropouts, switching to schedutil or performance for audio-sensitive sessions often resolves the stutter—this is the same class of fix used for professional audio workstations running JACK.

PipeWire buffer tuning

For anyone doing more than casual listening—say, gapless playback of lossless FLAC libraries—PipeWire’s default buffer size can occasionally introduce audible glitches on underpowered hardware. Adjust the quantum in ~/.config/pipewire/pipewire.conf:

context.properties = {
    default.clock.rate = 48000
    default.clock.quantum = 1024
}

Lower quantum values reduce latency but increase CPU overhead; higher values do the opposite. Tune based on your actual hardware rather than copying a value from a forum post.

Security Considerations

Media players are rarely thought of as attack surfaces, but that assumption gets people burned more often than expected—especially with tag-parsing libraries that historically have had their share of CVEs across the ecosystem.

• Keep the package updated through whichever channel you installed it from; Flatpak and Snap handle this automatically by default, but .deb installs and source builds require manual vigilance.
• If you built from source, track the upstream repository’s release tags and rebuild periodically rather than running an indefinitely aging local build.
• Sandboxed installs (Flatpak/Snap) meaningfully reduce blast radius if a malicious audio file exploits a parsing vulnerability in one of the tagging or codec libraries—this is a legitimate reason to prefer them on shared or multi-user systems.
• Restrict write permissions on shared music library directories to only the users who genuinely need to edit tags; broad 777 permissions on a shared NAS mount are a bad habit that outlives its original convenience.
• On any system exposed to the internet (unlikely for a desktop player, but relevant if you’re running this on a jump host with X forwarding), ensure your firewall isn’t inadvertently permitting inbound connections related to MPRIS’s D-Bus interface—it’s local-session-scoped by design, but audits should confirm this rather than assume it.