Windows Games on Arch Linux (Part 2): Running Non-Steam Games with Bottles (Epic, GOG, EXEs)
arch linux bottles epic games flatpak gaming linux gaming setup linux tutorials proton wine
Your Steam library runs perfectly. But those Epic freebies? GOG classics? They’re gathering digital dust.
If you’re an Arch Linux user who wants to play everything without dual-booting, you’re in the right place.
Welcome back to MusaBase. In Part 1, we used Proton to run Steam titles. Now we move beyond Steam.
This guide shows you how to run non-Steam Windows games and applications on Linux, including Epic Games Store titles, GOG offline installers, and standalone .exe files using Bottles.
Bottles provides a clean, user-friendly way to create isolated environments for Windows games and applications on Arch Linux. It simplifies setup, configuration, and runner management so you can focus on actually playing your games.
Here’s what we’ll cover:
- Install Bottles using Flatpak and AUR
- Configure Bottles for gaming and application use
- Install and launch Epic Games Store titles
- Run standalone .exe files and already installed Windows games
- Fix common launching and compatibility issues
Prerequisites
Before continuing, make sure your system is properly prepared. This guide is written using Arch Linux as the reference environment, but the overall concepts apply to most Linux distributions.
- A working Linux installation with a graphical desktop environment.
- A non-root user with sudo privileges.
- An AUR helper (yay recommended) if you plan to install Bottles from AUR.
- Properly installed GPU drivers such as AMDGPU, NVIDIA, or Intel.
- The multilib repository enabled on Arch for 32-bit Wine support.
Run grep -E "^\[multilib\]" /etc/pacman.conf to confirm multilib is uncommented.
For a smoother experience, I recommend setting up your system as a stable daily-driver Arch Linux environment, which covers yay, essential packages.
Troubleshooting Note for Downloads
Throughout this guide, some packages may fail to download or install properly. You might see an error in the terminal similar to:
curl: (28) Failed to connect to "package-name.mirror.org" port 443 after XXXX ms: Could not connect to serverThis does not mean the package is missing or that there is a problem with the AUR. In most cases, it is caused by one of the following:
- Network or Firewall Restrictions: Your local firewall, ISP, or proxy may be blocking outbound connections on certain ports such as 443 (HTTPS).
- Mirror Issues: The selected package mirror may be slow, temporarily down, or undergoing maintenance.
- DNS Problems: Your configured nameserver may be failing to resolve the mirror's IP address.
I encountered similar issues while installing bottles and winegui, and documented the full solution in my Fixing Slow Pacman Downloads on Arch Linux guide. If you continue to face the same issue, you can also try installing the packages while connected to a VPN.
Step 1: Set Up Flatpak on Arch Linux
Flatpak is a universal packaging system that runs apps in isolated environments with their own dependencies. On Arch Linux, it's a popular way to install desktop apps without system library conflicts.
1.1: Install Flatpak
- Installing Flatpak on Arch Linux is straightforward. Open a terminal and run:
sudo pacman -S flatpak- Next, add the official Flathub repository (remote) to Flatpak.
- Run the following command and then reboot your system:
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
1.2: Install Flatseal to Handle Permissions for Bottles
When I first installed Bottles via Flatpak on Arch Linux, I ran into a confusing issue while trying to run my Windows games and applications on Linux. If the game files were stored outside my Linux root partition, for example on a separate drive, Bottles simply wouldn’t launch them.
At first, I assumed this was a Linux limitation. After digging deeper, I realized the real reason: Bottles was running inside a Flatpak sandbox. By design, it cannot access system drives or folders unless explicit permission is granted.
There are two ways to solve this. The hard way means running commands like flatpak override --filesystem=/mnt/games com.usebottles.bottles for every single drive and folder. Do this for three drives? That's three commands. Ten games? More complexity. It works, but it's tedious and error-prone.
The easier and more practical solution is to use Flatseal, a graphical tool that lets you manage these permissions without touching the command line.
- Install Flatseal to manage Flatpak permissions:
flatpak install flathub com.github.tchx84.Flatseal
Why Flatpak Needs Permissions
Flatpak applications run inside a sandboxed environment. This means they are isolated from the rest of your system for security and stability reasons. By default, a Flatpak app cannot access external drives, custom game directories, or system folders unless you explicitly allow it.
This design improves security, but when running Windows games and applications on Linux, especially those stored on separate partitions or secondary drives, you must manually grant access. Without proper filesystem permissions, Bottles will not see or launch those game files.
Flatpak and Flatseal are now installed. In the next step, we’ll install and set up Bottles to start running Windows games on Linux.
Step 2: Install Bottles (Two Methods)
There are two common ways to install Bottles on Arch Linux. The first method uses Flatpak, which provides an isolated setup with bundled dependencies. The second method installs Bottles from the AUR, allowing it to use the system’s native shared libraries and integrate more closely with the Arch Linux environment.
If you want to keep Bottles isolated from the rest of your system, the Flatpak method is more suitable. However, it may require extra steps such as managing permissions, ensuring proper GPU runtime support, and handling potential driver mismatches.
From my experience, installing Bottles from the AUR feels more straightforward on Arch Linux because it avoids additional configuration steps like permission handling or GPU runtime adjustments.
In this guide, we will cover both methods so you can choose the one that best fits your setup.
2.1: Install Bottles from AUR
If you prefer a simple install that integrates directly with your system and uses your existing libraries, the AUR method is the better choice. Installing Bottles from the AUR allows it to use Arch Linux’s native system libraries, GPU drivers, and updates directly. This avoids Flatpak-specific permission management and sandbox limitations, making the setup more straightforward if you prefer tight system integration and minimal extra configuration.
- To install Bottles from the AUR, run:
yay -S bottles- After running the command, yay will calculate and resolve all required dependencies for Bottles automatically.
- You may see prompts such as Packages to cleanBuild? and Diffs to show?. In most cases, you can safely press Enter to skip these steps. If certain dependencies are missing, yay may compile them from source, which can take a few minutes depending on your system. This is normal on Arch. Don't interrupt the process.
- Yay will also ask for confirmation before installing required packages such as python, webkit2gtk, gamemode, and other supporting libraries. When prompted with Proceed with installation [Y/n], simply press Enter to continue.
2.2: Install Bottles from Flatpak
If you prefer to keep Bottles isolated from the rest of your system, the Flatpak method is a good option. It runs Bottles inside a sandbox with bundled dependencies, reducing the risk of system library conflicts. However, after installation, you may need Flatseal to manage permissions, ensure the correct Flatpak GPU (GL) runtime extensions are installed, and enable required 32-bit driver support for proper gaming performance.
- To install Bottles using Flatpak, run:
flatpak install flathub com.usebottles.bottles
- After running the command, Flatpak will display the runtime components and dependencies required by Bottles before installation.
- Press Enter to confirm. Flatpak will then download and install Bottles along with its required runtime packages.
| Feature | Bottles (AUR) | Bottles (Flatpak) |
|---|---|---|
| Integration with Arch Linux | Uses native system libraries and GPU drivers | Runs in an isolated sandbox environment |
| Permission Handling | No extra permission management required | Requires manual permission control (Flatseal recommended) |
| Driver & Runtime Compatibility | Directly uses system Vulkan, Mesa, NVIDIA drivers | Uses Flatpak runtime; may require GPU runtime alignment |
| System Isolation | Fully integrated with the system | Sandboxed and isolated from host filesystem |
| Ease of Setup (Arch Users) | Simpler on Arch if yay is already installed | Requires Flatpak setup and permission adjustments |
| Recommended For | Users who prefer tight system integration | Users who prefer isolation and stability |
With Bottles now installed, whether through AUR or Flatpak, the base setup is complete. The next step is to launch Bottles for the first time and configure it properly.
In the following section, we’ll walk through the initial startup process, create your first bottle, and prepare the environment to run Windows games and applications smoothly on Arch Linux.
Step 3: Bottles First Launch Configuration
Bottles is now installed using either the AUR or Flatpak method. In this section, we’ll launch Bottles using both approaches. The launching process is slightly different, but everything else remains the same, whether it’s creating bottles or running Windows games and applications. This step prepares the environment to properly run Windows software on Arch Linux.
3.1: Handling Permission for Bottles via Flatseal
If you installed Bottles via Flatpak, remember that it runs inside an isolated sandbox environment. This means it cannot access files, services, or external drives outside its sandbox unless you explicitly allow it to.
If your game library is stored on a separate storage drive, Bottles will not be able to launch those Windows applications or games by default. To fix this, grant the correct filesystem permissions using Flatseal, which we installed in Step 2.
Allow Bottles to Access Game/Application Folder
- Open Flatseal from your application menu or launch it from the terminal:
flatpak run com.github.tchx84.Flatseal
- Select Bottles from the sidebar.
- Scroll down to the Filesystem section.
- Next, in the Filesystem section, you can allow Bottles to access All System Files (filesystem=host), which gives it access to all connected storage devices, including USB drives and SD cards. However, this effectively removes the entire "sandbox" principle. If you accidentally run a malicious application or game, it would have access to all your data.
- The safer and more recommended approach is to grant access only to the specific folder where your Windows applications and games are stored, using the Other files option inside the Filesystem section.
- Click the folder or + icon from the Other files option.
- Copy your folder path and paste it into the input field under Other files. That’s it. Bottles will now have access to your Windows games and application folder.
- One last thing to check: in the Devices section, make sure All devices is enabled. To properly run games, Bottles needs access to GPU acceleration, shared memory, and input devices.
3.2: Launch Bottles
Now that everything is set, let’s launch Bottles and create our first bottle. One thing to note here is that only the launching process is different between the two versions of Bottles. After properly handling permissions via Flatseal, the practical difference between the AUR and Flatpak versions becomes minimal.
- Run the following command in the terminal for the Flatpak version:
flatpak run com.usebottles.bottles- Run the following command in the terminal for the AUR version:
bottles- On the first launch, Bottles will automatically configure its services, including runners (Soda, Wine) and components such as DXVK, VKD3D, and related dependencies required for running Windows games on Linux.
3.3: Creating First Bottle
- Click on Create New Bottle....
- Type any name you want for your bottle (e.g., Gaming).
- Select the Purpose or Environment for your bottle (e.g., Application, Gaming). For this guide, I'm choosing Gaming.
- By default, the runner is set to Soda. If you are planning to use this bottle only for gaming, the Soda runner is best suited.
- Think of the runner as an engine that translates Windows game or application code into Linux-compatible and processable code.
- Click Create.
- After clicking Create, Bottles will start creating your bottle with optimized settings and components required for your selected environment.
3.4: Bottle Manual Configuration
By default, Bottles sets itself up with pretty optimized settings when you first create it. But if you want extra features like performance stats, game capture, a dedicated sandbox, synchronization, DLL overrides, or custom environment variables for certain games, you’ll need to configure those manually.
On Windows, I used MSI Afterburner with RivaTuner to monitor my system performance, GPU usage, and temperatures with an in-game overlay. Linux doesn’t have MSI Afterburner, but we do have MangoHud. It’s not a full replacement since Afterburner also lets you tweak GPU settings, but MangoHud does a great job showing real-time performance stats while you’re playing.
Here’s how to do it:
- In your bottle’s Options section, click on Settings.
- Scroll down to the Performance section and click the ⚠️ icon next to Monitor Performance. (The toggle button may appear greyed out or unresponsive.)
- Bottles will provide the exact Flatpak command required to install MangoHud so it can integrate seamlessly. Copy the command and close Bottles.
- Open your terminal and run the following command:
flatpak install flathub org.freedesktop.Platform.VulkanLayer.MangoHud
- After installing MangoHud, reopen Bottles and go back to Settings.
- In the Performance section, toggle Monitor Performance to enable it. (It should now be clickable.)
- Whenever you launch a game, MangoHud will display an overlay in the top-left corner showing FPS, CPU usage, and GPU usage.
Your first Bottle is now successfully created and configured. We’ve seen how to manually tweak settings, enable performance monitoring. So now there’s nothing holding us back. The environment is fully prepared with the required components in place. In the next step, we’ll move forward and install a Windows game or application inside this Bottle, then properly launch and test it on Arch Linux.
Step 4: Install and Run Windows Games and Application on Linux Using Bottles
Now comes the fun part. Since 2020, Epic has been giving away free games every week, and let’s be honest, most of us have been claiming them nonstop. But actually playing them? Not so much. 😅 Personally, I’ve only played GTA V, Death Stranding, Control, and Wolfenstein from my Epic library so far. The rest are just sitting there, claimed but untouched. Well, this is where that collection finally becomes useful. We’ll install the Epic Games Launcher inside Bottles we created in Step 4, download one of those titles, and run it directly on Arch Linux. From setup to gameplay, you’ll see the complete real-world workflow.
4.1: Install Epic Games Launcher
- Open your freshly created bottle.
- Next, in the Programs section, click on Install Programs....
- Under Installers, click the 💾 icon in front of Epic Games Store.
- A new pop-up window will appear. Click Start Installation, and Bottles will begin configuring the required dependencies and installing the Epic Games Launcher.
- This process can take around 2–5 minutes. If any error appears during installation, simply close the pop-up and try installing again.
4.2: Launch Epic Games Store
- After installing the Epic Games Store, Bottles will automatically create its shortcut inside your current bottle’s Programs section.
- Click the ▶️ icon in front of Epic Games Store, and Bottles will launch it.
- On first launch, the Epic Games Launcher on Linux will follow the same initial setup process as on Windows, including checking for updates, downloading required components, and then prompting you to sign in to your Epic account.
4.3: Install and Launch a Game from Epic Games Store on Arch Linux
Now, I’ve claimed many free games from Epic over the years. But for demonstration in this guide, I’m going to install 20 Minutes Till Dawn because it downloads and installs quickly, making it perfect for testing.
4.4: GOG Installation
GOG Games Work the Same Way: I don’t actually have a GOG account, so I can’t show the full step-by-step process of installing it and playing games from it here. That said, it works pretty much the same as what we just did with the Epic Games Store. Whether you’re installing through GOG Galaxy or using the offline installer, the steps don’t really change. Just open your Bottle, pick the GOG installer, and you’re good to go.
4.5: Run Standalone .EXEs or Already Installed Games on Linux
Okay, now let’s run some real OG classics like Need for Speed Most Wanted 2005 on Linux using Bottles. I already have NFS MW 2005 installed on my Windows drive along with tons of other games. So now I’ll show you how you can run your already installed Windows games through Bottles. The launching process is pretty much the same for any game.
Now, Need for Speed Most Wanted 2005 is an older title and officially only supports up to 720p. But let’s be honest — most of us are playing at 1080p or higher these days. On Windows, we usually fix this using the NFS Most Wanted Widescreen Fix to scale it properly to 1080p widescreen.
However, this mod doesn’t always work out of the box on Linux, whether you're running the game via Bottles or Steam. So to make it work properly, we need to add a DLL override. This tells the bottle to use the modded files instead of the default ones — kind of like what we did earlier in manual bottle configuration.
- Open your bottle and scroll down to the Compatibility section.
- Click on DLL Overrides.
- Enter dinput8 and click ✅ to save.
4.6: Launch Need for Speed Most Wanted 2005
- Open the bottle we created in Step 4.
- In the Programs section, click + Add Shortcuts....
- Navigate to your game’s installation folder and select the game’s .EXE file.
- Once added, a new shortcut entry for your game will appear.
- Click ▶️ and enjoy your game!
4.7: Install Custom Proton/Wine Runner on Bottles
In the previous guide about setting up Arch Linux for Windows gaming with Steam, I showed how to install ProtonUp-Qt. Now, if you run into issues with a newer game, or a specific title that’s marked as Playable on ProtonDB but still refuses to launch on your system, the problem might be the bottle’s default runner (Soda).
In that case, we can install a custom Proton or Wine version inside Bottles and switch the runner. Often, just changing the runner is enough to get a game working that previously wouldn’t launch.
- Open ProtonUp-Qt (install it first if you haven’t already).
- Select Bottles from the application list and click Add Version.
- From the Compatibility dropdown, choose the Runner you want to install (e.g., ProtonGE, Lutris Wine, etc.).
- Next, choose your preferred version from the Version dropdown and click Install.
- The installation may take around 2–5 minutes, depending on your internet speed.
- Once installed, the custom runner will appear under Installed Compatibility Tools on the ProtonUp-Qt home screen.
4.8: Enable Custom Proton/Wine Runner on Bottles
- After the custom Proton version is installed, open your bottle.
- Click on Settings.
- Next, in the Components section, click the 🔻 icon in front of the Runner tile.
- Select the custom runner we just installed. Bottles will show a Proton Disclaimer — click I got it, then click Use Proton.
- After changing the runner, the bottle will automatically adjust its configuration for the new runner. This usually takes less than 1 minute. Let it finish, and your games will be ready to run using the custom runner.
Why does switching the runner fix compatibility issues? Because different Proton and Wine versions include different patches, DXVK updates, Vulkan improvements, and game-specific fixes. Sometimes a game that refuses to launch on the default soda runner works instantly with a newer Proton GE or Lutris Wine version. It’s not magic, it’s just better translation layers and newer compatibility patches.
And here are some of the games I regularly play on Arch Linux using Bottles, all running smoothly.
Far Cry 5
Red Dead Redemption
Marvel's Spider-Man: Miles Morales
🎮 Final Thoughts: From Windows to Native Linux Gaming
Look, I'll be honest with you. When I first started using Linux, I kept a dual boot setup specifically for gaming. I'd install a Windows game through Bottles, it'd crash. I'd try a different Wine version, something else would break. Back then, Bottles wasn't this smooth. The runner situation was messy, dependencies were a nightmare, and half the time I'd end up back on Windows just to play something.
These days? It's a completely different story. Bottles has evolved significantly. You get their own Soda runner integrated right out of the box, dependencies are handled automatically, and honestly, most of my Windows games just work. No tinkering, no terminal battles, no rebooting into Windows.
That said, I still use plain Wine for certain apps and older games. It's not dead, just more of a power user tool now. I'll probably cover that in a future part (Wine deep dive), because some people prefer the lightweight approach. But for daily gaming? Bottles is where it's at.
Windows vs Bottles: How They Compare
| Scenario | On Windows | On Arch Linux (Bottles) |
|---|---|---|
| Epic Games Store | Download installer, click next a few times, done | Bottles, Install Programs, Epic, Start Installation (2–5 minutes) |
| Standalone .EXE (like NFS MW 2005) | Double-click, run as admin if needed | Bottles, Add Shortcuts, select .exe, launch |
| Game saves and config | Located in Documents or AppData folders | Inside bottle's virtual C: drive (isolated from system) |
| Modding (DLL overrides) | Drop files in game folder, maybe run as admin | Drop files plus add DLL override in Bottles settings |
| Runner switching | Not applicable (you're on Windows) | Components, Runner, pick ProtonGE, Wine, or Soda |
What You've Actually Learned
- Bottles isn't magic. It's just Wine with a UI and sensible defaults. But that UI saves hours of headache.
- Flatpak vs AUR. Both work. AUR feels more native, Flatpak is more isolated and needs Flatseal.
- Runners matter. If a game won't launch, switching from Soda to ProtonGE often fixes it.
- DLL overrides aren't scary. They're just telling Bottles to use a modded file instead of the default one.
- Your Windows games folder is usable. You don't need to reinstall everything. Just point Bottles to it.
Bottom line? You're not running Windows games on Linux anymore. You're just running games. The OS underneath doesn't matter if everything works.
That's it for running Windows games on Arch Linux. Your gaming library is now accessible, your system is dialed in for performance, and you have the tools to troubleshoot any compatibility issues. If you run into problems with a specific game or just want to share your setup, drop a comment below.
Game on, catch you in the next one. 🎮
