Forem: Hishantik Sarkar

A Complete Guide to Networking on Linux Systems for File and Data Sharing

Hishantik Sarkar — Thu, 07 May 2026 07:46:58 +0000

Network file sharing between Linux systems forms the backbone of efficient data management in modern IT environments. Whether you are managing a home lab, administering enterprise servers, or simply transferring files between personal machines, understanding how to configure file sharing across Linux distributions like Ubuntu and Arch Linux is an essential skill. This guide walks you through the most effective methods for establishing secure, reliable file sharing between Linux systems, complete with step-by-step instructions and command-line examples.

Understanding Linux File Sharing Technologies

Before diving into configuration, it is important to understand the primary technologies available for Linux-to-Linux file sharing. Each approach offers distinct advantages depending on your specific use case, security requirements, and performance needs.

The Network File System, or NFS, represents the most native and efficient solution for Linux-to-Linux sharing. Developed originally by Sun Microsystems, NFS has been a staple of Unix and Linux networking for decades. It operates on a client-server model where the server exports directories that clients mount as if they were local filesystems. NFS performs exceptionally well within trusted networks due to its lightweight protocol and minimal overhead.

Samba, despite its origins as a compatibility layer for Windows file sharing, also serves Linux-to-Linux environments effectively. When you need to share files across heterogeneous environments or maintain compatibility with Windows systems that might join your network later, Samba provides a robust solution. Modern Samba configurations offer strong security features and excellent performance.

Secure Shell-based solutions, including SCP and SFTP, provide encrypted file transfer capabilities without requiring complex server configuration. These methods prove ideal for one-time transfers, automated scripts, or situations where mounting remote filesystems seems excessive.

Setting Up NFS File Sharing Between Linux Systems

NFS offers the most straightforward path to seamless file sharing between Linux machines. The following sections detail how to configure both Ubuntu and Arch Linux systems as NFS servers and clients.

Configuring the NFS Server

Begin by installing the necessary NFS server software on the machine that will host the shared directories. On Ubuntu, execute the following commands with root privileges to install the NFS kernel server and related utilities. The installation process automatically creates the necessary system groups and user mappings that NFS requires for operation.

sudo apt update
sudo apt install nfs-kernel-server

On Arch Linux, the process requires installing the nfs-utils package, which provides both client and server functionality. Arch follows a minimal installation philosophy, so you may need to enable and start theRPC bind service before configuring NFS.

sudo pacman -Syu
sudo pacman -S nfs-utils
sudo systemctl enable --now rpcbind.service

With the software installed, you must now define which directories the server will share and which clients may access them. This configuration lives in the /etc/exports file, where each line specifies a directory path, client access parameters, and export options. Consider a configuration that shares the /data directory with two specific machines on your local network, configuring appropriate permissions and squash settings to prevent privilege escalation.

sudo mkdir -p /data/shared
sudo chown nobody:nogroup /data/shared
sudo chmod 755 /data/shared

Edit the exports file using your preferred text editor, adding a line that specifies the shared directory and client machines. The following example grants read-write access to two specific IP addresses while using the rw and sync options to ensure data integrity.

sudo nano /etc/exports

Add the following line to /etc/exports, adjusting the IP addresses to match your network configuration:

/data/shared 192.168.1.10(rw,sync,no_subtree_check) 192.168.1.11(rw,sync,no_subtree_check)

After saving the configuration, export the shared directories and restart the NFS server to apply the changes. The exportfs command with the -a flag processes all entries in /etc/exports, while the -r option resynchronizes the current export table.

sudo exportfs -a
sudo systemctl restart nfs-kernel-server  # Ubuntu
sudo systemctl restart nfs-server.service  # Arch Linux

Configuring the NFS Client

On the machine that will access the shared directories, install the NFS client utilities and create a mount point directory. The client side requires far less configuration than the server, as most settings are determined by the server's export options.

Ubuntu

sudo apt install nfs-common

Arch Linux

sudo pacman -S nfs-utils

Create the mount point directory and mount the remote filesystem. The mount command connects to the NFS server and makes the remote directory accessible through the local mount point. For permanent mounting, add an entry to the /etc/fstab file, which instructs the system to establish the connection automatically during boot.

sudo mkdir -p /mnt/nfs/shared
sudo mount 192.168.1.100:/data/shared /mnt/nfs/shared

For permanent mounting, add this line to /etc/fstab:

192.168.1.100:/data/shared /mnt/nfs/shared nfs defaults,timeo=900,retrans=5,_netdev 0 0

Implementing Samba for Linux-to-Linux File Sharing

While NFS excels in pure Linux environments, Samba provides additional flexibility and compatibility benefits. Modern Samba versions offer excellent performance and robust security features that make them suitable for Linux-only networks as well.

Installing and Configuring Samba on Ubuntu

Begin by installing the Samba package along with its associated utilities. The installation process on Ubuntu automatically configures basic services and creates the necessary system users, though significant configuration remains necessary.

sudo apt update
sudo apt install samba samba-common-bin

Create a dedicated directory for sharing and set appropriate ownership permissions. It is good practice to create a specific system user for Samba access, separating Samba authentication from regular system login credentials.

sudo mkdir -p /samba/shared
sudo groupadd sambashare
sudo useradd -s /s/bin/false -G sambashare sambauser
sudo chown -R sambauser:sambashare /samba/shared
sudo chmod 0770 /samba/shared

Configure Samba by editing the /etc/samba/smb.conf file. This configuration file uses a simple ini-style format where square brackets define share names and the remaining lines specify parameters for each share. The following configuration creates a share named shared with valid user access and appropriate permission settings.

sudo nano /etc/samba/smb.conf

Add the following configuration section to the end of the file:

[shared]
comment = Shared Directory
path = /samba/shared
read only = no
browsable = yes
valid users = sambauser
create mask = 0660
directory mask = 0770

Set a password for the Samba user, which must exist as a system user but uses a separate password database for Samba authentication. This dual-password system provides an additional layer of security by preventing regular system login through Samba access.

sudo smbpasswd -a sambauser

Restart the Samba services to load the new configuration. Ubuntu uses the smbd and nmbd daemons for CIFS/SMB functionality, with nmbd handling NetBIOS name resolution.

sudo systemctl restart smbd nmbd
sudo systemctl enable smbd nmbd

Installing and Configuring Samba on Arch Linux

The Arch Linux installation follows a similar pattern, though package management and service handling differ slightly. Arch typically requires more manual configuration but offers greater flexibility.

sudo pacman -Syu
sudo pacman -S samba

Create the required directories and user accounts using the same principles as the Ubuntu configuration. Arch Linux does not enable services by default, so explicit enablement steps are necessary.

sudo mkdir -p /samba/shared
sudo groupadd sambashare
sudo useradd -s /s/bin/false -G sambashare sambauser
sudo chown -R sambauser:sambashare /samba/shared
sudo chmod 0770 /samba/shared

Configure Samba identically to the Ubuntu setup by editing /etc/samba/smb.conf. The configuration file format remains consistent across distributions. Create a basic configuration file if the default one does not suit your needs.

sudo nano /etc/samba/smb.conf

Add the same share configuration section described in the Ubuntu instructions. Then, set the Samba password and enable the required services.

sudo smbpasswd -a sambauser
sudo systemctl enable --now smbd nmbd

Accessing Samba Shares from Linux Clients

From any Linux machine on the network, you can access Samba shares using the smbclient utility or by mounting the share directly. Installing cifs-utils enables direct mounting behavior similar to NFS mounts.

Install client utilities

sudo apt install cifs-utils  #### Ubuntu
sudo pacman -S cifs-utils    #### Arch Linux

Create mount point and mount the share

sudo mkdir -p /mnt/samba
sudo mount -t cifs //192.168.1.100/shared /mnt/samba -o user=sambauser,password=your_password

Securing Your Linux File Sharing Environment

Security must remain paramount when configuring network file sharing. Both NFS and Samba offer various security mechanisms that you should understand and implement appropriately.

For NFS, the /etc/exports file controls client access at the network level. Never export directories to the entire internet or untrusted networks. The rw and ro options control read-write access, while root_squash and all_squash options map privileged user requests to unprivileged accounts, preventing clients from accessing files as root. Consider using specific IP addresses or network ranges rather than hostnames, which can be spoofed in certain circumstances.

Secure export example

/data/shared 192.168.1.0/24(rw,sync,root_squash,no_subtree_check)

Samba security operates primarily through user authentication and share-level permissions. The valid users parameter restricts access to specific accounts, while read only and writable parameters control access mode. For enhanced security, consider implementing Samba with TLS encryption, which requires additional certificates but protects credentials and data from network sniffing.

Both solutions require appropriate firewall configuration. Ubuntu uses UFW by default, while Arch often relies on iptables or nftables. Allow only the necessary ports for your configuration.

UFW for Ubuntu

sudo ufw allow from 192.168.1.0/24 to any port 2049  # NFS
sudo ufw allow from 192.168.1.0/24 to any port 445   # Samba

Arch Linux using firewalld

sudo firewall-cmd --permanent --add-service=nfs
sudo firewall-cmd --permanent --add-service=samba
sudo firewall-cmd --reload

Testing and Troubleshooting Your Configuration

After configuration, thorough testing ensures everything functions correctly before relying on the setup for production use. Begin by verifying that the server correctly advertises its shares using the appropriate discovery commands.

For NFS, use the showmount utility to query the server's exported directories. From the client machine, execute the following command against your NFS server's IP address to display available shares.

showmount -e 192.168.1.100

For Samba, the smbclient utility provides an interactive browsing capability that tests both connectivity and authentication. This command logs in to the specified share using the configured username, prompting for a password that should match your Samba password.

smbclient -U sambauser //192.168.1.100/shared

Common issues typically involve permission mismatches, firewall blocking, or service status problems. Verify that all required services are running using systemctl status commands, and check logs in /var/log/ directories when authentication or mounting failures occur. Ensure that both server and client time settings are synchronized, as authentication failures sometimes result from time drift between machines.

Conclusion

Establishing file sharing between Linux systems need not be intimidating, regardless of whether you work with Ubuntu, Arch Linux, or a mixture of distributions. NFS provides the most efficient solution for Linux-native environments, while Samba offers broader compatibility and familiar configuration patterns. Both technologies, when properly secured, provide robust foundations for networked file sharing that rival or exceed Windows file sharing capabilities.

Begin with NFS for pure Linux environments where simplicity and performance are priorities. Consider Samba when Windows compatibility might become necessary or when you prefer its authentication model. Implement firewall rules and appropriate export options to maintain security throughout your configuration. With the steps outlined in this guide, you now possess the knowledge to configure reliable, secure file sharing across your Linux infrastructure.

Setting Up Termux for Web Development: A Complete Guide

Hishantik Sarkar — Tue, 11 Feb 2025 12:43:36 +0000

Termux is a powerful terminal emulator for Android that allows you to
run a Linux environment without root. With the right setup, you can
turn Termux into a fully functional web development environment with
Oh My Zsh, Oh My Posh, Git, Neovim/LunarVim, and Node.js (Live Server).

In this guide, you’ll learn how to:

✅ Install and configure Termux

✅ Set up a powerful shell with Oh My Zsh and Oh My Posh

✅ Install Git for version control

✅ Configure Neovim/LunarVim for coding

✅ Set up Node.js with a Live Server for web development

1. Installing Termux & Required Packages

Step 1: Install Termux

Download and install Termux from F-Droid (recommended) or from GitHub (Termux GitHub).

⚠️ DO NOT install Termux from the Play Store as it’s outdated!

Step 2: Update Termux and Install Basic Packages

Open Termux and run:

pkg update && pkg upgrade -y
pkg install termux-api x11-repo tur-repo
pkg install zsh git neovim nodejs python wget curl unzip -y

Step 3: Create a Symlink to an External SD Card for Easy Access

If your device has an external SD card, you can create a symbolic link (symlink) to access it easily from your home directory.

Step 1: Find the Name of Your External SD Card.

The system assigns a unique name to your SD card, usually in the format /XXXX-XXXX (e.g., /3454-3377). To find the name of your SD card, open a terminal and type:

df

The output would be somewhat similar to this :

Filesystem	1K-blocks	Used	Available	Use%	Mounted on
/dev/root	305248512	12345678	292902834	5%	/
devtmpfs	4000000	0	4000000	0%	/dev
tmpfs	4023456	456	4023000	1%	/dev/shm
tmpfs	4023456	1234	4022222	1%	/run
tmpfs	4023456	0	4023456	0%	/sys/fs/cgroup
/dev/mmcblk1p1	6233392	2123456	4109936	35%	/boot
/dev/sda1	976762584	234567890	742194694	25%	/mnt/data
/dev/mmcblk0p1	6233392	3123456	3109936	50%	/storage/3454-3377
tmpfs	4023456	12	4023444	1%	/run/user/1000
/storage/3454-3377	3488388	3	36637727	6%	/mnt

Look at the last line of the output—it typically contains the mount point of your SD card.

In this example, the external SD card is mounted at:

/storage/3454-3377

This is the value you need to use when creating the symlink.

Step 2: Create a Symlink to the SD Card

Once you have the SD card name, create a symlink to it using the following command (replace 3454-3377 with the actual name of your SD card):

ln -s /storage/3454-3377 ~/sdcard

This command creates a symbolic link (~/sdcard) in your home directory, allowing you to access your SD card easily without navigating through long directory paths.

2. Setting Up a Powerful Shell (Oh My Zsh & Oh My Posh)

Step 1: Install and Configure Oh My Zsh

pkg install zsh -y
chsh -s zsh

Restart Termux, then install Oh My Zsh:

sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"

Install the Powerlevel10k theme for a better experience:

git clone --depth=1 https://github.com/romkatv/powerlevel10k.git ~/.oh-my-zsh/custom/themes/powerlevel10k

Set the theme in ~/.zshrc:

nano ~/.zshrc

Change the line:

ZSH_THEME="powerlevel10k/powerlevel10k"

Save and exit (CTRL + X, then Y, then ENTER).

Restart Termux:

source ~/.zshrc

Step 2: Install and Configure Oh My Posh (Optional)

pkg install oh-my-posh -y
oh-my-posh font install

To use Oh My Posh, add this to ~/.zshrc:

eval "$(oh-my-posh init zsh --config ~/.config/oh-my-posh/theme.json)"

3. Installing Git for Version Control

Git is essential for managing your code and collaborating with others.

pkg install git -y

Replace "YourName" and "your@email.com" with your preferred Git username and email address.

git config --global user.name "YourName"
git config --global user.email "your@email.com"

To check if Git is working:

git --version

4. Setting Up Neovim and configure it with LunarVim for Coding

Step: Install Neovim

pkg install neovim -y

To check whether neovim have installed properly:

nvim --version

step 2: Install LunarVim

pkg install python rust nodejs ripgrep make fd -y

Resolve EACCES permissions when installing packages globally to avoid error when installing packages with npm.

To minimize the chance of permissions errors, you can configure npm to use a different directory. In this example, you will create and use hidden directory in your home directory.

On the command line, in your home directory, create a directory for global installations:

    mkdir -p ~/.npm-global/lib

Configure npm to use the new directory path:

npm config set prefix '~/.npm-global'

In your preferred text editor, open ~/.zshrc file and add this line:

export PATH=~/.npm-global/bin:$PATH

On the command line, update your system variables:

source ~/.zshrc

To test your new configuration, install a package globally without using sudo:

npm install -g jshint

Now, run the below command in the terminal to install lunarvim :

LV_BRANCH='release-1.4/neovim-0.9' bash <(curl -s https://raw.githubusercontent.com/LunarVim/LunarVim/release-1.4/neovim-0.9/utils/installer/install.sh)

Type yes whenever prompted during installation.

Run LunarVim:

lvim

For plugins, edit ~/.config/lvim/config.lua :

lvim ~/.config/lvim/config.lua

Essential Plugins for Web Development

Add these to your LunarVim config (~/.config/lvim/config.lua):

lvim.plugins = {
  {"neoclide/coc.nvim", branch = "release"},
  {"preservim/nerdtree"},
  {"tpope/vim-fugitive"},
  {"vim-airline/vim-airline"},
}

Now to save and restart LunarVim, type:

:lvimreload

To make lunarvim your default editor:

export EDITOR=lvim
echo 'export EDITOR=lvim' >> ~/.zshrc

5. Setting Up a Live Server for wev-development.

Install Live Server and configure it : add the following lines in "/.config/lvim/config.lua" inside lvim.plugins{...}

{
    'barrett-ruth/live-server.nvim',
    build = 'pnpm add -g live-server',
    cmd = { 'LiveServerStart', 'LiveServerStop' },
    config = true
}

To start a live server in your project folder through lunarvim, type:

:LiveServerStart

Then, it will automatically open project at http://localhost:8080 in a default browser (using a browser that supports local networking, like Firefox,chrome,etc).

6. Additional Tweaks for a Better Experience

Enable Clipboard Support

Install termux-api if not already installed:

pkg install termux-api -y

To copy to clipboard:

echo "Hello, Termux!" | termux-clipboard-set

To paste:

termux-clipboard-get

Enable Storage Access

Run the following command to allow Termux to access your phone's storage:

 termux-setup-storage

Your internal storage will be available in:

/storage/emulated/0/

Enable X11 Support for GUI Apps

If you want to run GUI applications (e.g., a browser, VS Code alternative), install a VNC server:

pkg install tigervnc
vncserver

Then, connect using a VNC client.

7. Running a Complete Web Development Workflow

Step 1: Clone a Web Project

git clone https://github.com/your-username/your-project.git
cd your-project

Step 2: Start Neovim/LunarVim

lvim index.html

Step 3: Run the Live Server from inside lunarvim

:LiveServerStart

Opens http://localhost:8080 on a default browser.

Final Thoughts

With this setup, your Android phone can become a powerful web development machine! You now have:

✅ Oh My Zsh & Oh My Posh for a great shell experience

✅ Git for version control

✅ Neovim/LunarVim for advanced coding

✅ Node.js with a Live Server for real-time development

The Complete Guide to Linux Gaming: Setting Up Wine, Proton, and Dependencies.

Hishantik Sarkar — Tue, 11 Feb 2025 04:35:31 +0000

For years, gaming on Linux was considered an adventure reserved for the most dedicated enthusiasts. Closed-source games simply didn't run, compatibility was hit-or-miss, and the general consensus was that if you wanted to play games, you needed Windows. That narrative has fundamentally shifted. With the rise of Wine-based compatibility layers, Steam's Proton initiative, and an increasingly supportive gaming ecosystem, Linux has become a legitimate platform for PC gaming. This guide will walk you through everything you need to know to set up your Linux system for gaming, including installation instructions for Ubuntu, Arch Linux, and other popular distributions.

Understanding the Linux Gaming Landscape

Before diving into installation commands, it's worth understanding what makes Linux gaming possible today. At the heart of this ecosystem lies Wine, a compatibility layer that translates Windows API calls into their Linux equivalents. Wine isn't an emulator in the traditional sense—it's a translation layer that allows Windows applications to run on Unix-like systems by intercepting system calls and replacing them with POSIX-compliant alternatives.

Proton, developed by Valve Corporation in collaboration with CodeWeavers, builds directly upon Wine with additional enhancements specifically tailored for gaming. Proton includes DirectX 9, 10, and 11 support (via Vulkan-based translation), improved controller compatibility, better fullscreen support, and deep integration with Steam. What makes Proton particularly powerful is that it comes pre-configured with Steam, meaning many Windows games can be played on Linux with zero additional setup.

The gaming landscape extends beyond just Wine and Proton, though. You'll also encounter tools like Lutris for managing games from multiple sources (GOG, Epic, standalone installers), PlayOnLinux for organizing Wine prefixes, and various compatibility launchers. Understanding these tools—and when to use each—will make your Linux gaming experience much smoother.

Prerequisites and System Preparation

Before installing any gaming-related software, ensure your system meets a few basic requirements. Your graphics drivers are the most critical component here. For NVIDIA users, you'll want the proprietary drivers rather than the open-source nouveau alternative, as they provide significantly better performance and proper Vulkan support. AMD and Intel users generally fare well with open-source drivers, though AMD's proprietary driver (AMDGPU-PRO) exists for enterprise users who need its specific feature set.

You should also verify that your system has the necessary 32-bit architecture support enabled. Many Windows games are 32-bit applications, and Wine requires 32-bit libraries to run them. Most modern distributions enable this by default, but we'll cover specific commands to ensure it's configured correctly on each platform.

Setting Up Ubuntu and Debian-Based Distributions

Ubuntu and its derivatives (Linux Mint, Pop!_OS, elementary OS) share a common package management foundation, making their setup process nearly identical. The process begins with enabling 32-bit architecture support and updating your package lists.

sudo dpkg --add-architecture i386

sudo apt update && sudo apt upgrade -y

Next, you'll install the foundational graphics libraries.

For NVIDIA graphics cards, the proprietary driver package includes everything you need:

sudo apt install nvidia-driver-525 libnvidia-gl-525 libnvidia-gl-525:i386 libvulkan1 libvulkan1:i386 mesa-vulkan-drivers mesa-vulkan-drivers:i386

AMD users should install the Mesa Vulkan drivers and relevant libraries:

sudo apt install mesa-vulkan-drivers mesa-vulkan-drivers:i386 libgl1-mesa-dri libgl1-mesa-dri:i386 libgles2-mesa-dri libgles2-mesa-dri:i386

Intel users typically need the same Mesa packages as AMD users, plus potentially the Intel Media driver for hardware-accelerated video playback:

sudo apt install intel-media-va-driver-non-free mesa-vulkan-drivers mesa-vulkan-drivers:i386

Now comes theWine installation. The Ubuntu Wine team maintains a repository that offers newer Wine versions than the default repositories. Add the Wine repository with these commands:

sudo mkdir -p /etc/apt/keyrings
wget -qO- https://dl.winehq.org/wine-builds/winehq.key | sudo gpg --dearmor -o /etc/apt/keyrings/winehq-archive.key

echo "deb [signed-by=/etc/apt/keyrings/winehq-archive.key] https://dl.winehq.org/wine-builds/ubuntu/ $(lsb_release -cs) main"|sudo tee /etc/apt/sources.list.d/winehq.list

Update your package list again and install Wine:

sudo apt update
sudo apt install --install-recommends winehq-stable

For users who prefer the development or staging branches (which sometimes offer better compatibility with newer games), replace winehq-stable with winehq-devel or winehq-staging. The staging branch includes experimental patches that can improve compatibility with certain titles.

Proton installation is simpler since it integrates directly with Steam. Install Steam through the Ubuntu software center or via command line:

sudo apt install steam

After installing Steam, launch it, go to Steam > Settings > Steam Play, and ensure "Enable Steam Play for all titles" is checked. Steam will automatically download and configure the appropriate Proton version for your games.

For enhanced gaming functionality, consider installing these additional packages:

sudo apt install gamemode libgamemode0 libgamemode-dev mangohud mangohud:i386 goverlay

Gamemode automatically optimizes system resources when gaming, MangoHUD displays performance metrics during gameplay, and GOverlay provides a graphical interface for MangoHUD configuration.

Setting Up Arch Linux and Manjaro

Arch Linux offers a more hands-on approach to software installation, with the Arch User Repository (AUR) providing access to an enormous range of software, including gaming tools. Start by ensuring your system is up to date:

sudo pacman -Syu

Enable the multilib repository for 32-bit support by editing /etc/pacman.conf, uncommenting the following lines:

[multilib]
Include = /etc/pacman.d/mirrorlist

Sync the new repositories:

sudo pacman -Syu

Install your graphics drivers. For NVIDIA systems:

sudo pacman -S nvidia nvidia-utils lib32-nvidia-utils vulkan-icd-loader lib32-vulkan-icd-loader

AMD users should install:

sudo pacman -S mesa lib32-mesa vulkan-radeon lib32-vulkan-radeon  libva-mesa-driver lib32-libva-mesa-driver

Intel users can use:

sudo pacman -S mesa lib32-mesa intel-media-driver libva-intel-driver vulkan-intel lib32-vulkan-intel

Wine installation on Arch is straightforward since it's in the official repositories. Install both the 64-bit and 32-bit versions:

sudo pacman -S wine wine-mono wine-gecko

sudo pacman -S lib32-wine lib32-wine-mono lib32-wine-gecko

For users who prefer the staging repository (which includes performance improvements and bug fixes not yet in stable Wine):

sudo pacman -S wine-staging wine-staging-mono wine-staging-gecko

sudo pacman -S lib32-wine-staging lib32-wine-staging-mono lib32-wine-staging-gecko

Proton installation is still handled through Steam, but Arch users might want to install the latest Proton version from the AUR (Arch User Repository):

yay -S protonup-qt

ProtonUp-Qt is a tool that helps you install different versions of ProtonGE (a community-enhanced version of Proton) and DXVK for Steam and Lutris; it usually offers better compatibility with the latest games.

Gaming utilities are readily available in the official repositories:

sudo pacman -S gamemode mangohud goverlay protontricks

Protontricks is a powerful script that helps you install Windows runtime libraries in specific Wine prefixes, which is crucial for running games that depend on DirectX or specific Windows components.

The Arch AUR also offers many specialized game-related tools:

yay -S lutris-git heroic-games-launcher-bin

Lutris is a game manager that handles games from various platforms (GOG, Epic, emulators, indie games), while Heroic is a launcher specifically for the Epic Games Store.

Setting Up Fedora and Red Hat-Based Distributions

Fedora takes a slightly different approach, focusing on free and open-source software by default. Gaming setup begins with enabling the RPM Fusion repositories, which provide proprietary and non-free software:

sudo dnf install https://mirrors.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm

sudo dnf install https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm

Refresh your package cache:

sudo dnf makecache

Install graphics drivers. NVIDIA users should be aware that Fedora specifically requires the RPM Fusion version of the driver:

sudo dnf install akmod-nvidia xorg-x11-drv-nvidia-cuda libnvidia-vdpau-driver
sudo dnf install xorg-x11-drv-nvidia-libs.i686

AMD and Intel users can use Mesa drivers:

sudo dnf install mesa-vulkan-drivers mesa-libGL

sudo dnf install mesa-libGL.i686

Wine installation on Fedora requires adding the WineHQ repository:

sudo dnf config-manager --add-repo https://dl.winehq.org/wine-builds/fedora/winehq.repo

sudo dnf install winehq-stable

For Plasma users (KDE Plasma desktop), Fedora also makes gaming straightforward with additional utilities:

sudo dnf install gamemode mangohud

Steam installation follows a pattern similar to other distributions:

sudo dnf install steam

Setting Up Lutris and Heroic Game Launcher for Wine/Proton

Linux gaming has become increasingly viable thanks to tools like Lutris and Heroic Game Launcher, which simplify running Windows games through compatibility layers. This guide walks you through installing these launchers, configuring Wine and Proton environments, and implementing DXVK for improved Direct3D performance. The focus here is on the post-driver-setup process, assuming your graphics drivers are already properly installed and configured.

Installing Lutris Across Different Distributions

Lutris serves as a meta-launcher that manages wine prefixes, runtime environments, and game configurations through an intuitive interface. The installation process varies slightly depending on your Linux distribution, so choose the commands appropriate for your system.

On Ubuntu-based distributions such as Ubuntu, Linux Mint, or Pop!_OS, add the official Lutris repository and install the application. First, install the necessary dependencies and repository signing key, then add the repository itself before finally installing Lutris. This process ensures you receive the latest stable version directly from the project's maintained packages rather than relying on potentially outdated distribution repositories.

For Fedora, RHEL, or CentOS users, the process involves enabling the RPM Fusion Free repository, which contains the Lutris package. After enabling the repository, a straightforward dnf install command fetches all required dependencies and the application itself. Arch Linux and Arch-based distributions like Manjaro benefit from Lutris being available in the Arch User Repository, where installation through your preferred AUR helper provides the most up-to-date version.

Installing Heroic Game Launcher

Heroic specializes in running Epic Games Store titles through Heroic Games Launcher, offering a dedicated interface for managing DRM-free and Epic-exclusive games without requiring the official Epic client. The installation approach mirrors the distribution-specific patterns established with Lutris.

Ubuntu users should download the official .deb package from the Heroic GitHub releases page and install it using dpkg or your preferred package manager, then fix any dependency issues that arise during initial installation.

Fedora users can add the Heroic COPR repository, which provides automated builds and updates through a one-time repository enablement command followed by a standard package installation.

Arch Linux users again have the advantage of AUR availability, where installation proceeds identically to Lutris through your chosen AUR helper.

Flatpak installation offers a distribution-agnostic approach that works across any distribution supporting Flatpak. Add the Flathub repository if you haven't already, then install Heroic through your software center or via command line using flatpak install, which ensures you receive a sandboxed, self-contained application package.

Configuring Wine and Proton Environments

Both launchers require Wine or Proton installations to run Windows applications, and proper configuration significantly impacts performance and compatibility. Lutris allows you to install multiple Wine versions simultaneously, toggling between them on a per-game basis.

Access the preferences menu, navigate to the runners section, and install recommended Wine versions—typically the latest stable release alongside a GE (Gaming Enhanced) build from the Glorious Eggroll project, which includes patches specifically for gaming performance.

Heroic integrates Proton functionality through Steam's Proton, which requires Steam to be installed on your system even if you don't actively use it for gaming.

Enable Proton in Heroic's settings, and the launcher automatically detects and utilizes available Proton versions.

For games that struggle with newer Proton releases, configuring an older version through Heroic's per-game settings often resolves compatibility issues.

Creating separate Wine prefixes for each game prevents library conflicts and allows fine-tuned optimization without affecting your entire library. Lutris creates prefixes automatically in your designated games directory, while Heroic manages Epic Games titles within its own prefix structure.

Implementing DXVK for Direct3D Performance

DXVK translates Direct3D 9, 10, and 11 calls to Vulkan, the graphics API native to Linux, providing substantial performance improvements for many Direct3D-based games. Both launchers support DXVK installation through their runner configuration interfaces.

In Lutris

select your Wine runner, access runner options, and enable DXVK

if it isn't included with your selected Wine version.

Manually downloading DXVK releases and extracting them into your game's prefix folder inside the drive_c/windows/system32 directory offers more control over versioning. Heroic includes DXVK management within its settings menu under the DXVK tab, allowing per-game version selection including DXVK-native and D9VK variants for older titles.

For maximum compatibility, match your DXVK version to your game era—newer DXVK releases work best with recent games, while older versions often prove more stable for titles from the Direct3D 9 or early 10 era. Testing different versions helps identify the optimal configuration for problematic titles.

Optimization Arguments and Distribution-Specific Tuning

Performance tuning involves export variables set before launching games, which both launchers support through their environment variable configuration fields. These optimizations apply regardless of your distribution.

The PROTON_NO_ESYNC=1 export addresses stability issues with certain games that don't properly handle esync, while PROTON_NO_FSYNC=1 serves the same purpose for games experiencing issues with newer kernel synchronization features. For AMD GPU users, RADV_PERFTEST=esync and the more aggressive vk_xwayland_scale=0 setting can improve frame pacing and reduce input latency.

Nvidia users should ensure the nvidia-drm modeset=1 kernel parameter appears in your bootloader configuration for proper Wayland support and reduced stuttering when using Vulkan applications. Frame rate limiters through mangoHud or the in-game settings prevent unnecessary GPU load that generates heat and power consumption without visual benefit.

Distribution-specific considerations include enabling Game Mode through gamemoded, which Ubuntu and Fedora users install from their default repositories. Arch users find gamemoded in the AUR. This daemon optimizes system resources when gaming by scaling CPU governors, preventing power-saving states from interfering with performance-sensitive applications.

Advanced Configuration and Optimization

With the basic installation complete, optimizing your gaming environment significantly improves performance and compatibility. Creating a dedicated Wine prefix for each game helps prevent conflicts between different games' dependencies and provides a clean environment for troubleshooting when issues arise.

Create a new Wine prefix using:

WINEPREFIX=~/.wine/mygame WINEARCH=win32 wineboot -u

This command creates a 32-bitprefix in your home directory. The WINEPREFIX environment variable tells Wine where to store this particular installation, keeping it separate from your default prefix.

Installing specific Windows dependencies often resolves compatibility issues. Protontricks simplifies this process considerably:

protontricks -s "Game Name"
protontricks 1234567 dotnet48 vcrun2019

Some games require specific graphics settings to run properly. You can configure Wine settings using winecfg:

winecfg

The winecfg dialog allows you to set Windows version compatibility (Windows 10 recommended for most modern games), configure graphics settings including virtual desktop resolution, and manage DLL overrides for specific libraries.

For Steam games specifically, you can pass launch options to customize how games run. Right-click a game in your library, select Properties, and enter launch options:

PROTON_NO_ESYNC=1 %command%

The PROTON_NO_ESYNC flag disables esync, which can resolve issues on some systems. Other useful proton environment variables include PROTON_DUMP_DEBUG_INFO (for debugging), and PROTON_USE_WINEDBG (which provides more detailed error reporting).

Troubleshooting Common Issues

Even with perfect setup, you'll occasionally encounter issues. Black screens upon launching games often indicate driver problems—ensure your Vulkan installation is correct and that you're using the appropriate graphics card. You can verify Vulkan functionality with:

vulkaninfo

Performance issues frequently relate to system configuration rather than software setup. Gamemode should activate automatically for Steam games, but you can verify its operation:

gamemoded -s

Sound problems in games sometimes require configuring Wine to use a specific audio backend. Edit your winecfg and navigate to the Audio tab to experiment with different options if sound isn'tworking correctly.

Games that crash on startup may need specific Windows DLLs or runtime libraries. The Wine Application Database (winehq.org) maintains extensive compatibility ratings and user-reported solutions for thousands of games.

The Broader Linux Gaming Ecosystem

With your gaming environment configured, exploring the broader Linux gaming ecosystem enhances your experience significantly. Lutris connects to multiple game platforms, automatically configuring Wine prefixes and dependencies for hundreds of games. After installation, you can add games through Lutris' browser extension, with most major titles having community-contributed installation scripts.

For Epic Games Store titles, Heroic provides a native Linux experience:

flatpak install flathub com.heroicgameslauncher.HGL

Heroic supports importing your Epic library and managing games similarly to Steam, with Proton compatibility built-in.

Linux gaming continues evolving rapidly, with the Steam Deck demonstrating that Linux can provide an excellent gaming experience even for casual users. The tools and techniques covered in this guide position you at the forefront of this transformation, giving you access to thousands of games on an operating system that respects your freedom and privacy.

The community around Linux gaming is remarkably active, with dedicated forums, Discord servers, and wiki pages documenting solutions for even the most obscure issues. When you encounter problems, these communities offer valuable support, and contributing your own solutions helps everyone in the ecosystem.

Your Linux gaming setup is now complete. Start Steam, enable Steam Play, and browse your library—many of your games will work immediately. For titles that need additional configuration, the tools and knowledge you now possess will guide you through optimizations that make Linux gaming not just viable, but in many ways preferable to other platforms.