If you've recently started using Linux and still need programs and games designed for Windows , you've probably come across Wine, Proton, Lutris… and, of course, Bottles. However, finding a clear and well-explained guide to Bottles isn't so easy, and many people end up giving up because it seems more complicated than it actually is.
In the following lines you will see, step by step, how to use Bottles to run Windows applications on Linux , how it relates to Wine, what role tools like Flatpak and Flatseal play, how to map your disks to install games on other volumes, what you can expect in terms of compatibility, and in which cases it is still better to use "pure and simple" Wine or even a virtual machine.
What is Bottles and how does it fit with Wine, Proton and Lutris?
Bottles is a graphical application that simplifies the management of Wine prefixes , which are isolated environments where Windows programs are installed and run within Linux. Instead of struggling with the terminal and Wine commands, Bottles offers a modern interface for creating, configuring, and maintaining these "containers."
In short, Bottles lets you use Windows software on Linux through "bottles," which are independent spaces with their own Wine, libraries, configurations, and programs. Each bottle can be customized for a specific software or game, enhancing compatibility and preventing application conflicts.
Wine, the underlying technology, acts as a compatibility layer , translating Windows API calls into native Linux (and other systems like macOS or BSD) calls in real time. This avoids the extra resource consumption typical of virtual machines because it doesn't virtualize a complete Windows environment, but rather "reproduces" the environment the program expects to find.
In the realm of gaming, projects like Proton (Steam) and Lutris have taken the lead as recommended options for playing games on Linux: they are highly polished, automate numerous configurations, and, in practice, tend to be less troublesome when launching complex titles. Bottles can run games, yes, but it shines particularly well as a tool for standalone Windows applications without a native client , such as editors, utilities, or the occasional lightweight launcher.
Installing Bottles on Linux with Flatpak and GNOME Software
The most convenient and standard way to have Bottles on almost any distribution is to use Flatpak and Flathub . Developers publish the main version there, which is usually more up-to-date than the version available in other formats or repositories.
On a modern Linux distribution, you'll only need to enable Flatpak and add the Flathub repository . This is usually done by following a few instructions specific to your distribution (Ubuntu, Debian, Fedora, Arch, etc.), available on the official Flatpak website. Once configured, you can install Bottles from the graphical store or the terminal.
If you use GNOME Software with Flatpak support , installation is especially simple: search for "Bottles" in the store, select the package from Flathub, and click install. The initial file is relatively small, as it contains the graphical interface, the welcome screen, and the basics; the remaining components (Wine, Gecko, and others) are downloaded as you create and configure bottles.
Many Linux distributions also recommend combining Bottles with Flatseal , a small utility used to control and adjust Flatpak application permissions . Flatseal allows you to grant or restrict Bottles' access to other disks, external directories, and devices—essential if you plan to install games or programs on secondary drives.
Prerequisites: Wine and 32-bit support
Although Bottles handles Wine version management internally, it's worth understanding what's under the hood. Wine is the engine that allows .exe and .msi executables to run on Linux, and in many distributions, it can also be installed independently.
On 64-bit Ubuntu-based systems, for example, the first step to using Wine "by default" is usually to enable 32-bit support , since it is disabled by default and many Windows applications are still 32-bit. The typical command for this is:
sudo dpkg --add-architecture i386
Next, update the repositories with a simple `sudo apt update` , and then add the official WineHQ keys and repositories to maintain a stable and up-to-date version of Wine on your system. Depending on your Ubuntu version (20.04, 22.04, 23.04, 23.10, etc.), you will need to add the corresponding `.sources` file from the Wine website.
Once this is done, you can install the stable branch with:
sudo apt install --install-recommends winehq-stable
Alternatively, you can choose the development or staging branch if you need the latest features, at the cost of a higher risk of errors. Although Bottles already integrates and manages its own versions, understanding these options helps you understand where the components Bottles downloads come from and why it sometimes refers to "Wine stable," "Wine development," or "Wine staging."
Modern versions of Wine and compatibility
The Wine project is evolving rapidly, and recent versions have incorporated significant improvements in performance, compatibility, and graphics support . A modern stable release (such as the 10.x line) includes thousands of individual changes, among them better support for ARM64EC architectures, finer HiDPI scaling, a revamped control panel, improvements to DirectPlay, and an FFmpeg-based Media Foundation backend for enhanced multimedia playback.
Newer development branches typically refine details such as updated Unicode tables, Zip64 package support , and a host of internal fixes that, while not immediately visible, make a significant difference for demanding applications. Previous major releases, such as 9.0, introduced key advancements like WoW64 support (running 32-bit applications on 64-bit systems), the first Wayland driver (later enhanced with OpenGL support and window adjustments), reimplementation of PostScript drivers for 2D/3D graphics, and improvements to ARM64, WinRT, and the compilation of Direct3D shaders to SPIR-V.
All this progress is gradually being transferred to Bottles , as the application relies on Wine to do the heavy lifting. From the terminal, you can always check which version of Wine your system is using with:
wine --version
If you find that your system version is very old compared to the one used in the latest WineHQ news, you might want to update or simply rely on Bottles itself to download newer Wine runners or builds within each bottle.
Creation and initial configuration of a bottle
The first time you open Bottles, the program will download some necessary dependencies (Wine components, Gecko, etc.) . Let that process finish, and as soon as the main interface appears, you'll be ready to create your first bottle.
To do this, simply click on the typical “Create new bottle” button or similar, give it a descriptive name (for example, “Notepad++”, “Game-X”, “Office”), and then choose the type of environment you want:
- Games: a profile designed for video games, with options and tweaks focused on performance and graphics compatibility.
- Application: ideal for productivity programs, utilities, editors, launchers, etc.
- : if you want to control the details yourself or are going to experiment with different configurations.
After choosing the type, click "Create," and Bottles will generate the Wine prefix (the "home" where your Windows program will reside). When it's finished, you'll see a message or window indicating that the bottle has been created; close it and return to the main screen, where your new entry will appear.
If you open that bottle, you'll see several sections: installed programs, tools, settings, disks, variables, etc. This is where you'll install and launch the .exe or .msi executables you want, and adjust everything necessary for them to work.
Install Windows apps and games inside Bottles
To add a Windows program to a pre-existing Bottle, the most direct method is usually to use the "Run executable" option or the built-in "uninstaller" (which works like the "Add or Remove Programs" panel in Windows). Many versions of Bottles include a Tools section with an "Uninstaller" that also contains an "Install" button.
The usual workflow is very simple: you select the bottle, scroll down to find the relevant tool, click on Install or Run executable , navigate to the installation file (.exe, .msi), and let the wizard run. From there, you follow the steps just as you would in Windows (next, next, accept license, installation path, etc.).
After installation, Bottles may automatically detect the new program and add it to the "Programs" list for that bottle . Returning to the bottle's panel, you should see the application's name next to a "Play" or "Launch" icon: simply click it to launch the software whenever you want, without having to manually search for the .exe file again.
This same procedure works for both lightweight applications (like Notepad++) and game installers. However, with some launchers like Steam or Epic Games running within Bottles, you might experience crashes or unexpected closures, as they combine DRM, their own updates, overlays, and other elements that don't always play well with compatibility layers.
Configuring disks and paths with Flatseal and the “Disk” section
If you plan to install games or large programs on a second disk, additional partition, or external drive , there are two things you should keep in mind: Flatpak permissions and drive mapping within the bottle itself.
On one hand, with Flatseal you can adjust Bottles' permissions so that Flatpak has access to those additional directories. Open Flatseal, select Bottles from the list, and within the settings, enable access to the paths or mount points you want to share (for example, /mnt/data, /run/media/user/ExternalDisk, etc.). Without this permission, Bottles simply won't see the folders, no matter how much you try to map them.
Then, from the Bottles settings, you'll usually find a section called something like "Disks" or "Drives" where you can map those directories to drive letters in the Windows style: C:, D:, E:... There you can select "add disk", choose the directory path and assign it a letter.
In practice, this works the same as drive mapping in Windows : if you map your external drive as D:, Windows installers will see that drive letter and you can install or run games from there. For large games, this is a very convenient way to avoid filling up your Linux system's main drive.
Something similar applies to games previously installed on Steam or Epic under Windows: in theory, you could specify the path to those existing libraries , but in practice, many users encounter errors when trying to install or update Steam/Epic clients within Bottles. For now, you'll notice that Bottles tends to work more smoothly running standalone games or direct installers , while for major platforms, it's still more reliable to use Proton (on Steam) or clients like Heroic, Lutris, etc.
Advanced Wine options within Bottles
While one of Bottles' advantages is that it saves you from struggling with numerous commands, it's still important to understand that, internally, much of what it does is based on winecfg, winetricks, and the traditional Wine options . Bottles allows you to display or adjust some of these settings graphically.
In plain Wine, the initial configuration is launched with the command:
winecfg
This is where necessary components like Wine-Mono or Gecko are downloaded , providing functionalities equivalent to .NET and the Internet Explorer rendering engine. Once completed, a configuration window opens with several tabs, which Bottles abstracts to a greater or lesser extent, but which are worth knowing:
- Applications: allows you to simulate different versions of Windows (XP, 7, 10, 11, etc.) globally or for specific executables, in case a program requires a specific version.
- LibrariesThis controls which libraries Wine uses (its own, the program's own, or native DLLs copied from a real Windows system). This is crucial for applications that require specific versions of certain files.
- Recorders: configures how Windows windows and the virtual Windows desktop are drawn, as well as fonts, mouse captures, and some visual details.
- desktop integration: marks where documents, downloads, music, etc. are stored within the Wine environment, and what themes or styles are applied.
- Units: manages the different mount paths seen as C:, D:, etc., just what Bottles simplifies with its disk section.
- Audio: allows you to choose sound driver, output, input and other audio-related details.
- About: simply shows the installed Wine version.
Bottles makes much of this setup easy through predefined settings and runners adapted to games or apps , but if an app is giving you trouble, it doesn't hurt to open the bottle's advanced settings and play around with these parameters until you find the sweet spot.
Tips to improve performance and compatibility
The experience with Wine and Bottles can vary considerably depending on the game or program, but there are some general best practices that usually help avoid problems. To begin with, it's always advisable to use the latest stable version of Wine that Bottles offers for each bottle, unless you know exactly which bug is fixed in a beta version.
Before you attempt to install a complex game, it's a good idea to search for it in the WineHQ database (or in parallel repositories) to see its category: Platinum (works perfectly), Gold (works very well with minor adjustments), Silver (some minor bugs), Bronze (quite problematic), or Garbage (unusable). You'll often also find notes from other users with recommended configurations, required DLLs, or special flags.
Another interesting practice is to take advantage of Wineprefixes , which are essentially different, independent Wine environments. Bottles already organizes the use of prefixes per bottle, allowing you to have isolated configurations for each application or game and preventing a change or library installation in one bottle from breaking another.
To resolve typical dependencies (.NET, Visual C++, Microsoft fonts, etc.), the classic tool is winetricks . Although Bottles automates some of this management, it's useful to know that winetricks allows you to install packages like corefonts, vcrun2013, and similar ones, which many applications require to start correctly.
In some cases, disabling technologies like DXVK or VKD3D in the Bottles settings can help diagnose problems with specific games: these layers translate DirectX to Vulkan, which usually improves performance, but can also cause incompatibilities with very specific hardware or drivers. If you disable these options, the program will attempt to use native DirectX based on what Wine supports.
Practical example: preparing a bottle for Photoshop with Winetricks
A classic example in the Wine world is getting Photoshop to work . Some versions, like Photoshop CS6, have a "Gold" rating in WineHQ, meaning they work quite well with a little tweaking of the settings.
To achieve this in a traditional Wine environment, winetricks are used to install certain components: for example, the Microsoft basic sources with the command winetricks corefonts and the necessary Visual C++ libraries with winetricks vcrun2012 vcrun2013Then, from winecfgYou can go to the Libraries tab and specify that DLL as msvcp120 y msvcr120 are used in “native, integrated” mode.
In Bottles, much of this process is simplified thanks to predefined recipes and configurations . If a popular application requires certain components, the bottle's profile will usually already offer them or allow them to be installed from a graphical menu, without having to type all the commands manually.
These kinds of adjustments demonstrate that, with a little perseverance, complex programs originally designed only for Windows can work more than decently on Linux, although some initial setup time may be required.
Common problems with Wine and Bottles
Although technology has advanced tremendously, it's important to accept that not everything that exists for Windows will work perfectly on Linux with Wine or Bottles. Many common problems are related to the libraries used by programs and games, so it's often recommended to install additional tools like Winetricks or even frontends like PlayOnLinux, which offer configuration scripts specific to certain titles.
There are also programs that depend on very specific .NET components or frameworks like Mono. Installing Mono and the appropriate .NET runtimes can be crucial for some applications to even start. Bottles and Winetricks help resolve these dependencies in a more or less guided way.
Sometimes, Wine itself stops behaving as it should after multiple changes, installations, and tests. A radical but effective solution is often delete or rename the .wine folder in your home directory (or the specific wineprefix you're using), so that when you run it again winecfg The entire configuration is regenerated from scratch.
If you don't want to delete anything, you can always create a new prefix with a command like WINEPREFIX=$HOME/.foobar winecfgThis will create a parallel, clean environment. From there, you can test your applications in this new context without touching the previous one. In less drastic cases, it's also possible to clean the DLL configuration with winetricks alldlls=default to return to standard behavior.
Finally, keep in mind that hardware with proprietary drivers (such as certain NVIDIA cards) and aggressive DRM systems (Denuvo, anti-cheat software, etc.) can cause many more problems or even prevent a game from running altogether. In some cases, you could even face bans if an anti-cheat system detects the Wine environment as suspicious.
Security when running Windows .exe files on Linux
One of Linux's biggest advantages is its superior security against Windows malware , simply because Windows executables don't run natively here. But the moment you introduce a layer like Wine (or a package manager like Bottles), you open the door for that software to run.
A malicious file intended for Windows can affect your Linux system if you run it with Wine , especially if the environment has broad access to the file system. Hence the importance of caution: don't run .exe files from dubious sources, configure the bottles with the minimum necessary access, and use permissions tools (like Flatseal) to limit what each application can see and modify.
In the context of files downloaded from the internet, it's also common for the system to prevent you from running them due to insufficient permissions. To fix this graphically, simply go to the file's properties, open the permissions tab, and check the box for “Allow the file to be executed as a program”If you prefer the terminal, you can change permissions with chmodBeing chmod 777 archivo.exe the most permissive variant (although not the most recommended in terms of safety).
Uninstall Wine and clean up any remaining traces (if you stop using it)
It's possible that, after experimenting with Wine and Bottles for a while, you might decide you no longer need that layer on your system or that you prefer to use only a virtual machine. In that case, it's useful to know how to remove Wine in an orderly fashion and free up space.
On systems with winehq packages, the typical command to completely uninstall the stable version is:
sudo apt-get remove --purge winehq-stable
Next, you should manually delete the configuration and cache folders in your home directory: the infamous ~/.wine , the related menu entries in ~/.config/menus/applications-merged/ , the shortcuts in ~/.local/share/applications/wine/ , the desktop entries in ~/.local/share/desktop-directories/ , and the leftover icons in ~/.local/share/icons/ . All of this can be listed and carefully deleted, making sure to show hidden files.
Once those remnants have been removed, the commands sudo apt update, sudo apt autoclean, sudo apt clean y sudo apt autoremove They finish cleaning up any remaining dependencies. Finally, you can remove the WineHQ repository from your software sources configuration if you no longer plan to use it.
In Bottles' case, it would suffice to Uninstall Flatpak from GNOME Software or using flatpak uninstall, and then delete the remaining configuration folders in ~./var, ~/.config, etc. as indicated in the Flatpak documentation.
Which programs and games tend to work best
The goal of Wine (and by extension, Bottles) is to allow a large portion of Windows software to run on Linux , but in reality, compatibility varies considerably. In the WineHQ database, applications are categorized based on their actual functionality.
The Platinum category includes applications and games that function virtually flawlessly, without any special adjustments. Typical examples include specific versions of World of Warcraft, Fallout 3, Adobe Animate CS6, .NET Framework 3.5, Diablo III, and 32-bit Microsoft Word 2010.
The Gold category includes software that requires minor configurations, but then runs very smoothly: Adobe Photoshop CS6 , StarCraft 1.16.1, The Witcher 1.x, all installments of The Sims 3 or Final Fantasy XIV in certain expansions, among others.
Silver includes programs that may have minor errors but are still usable, such as the Microsoft Office 2019 installer, certain versions of StarCraft, Final Fantasy XI, Magic: The Gathering Online, Half-Life 2, or Planescape: Torment.
Since it's a community project, development priorities are usually determined by user votes and requests : the more interest a game or application generates, the more attention it receives in terms of patches and improvements. For very obscure software, sometimes the only option is to try your luck and attempt installation on a specific bottle, experimenting with different Wine versions and libraries until you find the right combination.
Gaming on Linux: Proton, PlayOnLinux, DOSBox and virtualization
When the focus is purely on playing Windows games on Linux , Bottles is just one more piece on the board. The most powerful combination these days is usually Steam + Proton, where Proton is a Wine-based layer, finely tuned for gaming, that handles all the heavy lifting without you having to touch a thing.
Thanks to Proton and SteamOS (like the one on the Steam Deck, based on Arch Linux), most Steam games can be run on Linux with a near-native experience, including support for NVIDIA and AMD graphics cards. The catalog of verified and playable titles on Linux grows every month, and often all you need to do is enable the "allow Proton for all titles" option, and you're good to go.
If the game isn't on Steam or doesn't have good Proton support, an alternative is to use PlayOnLinux , which offers specific scripts and configuration profiles for many titles. Each game runs in an independent environment with its own libraries and settings, which is quite reminiscent of the Bottles philosophy, but specifically focused on games and with a slightly different interface.
For very old MS-DOS-era games, the easiest option is usually to use DOSBox , which emulates a classic DOS environment where the games run as if they were on a PC from that era. If you need a complete Windows environment (with drivers, advanced features, and full compatibility), then the ideal solution is to use a virtual machine with VirtualBox, VMware, or similar software , although this will require more resources and a valid Windows license.
In summary, Bottles fits very well as an application management tool and some specific games that work better with a carefully configured Wine, while for the vast majority of massive gaming it is still more practical to use Proton, Lutris, Heroic or other dedicated platforms.
By combining Wine's compatibility engine with a user-friendly interface like Bottles, good permission control with Flatpak and Flatseal, and knowing when to rely on technologies like Proton or full virtualization, it's perfectly feasible to set up an environment on Linux where you can run most of your Windows programs and games with very decent performance and, most importantly, with considerably less of a headache than it used to involve a few years ago.
