I did Linux From Scratch recently and they have a brilliant solution. Here's the full text but it's a long read so I'll briefly explain it. https://www.linuxfromscratch.org/hints/downloads/files/more_control_and_pkg_man.txt

Basically you make a new user with the name of the package you want to install. Login to that user then compile and install the package.

Now when you search for files owned by the user with the same name as the package you will find every file that package installed.

You can document that somewhere or just use the find command when you are ready to remove all files related to the package.

I didn't actually do this for my own LFS build so I have no further experience on the matter. I think it will eventually lead to dependency hell when two packages want to install the same file.

I guess flatpaks are better about keeping libraries separate but I'm not sure if they leave random files all over your hard drive the way apt remove/apt purge does. (Getting really annoyed about all the crud left in my home dir)

Nix

I use a mixture of systemd-nspawn and different user logins. This is sufficient for experimentation, for actual use I try to package (makepkg) those tools to have them organized by my package manager.

Also LVM thinpools with snapshots are a great tool. You can mount a dedicated LV to each single user home to keep everything separated.

Qubes: you can install software inside of its own disposable VM. Or it can be a persistent VM we're only the data in home persists. Or it can be a VM where the root persists. You have a ton of control. And it's really useful to see what's changed in the system.

All the other solutions here are talking about in the operating system, qubes is doing it outside the operating system

I use Gentoo where builds from source are supported by the package manager. ;)

Overall though, any containerisation option such as Docker / Podman or Singularity is what I would typically do to put things in boxes.

For semi-persistent envs a chroot is fine, and I have a nice Gentoo-specific chroot script that makes my life easier when reproing bugs or testing software.

I think Podman should do a good job but I never used it myself, Distrobox is build on it and a lot easier to use so that's what I would recommend!

For "desktop" stuff (gaming, office etc.) I just install bare-metal, for "server" stuff I basically only look for containerisation in the form of Podman (Docker compatible). If it doesn't exist as a compose file it isn't worth my time.

Not sure if that's a good idea but if you use Fedora, you also have your root on a BTRFS partition after a default installation. You could utilize the snapshot features of BTRFS to roll back after testing.

software like stow keeps track of files installed, and helps you remove it later

it it does not need a gui, use docker and log in into it. do the stuff and when you are done, docker rm and everything disappear.

you can enable cuda inside the container, follow the docs for that.

bonus point, vs code can open itself inside a container.

Give a look at distrobox

Have an lxc config that enables glx on x11 in the container, spin one up and throw stuff in there, temp zfs volume.

Lxc-rm when done.

@j4k3 https://github.com/89luca89/distrobox/blob/main/docs/useful_tips.md#create-a-distrobox-with-a-custom-home-directory

You can't completely remove distrobox image and contents later?

Haven't tried it (and don't use docker), so a wild shot: https://github.com/jupyterhub/repo2docker

'repo2docker fetches a repository (from GitHub, GitLab, Zenodo, Figshare, Dataverse installations, a Git repository or a local directory) and builds a container image in which the code can be executed. The image build process is based on the configuration files found in the repository.'

That way you can perhaps just delete the docker image and everything is gone. Doesn't seem to depend on jupyter..

There’s a method using systemd-sysext that would work well for this on any distro without dealing with poking holes in containers. One of the gnome folks blogged about it recently here: https://blogs.gnome.org/alatiera/2023/08/04/developing-gnome-os-systemd-sysext/

Chroot would be fine for this and not overly complicated

I've never worried about this but I'd use Flatpak. The whole install goes in a specific directory and the metadata/config/data files go in their own specific directory.

export LDFLAGS="-Wl,-rpath=/sw/app/version/lib"
./configure --prefix=/sw/app/version
make
sudo make install
unset LDFLAGS