- WinBoat runs a real Windows with KVM and Docker and integrates its windows into Linux.
- Greater compatibility than Wine, with GPU limits and kernel anticheat.
- Clear requirements: active KVM, rootful Docker, FreeRDP 3 and 32 GB in /var.
Making the switch to Linux commands respect, and almost always for the same reason: compatibility with Windows applications . Although there are open-source alternatives for almost everything, they don't always cover 100% of your needs, and you might still depend on that editor, that ERP, or that specific game that only works on Microsoft's system.
This is where WinBoat comes in: it's not another Wine-like layer, nor a heavyweight virtual machine in the traditional sense. WinBoat runs a real Windows environment under the hood , with KVM virtualization and Docker containers, and integrates its windows into your Linux desktop via FreeRDP/RemoteApp. The result is that Windows apps behave almost natively, without the need for a dual boot or dealing with cryptic configurations.
What is WinBoat and what is it for?
WinBoat is a free and open-source application that aims to bridge the gap between the two worlds: pure "Windows for Penguins ." Its creator, known as TibixDev, has designed a polished interface with automations to make setting up a Windows environment integrated with Linux as simple as possible, suitable for both Windows newcomers and advanced users who require reliability.
Essentially, it launches a real Windows system and presents its programs as separate windows within your GNOME, KDE, or other desktop environment. If something works on Windows, it will most likely work here , with two major exceptions: applications that require high-level graphics acceleration (GPU passthrough) and games with kernel-level anti-cheat.
In addition to window integration, WinBoat offers practical options: a full Windows desktop on demand , smart card pass-through, resource monitoring, and improvements that arrive with each version. The idea is not to emulate or translate APIs, but to encapsulate Windows and expose its apps in a convenient and stable way.
If you've used WinApps, you'll notice a different approach. In that project, configuration is more user-intensive: more manual steps and less automation. WinBoat reduces that effort with a graphical wizard and a more cohesive experience, without sacrificing control when you need to fine-tune things.
How it works: KVM, Docker, and FreeRDP under the hood
WinBoat's key technical strength lies in combining proven technologies: KVM for hardware-assisted virtualization , Docker as the infrastructure orchestrator, and FreeRDP/RemoteApp for composing windows on the Linux desktop. You won't see a traditional virtual machine "monitor": you'll see detachable, dockable, resizable, and movable windows, just like any other native application.
To ensure a smooth workflow, WinBoat mounts your Linux user directory within the Windows guest environment. File sharing is instantaneous and requires no additional network setup. You can open a specific Windows app, switch between desktops with Alt+Tab, move it between desktops, or, if needed, open the entire guest desktop.
This approach avoids the typical Wine call translation errors because it doesn't translate anything: it runs genuine Windows . In return, it consumes more resources than a simple compatibility layer, which is something to keep in mind if you have a modest computer.
In terms of presentation, WinBoat uses a modern interface (based on Electron) to make installation and startup less intimidating. The idea is that the user only needs to do what's necessary : you select your preferences and the system does the rest.
Requirements and compatibility with distributions
To ensure everything works correctly the first time, it's advisable to review the requirements checklist. WinBoat requires virtualization enabled in BIOS/UEFI (Intel VT-x/AMD-V) and access to KVM from the Linux kernel. If KVM is blocked or disabled, it won't boot, no matter how well you install the rest.
The reasonable minimum requirements are: 4 GB of RAM for the guest (ideally 8 GB or more to avoid overloading the host), a CPU with at least two threads, and about 32 GB of free space, preferably in /var, where images are downloaded and data is stored. You'll also need Docker and Docker Compose v2, which in WinBoat must run in "rootful" mode (with normal Docker privileges).
Important: There is currently no support for Docker Desktop , rootless containers, or Podman. In environments that replace Docker with a Podman socket, communication with the guest breaks down. It's on the roadmap, but there are networking issues to resolve.
On the remote desktop side, WinBoat relies on FreeRDP 3.xx with audio . Make sure you have that branch installed to avoid any sound issues. And by the way, the user running WinBoat must be in the `docker` group to avoid having to use `sudo` constantly.
As for distributions, the range is wide. If your distro supports AppImage, .deb, or .rpm , it's likely to work (Ubuntu, Fedora, Mint, etc.), provided you meet the above requirements and have Docker and KVM properly configured.
Download, installation and available formats
The project publishes builds that make it easy to get started quickly. You can choose between the AppImage (portable) or the unpacked package ("Unpacked"), where you simply run the binary in `linux-unpacked/winboat`. On some distributions, you'll find .deb or .rpm files provided by the community or the repository itself, when available.
The first setup downloads and deploys the base Windows image used by WinBoat. You don't start from scratch unless you choose to: the wizard automates much of the process, and in a matter of minutes, you'll have your environment ready. In some cases, options are offered to use a custom ISO if you need a Windows installation with specific requirements.
The initial provisioning time can take around half an hour on normal connections. Make sure you have a stable network connection during this phase. After that, launching Windows apps or opening the desktop is much faster.
Remember that you'll need to install some components yourself: Docker, Compose v2, FreeRDP 3, membership in the docker group, and the iptables modules (iptables and iptable_nat). Once that's set up , the rest is fairly straightforward and guided by the app.
Compile from source and development mode
If you prefer to build WinBoat on your own machine, the process is straightforward as long as you have the dependencies. You'll need NodeJS and Go installed before starting. The basic steps, summarized and adapted, are as follows:
git clone https://github.com/TibixDev/WinBoat
npm i
npm run build:linux-gs
The resulting binaries will appear in the dist folder, with AppImage and Unpacked variants. For development, you can launch a local environment with npm rundev after compiling the “guest server” with npm run build-guest-server. This speeds up iteration whether you are going to contribute or debug.
USB, peripherals and hardware settings
The USB passthrough is on the radar of the graphical interface, but today can be used manually. Once WinBoat is installed, edit the layout file in ~/.winboat/docker-compose.yml to expose specific USB devices to the guest. After the changes, apply with:
docker-compose down
docker-compose up -d
This allows you, with a little care, to connect readers, dongles, or other peripherals to the Windows guest. It's an effective workaround until the GUI officially incorporates these controls.
Graphics acceleration and GPU passthrough status
Currently, there is no operational and stable GPU passthrough in WinBoat. The plan involves using paravirtualized drivers , but a mature solution ready for general use is not yet available. Options such as the MVisor Win VGPU Driver (with promising results in other hypervisors) have been explored, and work on DirectX drivers is being closely monitored.
Looking Glass (especially its Indirect Display Driver) has also been investigated to avoid the need for a second GPU, but so far attempts have resulted in a black screen or unpublishable results. The community and the author of these components themselves indicate that it is not yet ready for reliable use.
The practical consequence is clear: AAA titles and demanding 3D software aren't the project's strong point right now. If your priority is playing games with maxed-out graphics, dual-booting or PCIe passthrough solutions on dedicated VMs (and compatible hardware) remain more realistic shortcuts.
WinBoat vs. Wine, Proton, and traditional VMs
Compared to Wine, WinBoat is in a different league. Wine translates Windows calls to Linux , and when it gets it right, it's lightweight and incredibly fast. But it also struggles with modern apps or those with very specific dependencies. WinBoat avoids this pitfall by running Windows as is, at the cost of using more CPU, RAM, and storage resources.
Looking at Proton (Valve's Wine adaptation), its focus is on Steam gaming, with enormous improvements. However, aggressive anti-cheat and certain kernel dependencies remain a barrier. In productivity and enterprise software, WinBoat scores points for reliability.
Compared to VirtualBox or VMware, WinBoat is more "lightweight" in everyday use: you don't manage virtual disks in the old way or allocate such rigid fixed resources, and the integration of Windows on the host is much smoother. Even so, don't forget that underneath it all is a full Windows system with its associated resource costs.
Games and software with anticheat
If you're into competitive online gaming with kernel-level anti-cheat, there are no shortcuts: these systems detect virtualization and block booting . You might have an acceptable experience with less demanding or older games, but WinBoat wasn't designed as a hardcore gaming platform. For that scenario, dual boot or a dedicated Windows PC would be more sensible options.
However, for casual games or auxiliary gaming tools (launchers, non-kernel-dependent mods, etc.), the performance may be sufficient , considering the overhead of virtualization and the lack of full 3D acceleration.
Practical applications, use cases and real-world compatibility
Where WinBoat truly shines is in productivity and professional software that Wine struggles with. Examples include Affinity Photo , Paint Tool SAI v1.0, parts of the Adobe suite, Acrobat and AeroChat, as well as Microsoft Office, including Office 365. For studios, offices, and corporate environments, this reliability is more important than pure performance.
It's also appealing to users leaving behind Windows 10, whose support ends on October 14, 2025. If your hardware doesn't meet the Windows 11 requirements or you simply prefer Linux, WinBoat greatly reduces the fear of losing your key Windows tools during the transition.
In everyday use, opening a specific Windows app as if it were a native application, sharing files from your home screen, and maintaining stability is a real pleasure. Latency exists —it's a virtual guest, after all—but in office applications, accounting, management, 2D design, or business utilities, it's usually perfectly manageable.
Project status, license and contributions
WinBoat is still considered a solid beta. Bugs, network quirks, or limitations in certain configurations may appear. Even so, the pace of improvement is good, and the community around the project is growing with guides and contributions for Ubuntu, Fedora, Arch, and other distributions.
The project is licensed under the MIT license , so you can contribute code, documentation, or feedback. Pull requests should focus on technical aspects (contributions with political, sexual, or other unrelated content will not be considered). If you'd like to help, the best way is to review issues, suggest improvements, and submit well-defined and documented pull requests.
Regarding communication, some threads and reference sites display standard privacy and cookie notices (e.g., platforms like Reddit or X embeds). These are messages specific to those websites and do not affect WinBoat's functionality; they serve as context for the sources consulted.
Quick tips to keep things flowing
Before you jump into installing, take five minutes to verify that your user is in the docker group and that you can run containers without sudo. If not, fix it with a sudo usermod -aG docker tu_usuario and log back in.
Verify that FreeRDP is version 3.xx with sound support. Earlier versions may cause unpleasant audio issues. Also, check that you have enough space in /var so that the Windows image and data don't leave you stranded mid-deployment.
In BIOS/UEFI, enable VT-x/AMD-V and, once in Linux, verify KVM using the usual commands (for example, listing modules or checking permissions). Without a functioning KVM, there is no WinBoat , no matter how correct everything else is.
If you plan to use USB devices inside the guest, note their identifiers and document any changes you make to them. ~/.winboat/docker-compose.yml. A mini-checklist will save you time when raising and lowering containers or changing equipment.
WinBoat offers a pragmatic solution: near-total compatibility with Windows apps on Linux thanks to a containerized Windows environment with integrated windows and a lighter approach than traditional VMs. It's not the ideal tool for AAA games or GPU-intensive tasks, but it is a reliable bridge for productivity applications, enterprise suites, and software that Wine or Proton don't handle well. If you're looking for freedom on Linux without giving up your essential Windows programs, this is a very serious option for your daily use.