Shelly 3.1.2: Making Arch Package Management Easier

If you use Arch or an Arch-based distro like EndeavourOS, you are probably comfortable with pacman and an AUR helper. But Shelly 3.1.2 is a different approach. It is a modern graphical package manager that talks directly to libalpm and tries to bring native Arch packages, AUR packages, Flatpaks, and AppImages into one unified workflow. In the video I tested Shelly on EndeavourOS to see whether it really makes software management simpler or if pacman plus an AUR helper is still the more practical path.

Below I walk through what I covered in that test, what Shelly aims to solve, practical things to watch out for, and whether it might fit into your Arch workflow.

What Shelly is trying to do

Shelly is not just another GUI wrapper around pacman. According to the build I tried, it interacts directly with libalpm, the same library pacman uses. The design goal is to give Arch a more unified experience when software comes from multiple sources. That means Shelly intends to show and manage:

• Native Arch packages from official repositories.
• AUR packages.
• Flatpaks.
• AppImages.

That scope is interesting because one of the pain points on an Arch desktop is juggling package origins. You might install some apps from the repos, build others from the AUR, and sandbox or keep portable apps as Flatpaks or AppImages. Shelly tries to present all of that in a single interface.

What I did on EndeavourOS

In the video I installed Shelly on EndeavourOS and walked through the GUI. I used the search and discovery features, installed packages, and explored Shelly's AUR integration and update handling. I also looked at how it displays packages when the same application can come from multiple sources.

The testing was focused on the user experience of managing software graphically on an Arch desktop where packages have mixed origins. The idea was to answer the practical question - does Shelly simplify keeping a typical Arch desktop in good shape?

Practical strengths you should know about

• Single pane of glass: Shelly is built to show different package types in a consistent interface. If you like a GUI that reduces context switching, that is the main attraction.

• Native integration: Because Shelly talks to libalpm, it is designed to be native to Arch package management rather than a completely separate system stitched on top.

• Multi-source awareness: Shelly aims to let you see and manage packages whether they came from the official repos, AUR, Flatpak, or AppImage. For users who already mix those formats, that visibility can be helpful.

What to be cautious about - a concrete gotcha

Gotcha: do not assume a GUI hides the differences between package sources. Even though Shelly presents everything together, packages still come from different systems that behave differently. For example, Flatpaks and AppImages are not managed by pacman, and AUR packages are community-sourced and usually require a build step. Treat Shelly as a management front end, not an abstraction that removes the need to understand where software comes from.

A common mistake is to install an app from one source without realizing another copy exists from a different source. That can lead to duplicate entries, confusing update behavior, or picking the wrong origin for your workflow. Always check the package origin before you apply updates or remove software.

Pacman plus an AUR helper - still valid

One of the core questions I investigated was whether Shelly actually improves on the classic pacman plus an AUR helper workflow. The short answer is: it depends on what you want.

If you are comfortable on the command line and rely on pacman plus your AUR helper, you already have a fast and well-understood workflow. Shelly adds a GUI that may make things easier for users who prefer visual tools or want a single view for Flatpaks and AppImages. But the underlying package behaviors and trust boundaries still exist, so knowledge of pacman and the AUR remains important.

AUR integration - something to verify

Shelly advertises AUR integration, which is one of the compelling reasons to try it on Arch. A practical tip here is to verify how Shelly handles AUR builds and dependencies for packages you install. AUR packages are not official repo binaries, so you should expect build steps or prompts related to compilation and review of PKGBUILDs. Do not blindly assume any GUI will make AUR installs as transparent as installing from the official repos.

Updates and maintenance

Shelly also includes update checking across the different package types. Seeing updates from multiple sources in one place is convenient, but again be mindful of differing update lifecycles. Flatpaks may update independently, AppImages might not have automatic updates in the same way, and AUR packages depend on whether the maintainer updated PKGBUILDs or whether you are rebuilding from sources.

My testing looked at the experience of checking for and applying updates in Shelly to assess whether it makes multi-source maintenance less error-prone. The interface can be helpful to spot items that need attention, but it is still a good idea to understand how each backend updates software.

When Shelly might be a good fit

• You prefer a graphical interface and want a single place to see apps from repos, AUR, Flatpak, and AppImage.
• You are new to Arch and want a less steep UI-driven introduction to software on the platform.
• You run a desktop that mixes package types and want better visibility of what is installed where.

When to stick with pacman and an AUR helper

• You rely on scripted or repeatable command line workflows.
• You run servers or critical systems where GUI tools are unnecessary or undesirable.
• You prefer the speed and transparency of pacman and are already comfortable resolving AUR build issues manually.

What I did not cover in depth here

The video is an initial, practical look. There is more to Shelly that deserves separate attention. In a deeper follow up I plan to explore Shelly's CLI, its native package builder, the Flatpak backend and AppImage support in greater detail, and maintenance features like how it handles package signatures and rollback scenarios.

Final thoughts

Shelly 3.1.2 is an interesting step toward a unified software experience on Arch. It is more than just a pretty GUI because it interacts with libalpm and tries to bring the different packaging worlds together. That can be genuinely useful for desktop users who want a single management surface.

However, a GUI does not remove the need to understand the origins and update behavior of packages. A practical approach is to try Shelly for day-to-day GUI management while keeping pacman and your AUR workflow knowledge handy for troubleshooting and advanced tasks.

If you watched the video, you saw the live test on EndeavourOS where I install Shelly, poke around the interface, and deliberate whether it improves the Arch experience. If you want the deeper technical follow up on CLI features, native building, and backend behavior, I will be covering that in the next video.

Thanks for reading. If you liked the walkthrough, drop a like on the video and subscribe for more hands-on Linux content.

Josh KeepItTechie