ExeBrowser

How to run Windows software on a Chromebook

By Andrew Nakas · Published June 9, 2026 · Updated July 1, 2026 · ~7 minute read

Chromebooks are everywhere — in schools, on budgets, as travel laptops — and they run ChromeOS, not Windows. So when you need to open one Windows .exe (a legacy school tool, an old utility, a classic game), you hit a wall. Here are the four realistic ways to run Windows software on a Chromebook, ordered from least to most effort, with honest notes on what each is actually good for. For each method you get the actual steps, not just the concept — plus a comparison table, the fine print, and a decision guide at the end.

1. Run it in the browser, no install (easiest)

The lowest-friction option is to not install anything at all and run the EXE inside a browser tab using a WebAssembly build of Wine. That's exactly what ExeBrowser does: you open a page, boot Wine, drop in your executable, and it runs locally in the tab. Nothing is uploaded, no developer mode, no Linux container, no admin rights. On a managed school Chromebook where you can't install anything, this is often the only path that works at all.

The whole process, start to finish:

1. Open exebrowser.com in a normal browser tab. No extension, no sign-up, no permission prompts.
2. Click Boot Wine and wait for the runtime to download. The filesystem is fetched on demand, so a first boot typically pulls around 30–60 MB.
3. Add your program. A single self-contained EXE can be dropped in as-is; if the program normally lives in a folder with DLLs and data files, upload the whole folder (or a zip of it) so those files come along.
4. Click Run. The app draws into a canvas inside the tab; click the canvas to give it your keyboard and mouse.
5. Before you close or reload the tab, use "Download files written by this app." The virtual C:\ drive lives in memory and is wiped on reload, so that zip is how you keep saves and output.

The trade-off is performance and scope: it emulates an x86 CPU, so it targets classic 32-bit Win32 software (roughly 1995–2008) and runs at roughly 10–40% of native speed. Perfect for an old utility, a 2D game, or recovering a file from a legacy program; not for modern 64-bit apps (an experimental 64-bit runtime exists, but the stable engine is 32-bit only) or anything built on a modern DirectX 3D pipeline. One quiet advantage: because the CPU is emulated anyway, this route works the same on ARM Chromebooks — something none of the Wine-on-Linux options below can claim. See the compatibility guide for what runs, or the app guides for specific programs.

2. Enable Linux (Crostini) and install Wine

Most modern Chromebooks can turn on a Linux container in Settings. Once you have a Linux terminal, you can install Wine natively and run Windows apps with real x86 execution (Chromebooks with Intel/AMD chips run x86 directly — much faster than browser emulation). This handles a wider range of apps, including some that the browser route can't. The cost: it requires turning on Linux (blocked on many managed school devices), some terminal comfort, and disk space. It's the best balance of power and effort if your Chromebook allows it and you're comfortable with a few commands.

Setting it up looks like this:

1. Open Settings, search for "Linux," and turn on the Linux development environment. If the option isn't there, your device is either too old or — more often — managed by an administrator who has disabled it. In that case, use method 1 or 3 instead.
2. Give the container as much disk space as you can spare; the Debian-based container plus Wine will want several gigabytes.
3. In the Terminal that appears, enable 32-bit packages and install Wine: sudo dpkg --add-architecture i386, then sudo apt update, then sudo apt install wine wine32. (Most classic Windows software is 32-bit, so wine32 matters.)
4. Copy your program into the Linux files folder using the Files app, then launch it from the terminal: wine ./yourprogram.exe.

The big caveat is CPU architecture. Wine is a compatibility layer, not an emulator — it can only run x86 Windows binaries on an x86 processor. On the growing number of ARM-based Chromebooks, plain Wine won't run your EXE at all without a separate x86 emulation layer, which is fiddly territory well beyond a quick setup. Check Settings → About ChromeOS to confirm what chip you have before investing time here.

The paid variant: CrossOver on ChromeOS

CrossOver is the commercial, supported version of Wine from CodeWeavers, the company that leads Wine development. There was once a dedicated CrossOver app for ChromeOS; these days the practical path is installing the CrossOver Linux build inside the same Crostini container from the steps above. What the license fee buys you: a graphical installer instead of terminal commands, per-application configuration profiles, a searchable database of officially supported programs, and actual support staff when something breaks. Underneath it is still Wine on x86, with the same architecture limits. It makes sense when one specific Windows app really matters to you, CodeWeavers lists it as supported, and you'd rather pay than tinker.

3. Remote desktop into a real Windows PC

If you already have a Windows machine somewhere — at home, at work, or a cloud Windows instance — you can use Chrome Remote Desktop or RDP to control it from the Chromebook. The app runs on the real PC at full speed and compatibility; you're just viewing it. The catch is obvious: you need that Windows machine to exist and be on, plus a solid internet connection. Great for full modern apps, useless if you don't have a Windows box to connect to.

With Chrome Remote Desktop (free, and browser-based on the Chromebook side):

1. On the Windows PC, open remotedesktop.google.com/access in Chrome, sign in with your Google account, and install the remote-access host when prompted.
2. Name the computer and set a PIN.
3. Adjust the PC's power settings so it doesn't go to sleep — a sleeping PC is unreachable.
4. On the Chromebook, open the same site with the same account, click your PC in the list, and enter the PIN.

Everything runs at native speed because it literally runs natively; your Chromebook only streams video and sends input. That also means everything is at the mercy of your connection — fine for documents and desktop applications, frustrating for fast-paced games where latency shows.

4. Full virtualization or cloud Windows

The heavyweight option: run a complete Windows VM (where the hardware and policy allow it) or rent a cloud Windows desktop. This gives you the whole OS and maximum compatibility, but it's the most setup, the most resources, and often a cost. Reserve it for when you genuinely need full, modern Windows — not for opening a single old EXE.

Two flavors exist. Local Windows VMs on ChromeOS are sold as an enterprise feature, so for an individual the realistic version of this option is the cloud: services that rent you a real Windows machine in a data center, reachable from the Chromebook's browser. In practice it behaves like method 3, except you're renting the PC instead of owning it — full compatibility, a monthly subscription, and the same dependence on your internet connection.

The honest comparison

The fine print: limitations worth knowing up front

• Managed Chromebooks block most of this. School and work administrators commonly disable the Linux environment entirely, and there is no legitimate way around that policy. On a managed device your realistic options are the browser route and — if the network filter allows it — remote desktop.
• ARM changes the math. Wine and CrossOver need an x86 processor to run x86 Windows programs. On ARM Chromebooks, method 2 and the CrossOver variant are effectively off the table, while the browser, remote, and cloud routes are unaffected.
• Storage is tight on cheap Chromebooks. The Linux container plus Wine consumes several gigabytes, which stings on a device with 32 or 64 GB total. The browser route stores nothing permanently — which cuts both ways: zero disk used, but you must download your files before closing the tab.
• Nothing here supplies the software. Every method runs copies you already have the right to use. ExeBrowser in particular is strictly bring-your-own-EXE — it executes your files locally in the tab; it doesn't distribute programs.

Which should you pick?

Put differently: the browser route wins whenever friction is the enemy — a locked-down device, a one-off task, an old 32-bit program. Crostini plus Wine wins when you're on your own x86 Chromebook and expect to run Windows software regularly. CrossOver is the same bet with a support contract attached. Remote desktop wins the moment a Windows PC you own is sitting idle somewhere. And cloud Windows is for the case where a modern, 64-bit, Windows-only application is genuinely part of your working life and nothing lighter will do.

For the most common case — "I have this one Windows program and a Chromebook that won't let me install anything" — start with the browser. It costs you nothing to try.

Keep reading

• Wine vs. an emulatorWhat the difference actually is.
• Run old software without a VMWhen a browser tab beats a virtual machine.
• App guidesSpecific programs, step by step.