This is how Windows 95 runs on an ESP32-S3 thanks to Tiny386

What seemed like a forum joke not long ago has become real: Windows 95 booting on an ESP32-S3 Thanks to a minimalist x86 emulator called Tiny386. On a small devkit with a 3,5-inch touchscreen, the Microsoft system starts up, takes a few minutes and runs just barely, but opens Notepad, plays Solitaire and even loads a vintage website over the network.

The person responsible is the developer He Chunhui (hchunhui), who has built a i386 emulator from scratch on C99 and has ported it to the Espressif microcontroller. The remarkable thing is not only that it works, but, according to information published on GitHub, Hackster/Hackaday, and specialized media, this is probably the first time someone has managed to load Windows on Espressif. hardware ESP32, after previous milestones such as the startup of Linux 5.0 on other ESP32 boards and a Linux 6.3 image on the Olimex ESP32-S3-DevKit-LiPo.

What is Tiny386 and who is behind it?

Tiny386 is, essentially, a virtual x86 PC, written in C99 and designed to be portableIts core is a CPU emulator Intel i386 “simple and dumb” —in the author's own words— with a very clear objective: to run as much 16 and 32 bit software as possible without burdening it with enormous complexity.

The virtual CPU implements the 80386 instruction set and adds 486 and 586 instructions where they are needed to boot modern Linux kernels and Windows systems contemporary to that era. The kernel is around 6.000 lines of code (LOC), which is surprising considering what it is capable of handling, and optionally includes x87 FPU emulation for software that needs it.

Like any young project, there are gaps to fill. In fact, Features such as debugging, hardware tasking, and certain permission checks are missing.Even so, the premise holds true: for most classic DOS/Windows 3.x/95 software and even for booting a modern Linux system, the current implementation is up to the task.

How to emulate an i386 PC on an ESP32-S3

To appreciate the merit, it's worth remembering what an 80386 was: a 32-bit x86 processor with six-stage pipeline and MMU integrated, launched in the mid-80s. It was the basis of an entire era of personal PCs, portable and even servers, with real and protected modes that marked the evolution of software.

On the opposite side, the ESP32-S3 It's a current, low-cost microcontroller with two Tensilica Xtensa LX7 cores at 240 MHz, Wi-Fi/Bluetooth connectivity, and very low power consumption. Although the comparison isn't direct (emulation always has a disadvantage), the raw power of this SoC and the support of external PSRAM memory make it a strong contender. They allow you to simulate a functional 386 machine with basic graphics, network and sound, all within the microphone itself.

The trick lies in a pragmatic approach: the CPU is emulated in a simple way, The essential instructions are added that were missing for modern cases, and the rest of the PC experience is built on virtual peripherals already tested in other projects. This mix of minimalism and clever recycling is what makes it possible for the system to boot Windows 95 without crashing.

Emulated peripherals and firmware

To complete the PC ecosystem, Tiny386 borrows code from TinyEMU and QEMU in order to emulate the classic components of an early 90s ISA machine. BIOS VGABIOS, meanwhile, comes from the SeaBIOS project, which makes it easier to boot systems without relying on proprietary ROMs.

The list of supported peripherals includes parts very familiar to anyone who has tinkered with classic PC emulation: interrupt controllers, timers, keyboard, video, disk, network, and audio. In detail:

• Interrupt controller 8259 (PIC) and timer 8254 (PIT), essential for system timing.
• 8042 and keyboard controller CMOS RTC for clock and basic settings.
• VGA ISA with Bosch VBE to offer compatible video modes.
• IDE disk controller for storage.
• NE2000 ISA network card, a veteran that is widespread and easy to emulate.
• DMA ISA 8257, PC speaker, Adlib OPL2 and Sound Blaster 16 for audio.

Thanks to this catalog, the system not only displays graphics and boots a Windows environment with an interface, but also It has network connectivity and can play sound with the drivers suitable, which rounds out the "old PC" experience in a surprisingly complete way.

Reference hardware: JC3248W535 with ESP32-S3

The demonstration that has captured everyone's attention runs over the Guition JC3248W535It's a development board with an ESP32-S3 and a 3,5-inch touchscreen LCD. This devkit can be found for around $25-30 on sites like AliExpress, and from what we've seen, it includes everything you need to play "90s pocket PC" games.

One important detail: the USB-C port on this motherboard seems to be designed for programming and refinednot as a peripheral host USB standard of the ESP32-S3. Even so, with the chip's USB OTG peripheral, one could imagine a setup with a USB hub to which you can connect a keyboard and mouse, creating a mini-386 with direct wired input.

Currently, official project support focuses on this specific board, and the author indicates that ESP32-S3 only It is natively supported. The emulator's architecture, however, prioritizes portability: with reasonable effort, it could be ported to other microcontrollers and platforms, opening the door to more formats and screens.

Performance and user experience

The question everyone is asking: how's it going? The short answer is “It works, with patience.The complete boot of Windows 95 takes around 4 minutes in the public demo. Once loaded, the system is slow but manageable: you can open Notepad, play Solitaire, and even launch Internet Explorer.

Network connectivity is implemented, so the emulator can Load basic websitesThe demonstration shows how it opens info.cern.ch, the first website in history, which adds a delightful touch of nostalgia to the scene of Windows 95 running on a microchip costing less than 30 euros.

In terms of performance, it's understandable that the system is pushed to its limits: emulation adds overhead, and the ESP32-S3 lacks PC-grade graphics acceleration. Despite this, the overall feeling is “usability on the edge” It's more than just a simple "it starts and freezes." If you play the video at double speed—a popular tip among those who have already seen it—it becomes much more bearable.

As a fun fact, Tiny386 can run DoomThat classic "if it doesn't run Doom, it's no good" test. And thanks to virtualized sound devices (PC speaker, Adlib OPL2 and SB16), the audio aspect is also covered as much as possible within the hardware limitations.

Supported operating systems and software

The catalog, which has already been shown in a video, includes Windows 3.1 / 3.2 (with the Chinese variant of 3.1) and Windows 95. Beyond that, the author emphasizes that Tiny386 “It should run most 16/32-bit software”, and that with the expansion of 486/586 instructions it is possible to boot both relatively modern Linux kernels and Windows NT of the time.

One very interesting detail is that Tiny386 is capable of boot the Linux kernel directlywithout going through a traditional BIOS, which simplifies some testing workflows. For exploring without assembling hardware, the project also offers a demo in WebAssembly which boots Windows 3.2 in the browser, and mentions alternatives such as FreeDOS or JSLinux for those who want to compare emulation experiences on the web.

In the field of applications, in addition to the aforementioned Doom, the basic Windows 95 programs (Notepad, Solitaire and Internet ExplorerThese have proven to work, with the obvious performance limitations. This is sufficient evidence to conclude that the graphics, input/output, and network stack is reasonably well integrated.

How input and ports are handled

On the JC3248W535 board, the use of physical peripherals is conditioned by the USB-C for programmingTo overcome this obstacle, in the current implementation the keyboard and mouse can be redirect over Wi-Fi towards the emulator, offering control without the need for dedicated ports in the devkit.

Looking ahead, it wouldn't be surprising to see builds that take advantage of the ESP32-S3 USB OTG as a host, and allowing the creation of a hub to plug in conventional keyboards and mice. This leap would greatly facilitate interaction without relying on touchscreens or remote input solutions.

License, code, and testing resources

The project is published under 3 clause BSD licenseThis encourages its reuse and portability. The complete source code is available in the GitHub repository. basic compilation instructionsdocumentation of the configuration files and, for those in a hurry, pre-compiled images ready to flash.

In addition to the technical documentation, there is a demo in the browser (GitHub Pages) which allows you to get an idea of ​​how Windows 3.2 boots and how the system responds, without needing any hardware. Those who want to delve deeper can also find information and discussions on sites like Hackster.io and Hackaday.io, and in communities like /r/hardware, where these retro-tech feats often generate lively conversations.

Media outlets such as CNX Software and Tom's Hardware have covered the development, highlighting details such as the list of emulated peripheralsThe dependence of SeaBIOS for BIOS/VGABIOS and the current state of support for the JC3248W535 board. In fact, part of the dissemination has come with the impetus of the community —thanks to tips like Zoobab's—, which explains the speed with which the project has jumped to the forefront of the maker scene.

From Linux on AVR to Windows 95 on ESP32‑S3

To put things in perspective, those who remember the attempts to booting Linux on 8-bit microcontrollers (like AVR) know how long it could take. Compared to that, seeing an ESP32-S3 emulating a 386 running Windows 95 feels "fast" and, certainly, much more practical.

Previous achievements have also been seen in the ESP32 ecosystem: Linux 5.0 on ESP32 boards and, more recently, a Linux 6.3 image in the Olimex ESP32‑S3‑DevKit‑LiPoBut the arrival of Windows to this family of microcomputers marks a turning point in the exploration of limits, due to the peculiarity of the objective and how demanding it is to run a classic graphical environment.

Current limitations and opportunities for improvement

The "not yet" list includes the integrated debuggerHardware tasking and certain permission checks, in addition to the inevitable performance bottlenecks that come with pure emulation, are also drawbacks. It's also a disadvantage that, for the moment, official support is limited to the JC3248W535This limits the variety of screens and accessories available as standard.

On the positive side, Tiny386's approach is so straightforward that there are clear room for optimizationImprovements to external memory (PSRAM latencies), fine-tuning CPU emulation, addressing potential critical paths in graphics or disk peripherals, and leveraging USB OTG to enhance the experience with real devices. Every little bit helps when the development cycle budget is so tight.

Preservation, education, and retro fun

Beyond the "because we can" premise, projects like this have significant educational and preservation value. With Tiny386, developers and teachers They can reproduce historical x86 environments without original hardware, which is increasingly scarce and fragile, and do so on an ultra-cheap, low-power platform.

For the community, it opens the door to test old software, documenting the behavior of legacy systems and setting up workshops where it is explained, with tangible examples, how the real and protected modes of the 386 conditioned the design of OS such as Windows 3.x/95 and the evolution of Linux.

There is also a cultural aspect that should not be underestimated: it is paradoxical—and very amusing—that to “feel powerful” today we have to emulate an 80s CPU on a modern microphone, when we carry in our pockets mobile phones thousands of times more capable than those original PCs. That contrast helps to understand how far we've come and why emulation is such a powerful tool.

Internal architecture: modes, memory and BIOS

The real i386 combined modes real and protected, pagination and an MMU that laid the foundations for the virtual memory On PCs, Tiny386 replicates the critical aspects of that behavior to make operating systems feel "at home," combining CPU emulation with a set of peripherals that respond where the software expects good old ISA signals.

A pillar here is Sea BIOSThe BIOS and VGABIOS used are sourced from this source. This ensures compatibility with widely supported boot routines and avoids reliance on closed ROMs. At the same time, when necessary, the emulator can bypass the BIOS and load the Linux kernel directly, a very useful shortcut for testing.

Portability and ecosystem

Being written in C99 and with such a concise CPU core, carry Tiny386 For other platforms, the task becomes straightforward: simply implement the I/O layer and adapt the integration with the display, input, and storage. The author himself highlights portability as the project's greatest strength.

This not only benefits those who want to take it to other micro or SBCs, it also makes it easier for third parties add peripherals, try optimizations or even build specific frontends (for example, to directly launch different Windows images or retro DOS/Linux distributions).

What has been demonstrated so far

The “proof of life” of Windows 95 with Start-up in ~4 minutes It's the star attraction, but it's not alone. Windows 3.1/3.2, basic web browsing (including info.cern.ch), system applications, and iconic software like Doom were also showcased.

In parallel, there is a WebAssembly demo It boots Windows 3.2 in the browser, a great way to experience emulation without soldering or flashing anything. And for the more tech-savvy, the repository offers configurations and a pre-compiled image to get started on the JC3248W535 with minimal hassle.

Comparison with other experiences on ESP32

Compared to other demos like Linux on ESP32 "without hardware", the leap to Windows 95 emulated It adds a special interest: it forces the reproduction of a more capricious graphics and driver stack, and dealing with interface expectations that did not exist in a console boot.

The experience with the Olimex ESP32‑S3‑DevKit‑LiPo and Linux 6.3 It demonstrates that the ESP32-S3 ecosystem has room to surprise. Tiny386 pushes that frontier into Windows territory, closing a circle that seemed reserved for more powerful SBCs like Raspberry Pi.

In the end, what is clear is that, with some ingenuity, a low-cost microphone It can become a pretty convincing retro machine, capable of booting complete systems and giving us a masterclass in 90s computer architecture.

Viewed as a whole, the story of Tiny386 encapsulates several achievements: concise i386 emulationKey peripherals are well integrated, the BIOS is open source, portability was designed from day one, and a demo that, although slow, teaches what matters: that Windows 95 and Linux can run on an ESP32-S3 with more than decent fidelity.

And yes, it has a certain poetic quality that to relive the "magic" of Windows 95 in 2025 we won't be touching an old Pentium, but rather using... a 6.000-line emulator And a devkit with a touchscreen that fits in your pocket. Computing is sometimes much more fun when nostalgia is mixed with ingenuity.