Below is a list of software I personally think is worth checking out. I use most of the software listed down below daily. The opinions on here are entirely my own.
This page will be frequently updated. Feel free to drop an email for suggestions, corrections... (contact info in the about page)
Last updated: 26/08/2025This is just a list of software I enjoy for personal or enterprise use.
There is a brief description of why I think they should be mentioned or checked out. These are not meant to be extensive reviews.
I wouldn't recommend it to first time Linux users, not because it's particularly hard to use, but just because some things require reading skills (i.e. you have to make partitions manually, and you'll probably need a tutorial if it's the first time), but if you have some experience with Linux or alternatively have time to read the documentation, Void is a very comfortable distro for desktop usage. I've been using the same install for four years.
The package manager, XBPS, is hybrid: you can download binaries but it's easy to compile software yourself, and this feature is very well documented on the wiki.
I'm also one of those people who really enjoy being wholly in control of their system for some reason, and Void notably uses runit as system supervisor, instead of the much more complex systemd. It's also known for supporting musl, a less-bloated alternative to glibc, though I've never used it personally.
Void was also known for shipping with LibreSSL instead of OpenSSL (remember heartbleed?), but that practice was discontinued (see here)
It's no secret that many linux users after switching to BSD never come back. This website used to on FreeBSD. I still have to explore all the features it has to offer, but so far it's been great. In this list there are quite a few programs that run on FreeBSD, such as pf and bastille. The package manager is hybrid: you can either use ports and build your own packages or download binaries directly.
Apparenly in the BSD world compiling software is much more
commonplace than on linux: most FreeBSD related tutorial will show both
ways to install applications (pkg install thing or use ports).
Despite this, I've never used ports myself because the package
repository always contained anything I need.
It's also widely known and rumored that the network stack on FreeBSD is generally better than Linux's. pf, for instance, is very powerful and simple to use, and offers built-in jail2ban-like functionality. Containers on FreeBSD, namely jails, are very pleasant to use. I use Bastille to handle my jails, which despite being relatively new software works like a charm and is straightforward to use, ever for a FreeBSD beginner.
FreeBSD has a much smaller codebase than Linux. The Linux kernel alone had more than 27 million lines of code in 2020, partly thanks to SELinux, AppArmour, and other complex kernel modules developed to solve the exact same problem (containers). On the other hand, BSD tends to have less and less lines of code thanks to aggressive pruning. FreeBSD (not just the kernel, the entire OS) is 16 million lines of code. DragonFlyBSD, a fork of FreeBSD, has about 9 million lines of code. (Data taken from openhub, as 2022). Less code means more maintainable.
Recently FreeBSD added support for OCI container images, bridging a significant gap with Linux.
Alpine linux is a lightweight and minimal linux distro based on musl. It's my go-to linux distro for containers in general, both as base image for docker builds (resulting in <10MB OCI images) or for interactive use within a Proxmox CT. Despite being very minimal, the package repository is surprisingly complete and updated, including a lot of developer tools (think pipelines!)
Proxmox is an open-source hypervisor, suitable for medium organizations with low administration budget. A single person can start to manage infrastructure, as most tasks can be performed on an intuitive and complete web ui. It built to scale seamlessly from single node to multiple nodes when you expand on hardware in the future. You can create regular virtual machines but also "CT"s, which are an abstraction built on LXC and hence consume little resources.
It also has a little android app, which doesn't come with all the features of the web-ui but gives you shell access (like the web-ui) to the host (or any CT/VM), bypassing any UI and API design needs, a few graphs, and start/stop/reboot buttons where they make sense.
The open source community around Proxmox also made a bunch of scripts to automatically install software of all sorts on your Proxmox install. Some of these can be easily updated in an uniform way. (type update in the shell)
Sway is a tiling window manager meant to be used as a drop-in replacement for i3. The config file supports the same syntax, and if you're an i3 user thinking of switching to wayland you can just use your good old i3 config.
There's not much more to say: it's a wm and thus very minimalistic, you're pretty much in charge of everything else.
Sway rarely gets in the way of productivity. I find myself switching workspaces much faster on sway, even if I also had a similar setup on my old KDE install.
Niri is a scrollable-tiling window manager. It's basically sway but windows appear always to the right on an inifnite strip. Instead of 10 workspaces you get 10 infinite strips. I've used it for a few months and found it surprisingly smooth, battery friendly, glitch-free and easy to use.
Kitty is a GPU accelerated terminal emulator. It's fast, and it has a focus on shortcuts for keyboard-only users, and folks that enjoy living in their terminal. Kitty is also famous for having its own protocol to display images on the terminal. Thanks to kitty I have implemented image previews inside of fzf, which is pretty cool. You start to miss thumbnails after a while.
Neovim is a very extensible and powerful text editor. You can use it as a full fledged IDE (I do).
If you know to use vim, then you can skip this section. If you don't know how to use vim, learn it. Neovim supports vimscript entirely for retrocompatibility, but plugins are usually written in Lua.
The power of a infinitely customizable, terminal based text editor are not to be underestimated. I did not want to learn vim, but after using it for a while there is no turning back.
I try to use the vim keybindings in every application I use, firefox included, and I feel like they give less carpal tunnel syndrome than emacs style keybindings.
Helix is a "post-modal" editor written in Rust which aims to support a wide range of modern features and easy defaults. If you use neovim you can immediately switch to helix as a lot of the keybindings are the same. I use helix because, with default config, it behaves rouughly like my heavily modded neovim, so I get the same features without the maintainance burden.
I miss some features and I haven't switch over completely, but I try to use helix as much as possible.
Fish is a shell which focuses on being user friendly. I really miss Fish when I'm not using it. You should just check it out, or read the features from their website.
z is a command line utility to quickly jump around
your most frequently visited folders.
Right after you install it, z is completely useless. But after
moving around in a few directories, z will keep note of them,
and then you'll be able to jump back inside instantly by typing
z keyword, where keyword is any part
of the directory you're trying to move to.
For instance, if I type z down, z will
take me to the Downloads folder: it's a
folder I open very frequently and it has the word
down in it. Z does fuzzy-matching.
It doesn't sound too spectacular, but nowadays I really rely
heavily on z. It feels a bit like magic: I can type
z proj
faster than I can think "Oh, I need to go in the project folder
right now..."
I really suggest trying it out. If you use Fish, here's the fish plugin I use. On zsh, I use xozide There are many z implementations out there.
In the same vein as z, which can be thought as a
"fuzzy-cd", fzf is a fuzzy everything. Check the webpage for
some examples. It's another one of those programs that radically
changed the way I use the terminal.
Besides just finding files, fzf can be used to browse all the current environment variables and the command history too.
Another unorthodox way I use fzf is to preview files right off the terminal. Sometimes I just don't remember where some piece of code is, and I quickly call fzf to peek inside files.
If Fish is your shell, here's the fish plugin. There are also many fzf implementations, and since this article has been first written fzf is now integrated in a bunch of neovim distributions, emacs configs, and probably some other terminal tool.
Bat is a fancier version of cat. That's basically it. It has syntax highlighting, git integration, and a few other features.
By default it also works as a pager when the file is too big to fit inside one screen, but I personally disabled that. I use it when I want to peek inside a file, but also want to see syntax highlighted. Not really a life changing tool, but very nice overall.
Ripgrep is just like grep, but recursive, and insanely fast. It also comes with some sane defaults, such as ignoring .gitignore and binary files. Quoting ripgrep's githup page,
In other words, use ripgrep if you like speed, filtering by default, fewer bugs and Unicode support.
It's also worth nothing that the author of Ripgrep is pretty good at searching text.
Ripgrep is also very useful in the real-world scenario of full text search in
a codebase, you can rg <id> and find all occurrences in a snap.
Fd is just a file-searching utility. It aims to be more friendly than
find, and I honestly can say it is. You can argue that find is a standard
tool and you should just learn that. Which is a very fair point but why are
you here even? Also, I am mostly searching files on my computer or on development
enviromnents where I'm allowed to install some tools to make my life
easier.
Haskell is a purely functional programming language.
"Pure" in this context roughly means that there is no state and no variables: the behaviour of a function call solely depends on its (immutable) arguments. This has a bunch of benefits, going from not having to keep track of state in your head to allowing GHC to perform very aggressive optimizations.
Haskell is also a very good language for building eDSL, namely embedded domain-specific languages, which you can think as small languages within Haskell. This allows for a lot of flexibility in the ways the language can be used. If that's not enough there's also a meta-programming system called template Haskell, which is fully type-checked.
Rust is another language I use mostly because of the safety guarantees it offers: a safety system called "borrow checker" ensures that, despite not having a garbage collector, memory is automatically freed and no double free, use after free, and other memory errors can ever take place. The type system is strong enough to even prevent certain bugs in concurrent program (Send and Sync traits), and can allow to express precise contracts thanks to its richness.
The Rust ecosystem isn't perfect, but there are many incredible libraries out there, and it's surely growing fast. Rust is also becoming one of the go-to languages for low-level development, securing its place inside massive codebases such as most browsers and operating systems.
Typst looks as clean as markdown but competes with Latex in function, and that is pretty much the entire selling point. Works really great in pipelines to produce release documents, for instance
Mise helps you manage toolchains, env variables and tasks on
a codebase. It connects to a repo with hundreads of dev tools
which you can install with a simple command, such as mise add clang
You can set projet-only mise specific env variables, and you can
create specific lists of commands to run, like mise build
to compile your project. Those tasks can depend on one another
and you can specify files to watch to skip a certain task.
The combination of these features turns mise into a very powerful language-agnostic build tool. Very good experience so far.
K0s is a lightweight Kubernetes distribution. I run one on my homelab to play with kubernetes. It's very lightweight and quite fun to use. There's also a tool called k0sctl which helps you spin up entire clusters. I found it to be easier than alternatives, but it could be possible that it just happened to work well on my particular setup.
Tanka is a kubernetes configuration utility that uses JSonnet as language. Practically it means having a modern-ish programming language instead of yolo-templates to manage your .yaml definition files for kubernetes. It's compatible with helm but feels more robust.
Opentofu is the open source Terraform fork, and can be used to deploy infrastructure on different cloud providers programmatically. Even if you're not a cloud person you can use opentofu to manage your selfhosted Proxmox cluster, which is actually amazing.
K9s is a terminal based UI to interact with your kubernetes cluster. It uses vim key bindings and it's really intuitive once you get used to it. I find myself much more comfortable navigating a cluster using k9s rather than any web-based graphical UIs I've ever tried (openshift being one of the clunkiest)