Sway + waybar + wofi + foot plus as many Vim-like applications as I know.
Music player = cmus
File manager = vifm
Image viewer = swayimg with Vim-style movements
PDF viewer = zathura
Database client = rainfrog
Wifi controls = impala
Git user interface = tig
It's a full Sway+Vim desktop environment.
You know how some say the song sounds like Remission, some say like Blood Mountain, and the chorus with Brann singing sounds like CtS? There's even a breakdown that sounds like Capillarian Crest. On the whole the song sounds all over the place and I think it's actually on purpose. They are paying tribute to their golden albums where Brent was the most involved. They're celebrating his legacy all within one song. This song is a "Brent albums' mashup". Which is simply genius!
During all my distro-hopping (Ubuntu, Arch, Debian, Gentoo, Void) and reading about different Linux packaging systems one question has been eluding me: why do all distros insist on handling core system packages and frivolous user apps the same way? Why must every library have the same version when it's used by GNU Make and when it's used by Kdenlive? Hence, why can an upgrade in SomePeskyApp bump up package versions used by the core system, like coreutils or libinput or other system-critical stuff?
I envision a system where there are two sets of packages, @base and @user with the following rules:
@base packages can only depend on other @base packages and are updated like Debian stable (once in 2 years) or for urgent security updates
@user packages can depend on @base packages but only if the @base version satisfies their dependency; if a dep they need is missing or its version is too old, they pull in a @user dependency;
an upgrade of a @user package can never pull in an update in any @base package: they use @base only on a "take it or leave it" basis;
@user packages can have a rolling release model or have point releases that are much more frequent than 2 years, for example 3 months.
What this system achieves is that the system is stable but the user-facing software is fresh. For example, if some install script uses coreutils packages, they are always stable (provided they call them like /usr/bin/rm which is the best practice already), but the user can have a patched version of those packages in, say /usr/local/bin or whatever prefix @user packages have.
At the same time, the duplication between packages is kept to a minimum (no more than 2 versions of same package within the system).
Something like this is doable manually or via script automation, for example, on Debian. However, I wonder why nobody did a full-fledged distro based on this principle. Immutable distros are the closest thing that comes to mind but they are container-based which is a whole different can of worms. FreeBSD is based around some kind of similar principle, I've heard. But why no regular Linux distro?