I'm running Linux Mint Debian Edition on a roughly 2017 Lenovo Chromebook with a soldered 32GB eMMC drive and 4GB of RAM. I rely on this machine for nearly everything, so I'd like to reduce storage pressure and avoid unnecessary wear on the internal flash storage.
I usually keep applications on the eMMC drive and personal data on microSD cards. After removing my Flatpak installations, I downloaded the equivalent AppImages and was surprised to recover about 9GB of internal storage. The AppImages for the same applications occupy only around 1.3GB on the microSD card.
I expected AppImages to be larger because they bundle their dependencies instead of sharing them. Why might the Flatpak versions have used so much more space? Are there meaningful downsides to AppImages, and what problems does Flatpak solve that AppImage does not? Also, is using swap on a 4GB system likely to harm the eMMC, or should I measure that instead of assuming?
4 Answers
Flatpaks use runtimes, which are collections of shared libraries that applications can depend on. Those runtimes can be reused by several programs, but different applications may require different runtimes or versions. A runtime also contains a broad set of libraries that an app might need, not just the exact files it uses.
An AppImage is usually packaged more narrowly: the application plus the libraries it actually needs, along with some packaging overhead. So an AppImage can absolutely be smaller in a particular case, especially if the Flatpak installation left behind unused runtimes or desktop-related dependencies. The two formats aren't guaranteed to have similar sizes.
Don't assume the machine is hitting swap frequently just because it has 4GB of RAM. Check it with `free -h`, `swapon --show`, or the system monitor while doing your normal work. Linux may use some swap even when memory pressure is modest, and that alone isn't necessarily a problem.
Heavy swapping can add writes to the eMMC, but storage wear depends on the amount of data written, the drive's controller, and its available spare space. Keeping plenty of free space, avoiding unnecessary write-heavy workloads, and maintaining backups are sensible precautions. Moving applications to another device may reduce internal writes, but it won't guarantee a longer lifespan.
Fair point. I was treating swap usage as evidence of constant swapping, but I should monitor it during actual workloads instead of guessing from the system monitor.
An AppImage is commonly a compressed filesystem image mounted through FUSE when it runs. That can add a little startup overhead, and an application that constantly reads large amounts of data from the image may be marginally slower. Usually the difference is measurable rather than noticeable.
Running the AppImage from a microSD card may matter more than the format itself, since many cards are slower and less durable than internal storage. Keep backups either way, because neither package format protects against a failing drive or card.
AppImages are convenient and portable, but they don't provide everything Flatpak does. They generally don't update themselves, so you need to replace them manually or use an update tool. Integration with menus, file associations, desktop themes, permissions, and sandboxing can also be less consistent.
Flatpak's main advantages are consistent packaging across distributions, controlled application permissions, centralized updates, and runtimes that can be shared by multiple apps. Whether those benefits matter depends on how much you value convenience and isolation versus keeping the installation small and simple.
That explains the unexpected result. I had removed unused packages first, but it looks like several gigabytes of runtime and desktop libraries were still associated with the Flatpak setup.