Moving Beyond js-dos: Experimenting with x86 WebAssembly for Faster Windows Game Emulation

I have been using js-dos extensively for quite some time now, and when it comes to classic DOS games, I really have very little to complain about. It works great, integrates nicely into the browser, and has become an important part of how I bring old DOS games back to life on Lemon Web Games. For genuine DOS titles, I am definitely not planning to move away from it anytime soon.

The problem starts when I move beyond DOS and into the Windows 95 and Windows 98 era.

Despite already using the latest js-dos source code in my current emulator implementation, I have found that performance can become quite poor with certain Windows games. Some lighter titles remain playable, but once I start experimenting with more demanding games from the late 1990s, the limitations become increasingly obvious.

And unfortunately, some of those games happen to be my childhood favourites.

js-dos Is Still Excellent for DOS

Before anyone gets the wrong idea, this is definitely not an article about js-dos being a bad emulator.

Quite the opposite.

For DOS games, js-dos remains one of the best browser-based solutions I have worked with. It provides a complete framework around DOSBox and DOSBox-X, including browser integration, save and load functionality, networking, large disk support and Windows 9x support. The official js-dos documentation specifically uses DOSBox-X for Windows 95/98 applications and games.

That architecture works remarkably well considering everything is happening inside a web browser.

The issue is simply that running a Windows 9x game is significantly heavier than launching something designed directly for DOS. In my current setup, Windows itself has to run as a guest operating system inside the DOSBox-X emulation environment before the actual Windows game even gets to run.

That additional workload matters.

The js-dos documentation itself notes that its DOSBox-X backend, which provides the Windows 95/98 support I am using, can be somewhat slower than traditional DOSBox emulation.

Experimenting with a New x86 WebAssembly Build

Because of this, I have recently started experimenting with a completely different x86 WebAssembly-based emulator build.

Instead of focusing primarily on DOS compatibility and then using DOSBox-X to provide the environment needed for Windows, this project takes a more direct x86 machine-emulation approach.

The early results have been very encouraging.

On several Windows games that I previously struggled to run smoothly through my js-dos configuration, the new x86 WASM build is providing noticeably better performance.

This does not suddenly make browser emulation equivalent to running the game natively on an old PC, of course. There is still an entire x86 computer effectively being emulated inside the browser.

However, based on my testing so far, the difference is significant enough that I think this could become a much better foundation for the Windows side of Lemon Web Games.

js-dos vs x86 WASM

Here is roughly how I currently see the two approaches based on my testing:

It is therefore unlikely that one emulator will completely replace the other.

Instead, I am starting to see them as two different tools for two different generations of PC gaming.

js-dos can continue handling DOS, while x86 WASM could handle Windows.

That may ultimately give me the best of both worlds.

Revisiting Some of My Childhood Favourites

One of the biggest reasons I started this experiment was simply because there are several games from my childhood that I really want to bring to the browser.

I tried some of them using my existing js-dos Windows environment, and although I could technically get them running, performance just wasn't good enough.

For me, getting a game to boot is not the same thing as getting a game to work.

If the frame rate is poor, controls are delayed, audio is constantly struggling or the entire Windows environment feels sluggish, I don't consider that ready for publication.

That is where development basically stopped for several games.

The new x86 WASM project has allowed me to revisit those titles, and this time the results are considerably more promising.

There is still plenty of testing to do, particularly around browser compatibility, storage, loading large Windows disk images, persistent saves, audio, input handling and making the whole thing work reliably with the existing Lemon Web Games interface.

But at least performance is no longer immediately stopping the project.

Still Running Locally for Now

At the moment, none of this is running on the production Lemon Web Games server.

The entire x86 WASM project is still being tested on my local development server.

That gives me the freedom to break things, experiment with different configurations and completely rebuild parts of the emulator without affecting the games that people are already playing on the website.

I would much rather keep it there until I am satisfied that everything is stable.

The emulator itself is only one part of the project. I also need to make sure loading, caching, disk storage, fullscreen behaviour, controls and the overall user experience work properly before releasing it publicly.

Tentatively Coming in August

If development continues at its current pace, I am tentatively targeting the second or third week of August 2026 to begin deploying the new x86 WASM emulator to the production site.

That would put the initial target somewhere around August 10–23, 2026.

I am deliberately calling that a tentative target because I would rather delay the release than push something into production simply because I announced a date.

Once it goes live, I also don't expect every Windows game to suddenly migrate to the new emulator.

The first releases will most likely be games that clearly benefit from the additional performance. From there, I can continue testing different Windows titles and gradually expand the library.

Final Thoughts

Browser-based DOS emulation has reached a point where I am genuinely happy with what js-dos can deliver. For classic DOS games, it remains an excellent platform and will continue powering that part of Lemon Web Games.

Windows gaming is a different challenge.

Running Windows 95 or Windows 98, followed by the game itself, puts considerably more pressure on browser-based emulation. Some games simply demand more performance than I have been able to comfortably get from my existing js-dos/DOSBox-X setup.

That is why this x86 WebAssembly experiment has become particularly interesting.

For the first time, several Windows games that I previously considered impractical for the website are starting to look genuinely playable.

There is still quite a bit of work between a successful experiment on my local server and something I am comfortable deploying publicly, but the foundation is looking promising.

And if everything goes according to plan, sometime around the second or third week of August, Lemon Web Games should start getting a much more capable way of bringing classic Windows games back into the browser.