Games are complex desktop applications that require interactions like:

• your disk, to save game state, load images and audio/video files
• network card, to allow playing online
• graphics/audio card, for best performance/user interaction

Hardware interactions are handled by your operating system by specialized software components called device drivers. They offer higher level abstractions, which allows creating higher level APIs for application developers via software libraries.

In many cases, standards have evolved and are usually publicly available. They offer a guarantee that the application will continue to work as the operating system/software libraries get updated.

In case of the gaming world, for graphics we have the following main standards

• Vulkan - cross-platform
• Metal - Apple specific
• DirectX - Windows specific
• OpenGL - cross-platform

For Audio APIs, we have:

• XAudio2 - Windows specific, part of DirectX
• OpenAL - started out open source, but latest versions are closed

Here's a high level overview of the infrastructure built-in Linux to support gaming/multimedia.

Separate from this, there are a bunch of (higher level) libraries that do not adhere to a specific standard, like SDL, SFML or Raylib.

As you can imagine, building a game requires a deep integration with all these layers, making things complicated.

It is no wonder that, in order not to reinvent the wheel, all these functionalities have been integrated as parts of what people call a game engine.

The main platform for PC gaming is Microsoft Windows. Obviously, this closely follows the OS market shares, and, as things stand right now, it is unlikely this will change in the near future.

So, many game developers prefer to stay focused and target the dominant OS and use the APIs that make their life the easiest even though they may be OS specific. The big elephant in the room is DirectX multimedia API, which is many times preferred over the newer cross-platform standards.

In time, the Linux community has built an impressive compatibility layer (Wine) that allows you to run, with varying success, day to day Windows applications, games included.

There are a few native games, but the big names usually require Wine to run on Linux.

The gaming support has gradually increased over time. A few years ago, Valve, one of the biggest game digital distribution companies, decided to add Linux support for Steam, its software distribution platform. It worked with CodeWeavers (a commercial company that focuses on Wine development) to create Proton, an improved compatibility layer, which is integrated into Steam to offer Linux support. Proton is a Wine fork which specializes on running games and has added improved 3D support. It has a permissive license and is open source, allowing for contributions to be reincorporated/adapted in Wine, as needed.

I've given a high level outlook and history, and I will detail on the day to day user experience:

• Kernel Drivers for graphics cards
• Native games
• Popular games

Usually, all hardware drivers come with the Linux kernel, which is included in your distribution. A notable exception is Nvidia, for which the proprietary drivers are to be preferred.

As with Windows, major vendors also publish the newest versions on their websites, e.g. :

• AMD - https://www.amd.com/en/support/download/linux-drivers.html
• Nvidia - https://www.nvidia.com/en-us/drivers/unix/
• Intel - https://dgpu-docs.intel.com/driver/client/overview.html

Obviously, the first step is to properly identify your hardware, and then follow up with installing the right drivers if need be.

There are some native Linux games, which are free and can be installed with your default distribution package manager. Here are some classic games examples below:

Chess

GNOME chess (has a default engine, but one can use others such as stockfish).

Backgammon

GNU backgammon

Solitaire

Aisleriot

Tetris

LTris

Tux Racer

Tux Racer

Minesweeper

GNOME mines

I will not go into details on how to install them. You can apt from CLI, or GNOME software for a UI based approach. More details are available here

The bigger names mostly come via digital distribution platforms. Here are some that openly support Linux:

• Valve Steam - https://store.steampowered.com/linux
• gog.com - https://www.gog.com/en/games/linux
• Humble Bundle - https://www.humblebundle.com/store/c/linux

Valve offers Linux support for its software client (Steam), while the others do not.

There are good solutions readily available though, namely Lutris and Heroic Games Launcher. They seem roughly equivalent at this, I've decided to go with Lutris because it is available as a package in the distribution, and also like the idea that it is built on GTK, the UI library that GNOME is built on.

In the end though, it seems they've started working on common infrastructure, so it probably will not matter as much what you use in terms of games supported.

Overall, the Linux gaming infrastructure has gotten much better nowadays, with more and more games supporting Linux via Steam or other vendors. You will probably still run into various issues, but this time around I expect to find a lot more answers in various forums, as this was my overall experience.

There are some concerns caused by the fact that Linux has no anti cheat kernel based solution, resulting in some game developers not supporting Linux as a platform. The community maintains a website tracking these games and the plans for it at https://areweanticheatyet.com/

Things can always be better, but I consider things good enough so that you can get by. If gaming stopped you from switching to Linux, you should check out the Protondb/Lutris databases to see if you're favorite games are available.

There are many ways to get new software installed on your Linux machine, and I will outline a few below. I'm mainly using Ubuntu nowadays, so most of the explanations are made from this perspective, though I'd expect most of my comments will apply to Debian based distributions and will outline a way to approach things for others.

First of all, an application must be at its core a file in a format that your operating system understands. Also, in order to simplify software development, people came up with the idea of reusable code, so that you don't start from scratch with every tool/application that one wants to create. One simple example would be if someone wanted to build an editor, they should not have to write the code for building GUIs or the operating system kernel. All of this lead to the emergence of software libraries which at the end of the day are some files we put on our disk.

So, many of applications we use day to day are broken up in multiple files, including configuration one. So, it is no wonder that there are widely available and popular solutions that try to package applications in a standardized way (usually an archive that respects some predefined directory layout).

You are probably already familiar with one of the below:

.deb

Debian based distributions

.rpm

rpm based, such as RedHat and OpenSUSE

.dmg/.img

macOS

.msi

Microsoft Windows

As outlined above, there are common frameworks/libraries that are needed. Obviously you could potentially package them with each application, but the size of them is sometimes too much. For instance, if you were to depend on most of the GNOME libraries, you'd have to package 500MB-1GB every time (this was estimated based on how flatpak and snap package GNOME, don't worry I will explain what they are later on).

george@local:~$ snap info gnome-42-2204 | grep installed
  This snap is automatically installed and removed when needed. **Manually
installed:          0+git.510a601            (176) 529MB -
george@local:~$ flatpak info org.gnome.Platform/x86_64/47 | grep Installed
   Installed: 1.0 GB

As a side note, it's not only disk that is saved, but RAM as well, as operating know how to load the shared libraries in memory once for multiple applications.

Therefore, the idea of dependencies between packages came along, so you'd be able to have a single copy of all those binaries.

Unfortunately, there's one more important aspect to this. These libraries have new releases (which might change behavior intentionally), and also there might bugs related to the interaction between the application and its dependencies, which basically means an application is compatible with certain versions of libraries

In order for its users to have a smooth experience, a distribution needs to test and pick the right combination of all these applications and libraries, package it together in a ISO image, which you can then put on a USB flash drive. There are periodic releases and this would be one way to get newer software.

As the Internet has become widely available, the package managers have evolved and are offering online repositories as well, which make the (security) updates much easier.

When you install an application, there a few things to consider:

Trust

does what you want and is not malware

Interaction with your OS

works well with infrastructure/other applications

Easy to uninstall

easily remove its files/data to avoid polluting your disk

Easy to manage

common way to configure/install/uninstall, so that you don't need to learn a lot of specifics for each application

Space on disk

how much space the end installation will occupy on your system

Performance

how is the application responsiveness impacted by the installation approach

Given my criteria above (you may or not agree with them), the preferred way of installing something from my perspective is a package manager.

Here's my prioritized approach on getting new stuff on my computer:

1. Default distribution package manager (APT for Debian based distributions)
2. Distribution agnostic package managers (flatpak, snap, Nix, npm, etc)
3. Manual installation

Of course, I install the majority of the games I play via Steam which is yet another package manager.

Also, if you find that most of the apps you need are shipped with the distribution, but have an older version, you should look out for new releases.

Using the provided solution from your distribution is a no-brainer for me, as it tries to make sure everything is curated and works well together. Most of them provide both an GUI/CLI management application.

The details below apply to Debian based distribution (that means APT as a package manager), but you should probably be able to find similar functionality on other distributions (see a CLI functionality comparison for multiple package managers here.

Firstly, for best performance you should go ahead and configure a mirror if not already.

If you're using the GUI, I recommend the "Software & Updates" app (see "Download from" below):

Some applications are not in the main repository, but might be found in others. Ubuntu offers some centralized place for them via their Launchpad infrastructure. It is also used for Canonical internal testing, but it has been extended since to allow third party publishing as a Personal Package Archives(ppa).

It's easy to search ppas, but it's hard to reason as to what is recommended for use or in a good state. I don't usually resort to ppas, as it's easy for them to put your package manager in an inconsistent state (because of not enough testing, incorrect dependencies, lack of updates). I only consider using them when the application itself recommends it and I know it is popular enough to be kept up to date.

As a side note, Debian maintains another solution called extrepo, which seems to be available on Ubuntu as well. It has a curated list of external APT repositories, but I have not tested it though, so I wouldn't be able to recommend it.

I have decided to add the flatpak repository. Trust is always an issue, so please be careful what you add.

It is a bit harder to get a full picture from the GUI, so going deeper into the configuration files/CLI is my preferred approach.

See below on how to get a unified list of repositories via apt-add-repository. Please note the special security repository, which helps keeping your system secure.

Repositories are saved in the file /etc/apt/sources.list (Debian approach) or stored as individual files in /etc/apt/sources.list.d directory (Ubuntu 24.04 approach).

george@local:/etc/apt/sources.list.d$ sudo add-apt-repository --list
[sudo] password for george: 
Types: deb
URIs: http://archive.ubuntu.com/ubuntu
Suites: noble noble-updates noble-backports
Components: main restricted universe multiverse
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg 

Types: deb
URIs: http://security.ubuntu.com/ubuntu/
Suites: noble-security
Components: main restricted universe multiverse
Signed-By: /usr/share/keyrings/ubuntu-archive-keyring.gpg 

Types: deb
URIs: https://ppa.launchpadcontent.net/flatpak/stable/ubuntu/
Suites: noble
Components: main
Signed-By: -----BEGIN PGP PUBLIC KEY BLOCK-----
 .
 mQINBGERGM0BEAC+3QHbpl2ZAnJxoiNXqAc/CkkAQwUc1rvJLqxUVctIWPw5+zVt
 mJEpmAEfiz+t/EaBrmNUMi+8fKkjRCiaFeKpaOHGA/WALxuEbVFR/YtA48IhdK1S
 +YPueMsVDJdwG+TvG+8c/C5nJWjDwUDQVYqRRuXsd+256jN45F4Xs1y3eHX3blS9
 yOHpkOTlOhZYe7dN/+PUEz8HXfqfQBjlnpdDAV9DP4bgZnHzwbdN0L59nJitCS2N
 FrxpTYtF/Mv9PeZc5F8e62Ck5mGtfTWPgusoIw/0aGbVXoOUoZY+uX1b8lUI4rj/
 cw5PndCEX1LsUAsmpzt5iZdXaxLCt/NUfbI1nki+1WyquZPCScQqhXohCf9D8Uxu
 h1TTmJ+jRJbfyoNMnlcGkIz+3g1V9wD1w4+wRCZLSnToa0XYrDJkXVPtIYsmgelE
 /mQeCHFpsQEFxa94bkRhRb1C/CAKrQ5yMtREnP8l/0yyYkOHCFh41nC+sN1oxX89
 T0cpX2hnB8cs4AUbonz80UkMk6zeQwUg1yHgdX7gLoELnZVwctA03nB9SJW6BPG/
 kgMrReHKn5diZWz0RhDTz0K0qh4NUdcKtK4oJZ7Lk5OGSR6N0f/zIBKVCNo9jzK3
 E8zFeMzWelXlUEQ5k9GsxF9XThVJ0On2RHMRjUUQbRVR4HjoyI77mk5kXwARAQAB
 tBlMYXVuY2hwYWQgUFBBIGZvciBGbGF0cGFriQJOBBMBCgA4FiEEXG0VOhfALDN+
 9sZjuLnUEinfpfUFAmERGM0CGwMFCwkIBwIGFQoJCAsCBBYCAwECHgECF4AACgkQ
 uLnUEinfpfXYUw//Yfl7rRaZ/tbLjtOMUHlcQoQdrZ0FkaubNGz8ydyBe37Xulij
 Ss6zAamdEqERZ9VuAiKhwc7oEfRqigaZpXvzMcO2fdg7nF4S3yRckUcShAkoO8IO
 i33paHWxo03tU6FpncAJeuWXhsFl8FOhD1dkoOG2rqELaMd2TKOF7+OuGA6Y4DvH
 eHPOhXqhn65vVzuUGQTXce6tsZfRHNYvMkAdRAqCo731ZlY8ilSHW9hwGYnFsRZ5
 +n4E6ZPCOtWAbapa+iCmV/liRLB+VZ+MP3tUaFHk/yeCllCjsmxmNAIA31hTOXTQ
 aAt7t/wjZMWC/x1S6kJKvq/to2vyHPtlCAH7Y8HBumQ2NXfCgt2yk/2TyvpmxEUh
 +9/XRw3VoSXK3lL1muK3af1o6VSoFiUNyrIJSO8UhE/Dz6ykcSJfOqM7G/9Mlosw
 FaAgHDBd9rb8lUz3RIu7n3t292UuuuPmQd5kby4/SPvc4lHdQHD415fFOcF2nzZG
 786a6cqu8+1MpUPcg1HVNe3fz3kliIrnYfDHk5ic3D2wS9iGn5brDJYwcqsCYpF/
 66XSJB6vXNGamOdQ1GKKUEh0ilfVEvmX+a+ovo4G4YQ16iHQO0JzC7SVe/+ITSNY
 o5RT+82ocwyNGzBPzKmRqKV99baRT63dD9NVs0u0BjihRyMWCUwfWYwNtlI=
 =Fi60
 -----END PGP PUBLIC KEY BLOCK----- 

I've outlined below a high level overview for the package management infrastructure. apt is the high level package manager, and is responsible for resolving and downloading dependencies. It will then defer to dpkg low level infrastructure to install them.

As you may have already figured out, many Linux distributions have different package managers (see below). It is therefore a lot of work to have a global presence.

You can also check out for instance the Firefox distribution plan to get an idea of what one may need to cover. So, it is unfortunate, but understandable, that application developers seek out distribution methods that are cross-platform.

In theory, it is possible to install one of the known package managers associated with distributions (e.g. you could install pacman on Ubuntu). However, given that the package manager is such an integral part of the overall experience, this is not a common thing among the Linux users.

Once an external package manager accepts that you can potentially deviate from the distribution provided libraries, it has to find a way to isolate its binaries and bootstrap itself.

So, please keep in mind though that an extra package manager comes with an additional learning curve, extra bootstrap disk space and potentially more RAM being used. This is why it's important to keep the extra apps installed outside the native package manager to a minimum.

There are two main contenders out there, specially built for Linux:

flatpak

community driven, main app store available at https://flathub.org/, other stores supported

snap

a Canonical initiative, app store available at https://snapcraft.io/

Here's a quick cheat sheet on how to achieve the simplest things when using the CLI tools offered.

All the applications provided to the end user rely on some build infrastructure. You can, of course, also install it on your system and recreate the binaries. You can then control where they go on your system, and you'll basically have to manage it yourself

Some people have created AppImage, a file format that contains the full application and its dependencies. With this approach, you get to skip the building part, but need to handle everything else. Its philosophy seems to not rely on a package manager at all, although I've seen utilities from people trying to offer this as well. There is a popular central repository that aggregates a lot of them (1.4k as of today). The idea is interesting, it would probably be OK to have a few apps like this, but I wouldn't go further than this.

If I need to get the manual route for an app, I usually go and check its website, and usually take their recommended approach.

Although Linux is considered to be very safe, the same threats apply. You need to be cautious and do a basic analysis of the software you're installing, as well as its source.

Each Linux distribution has a good story for the security aspect, see the Ubuntu story or the Debian one. Also, installing via the distribution package manager ensures that there's some minimum testing that has been done for proper interaction with all the other apps/components, as well as some basic identity validation.

For new applications, you should always be looking at least at the publisher, especially if you use the alternate solutions (in order to relate it to a trustworthy source).

See the GNOME Text Editor links below to get an idea of where to look:

snap

https://snapcraft.io/gnome-text-editor

flatpak

https://flathub.org/apps/org.gnome.TextEditor

apt

https://packages.ubuntu.com/noble/gnome-text-editor

Installing Linux software applications is straightforward, pretty much on par with other operating systems. Upgrading your release regularly is also a good practice.

Each operating system comes along with a list of preinstalled applications that make your computer usable. Usually, they ship with commonly used applications such as a file manager, text editor, package/app manager, media player, web browser.

Many times though, people want to tweak their environment or do stuff that their applications were not designed for. This is where a terminal emulator comes along. It is not necessarily something that you pick up immediately when starting out with a Linux desktop distribution, but, once you gain a bit of experience, it will come in very handy.

In a nutshell, using a terminal is about combining a list of commands to achieve a specific result. If you're looking to get a quick overview, just go here.

Here's an example showing how to find big files recursively in a directory. This is useful for me when doing cleanup on my system (obviously you shouldn't delete things from your "/usr", I've just used it to showcase the usage).

If you want to tweak your bash based terminal, you can get some inspiration from these themes, based on ohmybash.

I'm personally keeping things to a minimum, but I've outlined a few things I'm doing below

Using the terminal is one of the ways to take more control of your PC. I think most of them provide a good enough experience, so, you don't need a lot of research to get started. Picking the distribution default is a good place to start. Had I been using KDE, konsole would have covered most of my needs.

This is the year of the GNU/Linux desktop for me, and I've decided to share my thoughts on why I think this is a good idea for you to switch as well in 2024.

I try to maintain a similar workflow regardless of the operating system, so, over time, I found myself prioritizing more the cross-platform tools (e.g. Firefox, VLC, Steam, Emacs, Visual Studio Code, etc). This makes it simpler for me to embrace another operating system.

Also, I've been using it both personally and professionally for about 20 years, but mostly in dual boot mode or in a virtual machine

In terms of distributions, I've used Fedora, Debian, Ubuntu and Redhat for longer periods of time, and briefly experimented with Mint and Gentoo.

Debian stuck with me, as I like the multiple ways you could consume it. I've experimented with the Debian testing rolling release, which is a great idea, but things can get complicated as you continue updating packages and requires a bit more time/hacking to sustain

Nowadays, I appreciate more the longer support time, and here is where Ubuntu (a Debian based distribution) shines, with a 5-year support time.

In the end, I've settled for Ubuntu, and would also recommend it to anyone starting out, as it is beginner-friendly.

I've also used Windows and macOS, but I prefer Linux because:

• Centralized package management system (e.g. apt, yum, pacman)
• Old hardware is supported for a longer time
• Scripting infrastructure (e.g. bash and proc)

My own reasons to stick to the Windows/macOS up until now:

• Microsoft Office suite. Nowadays, the online version is good enough
• No gaming story. This got solved when Steam support for Linux was added

Given the high number of distribution options, it is somewhat surprising that Linux is not the desktop OS of choice.

Also, it has an unusually high number of options desktop environments, out of which the most popular are KDE and GNOME. Some distributions even have special flavors which build around them, so some initial experiments (using a virtual machine for instance) are probably in order if you are really picky.

If you're new to Linux, I would recommend you to make a top 3 of distributions based on your most important criteria, and pick one to experiment. As they are free, you can also quickly switch to another one, if something goes wrong. So, don't spend too much time on the choosing the perfect one, but rather try to experiment.

There's no perfect operating system, and Linux is just one option. The ecosystem has grown a lot though, and you can find a lot of high quality applications alternatives for free.

The major operating systems continuously update and reinvent themselves, so one has to periodically learn a new interface about every 5 years. So, you might as well give Linux a try as well at some point

As a word of caution, even though the overall usability has improved a lot, you can still hit some occasional hiccups. There is a lot of support online, so you should be able to tackle them with minor investment.

The overall desktop Linux usage has steadily increased over the years, so, if you decide to make the switch, you're in good company