This hobby project has added quite a bit of features and I think the architecture will be interesting to the OS aficionados on this forum. See

https://www.youtube.com/watch?v=_DG_4CkjV9I

The most interesting thing perhaps is that I was able to isolate the x86 core stuff into arch-metal lib that implements arch-abi trait. The way it's setup is such, that I also implemented the trait by wrapping QEMU TCG engine (unicorn) and also a full kvm variant. The actual kernel (vfs, dos personality, linux personality, threading, ...) is written in almost entirely safe rust calling into a handful of arch functions through the arch-abi trait. This means that the same kernel can be build in three modes,

1) metal. It's a full OS with both legacy bios and modern uefi compatibility. So it can run on old machines with vga compatible graphics and sound blaster and it will expose this. But it can also run on uefi with hda, in which case vga and sound blaster is emulated, so you can still play your retro-games directly on the machine.

2) interpreted. This is basically dosbox mode, the QEMU TCG emulates the userspace programs, while the kernel is compiled as a regular app running native on the host machine. This can be played on any architecture.

3) kvm. This is basically dosemu2 mode. The userspace apps run natively on the cpu under kvm hypervisor, the kernel still runs as a regular app on the host machine. Most of the hosted specific code is shared with interpreted mode. The only differnce is that TCG is replaced with native execution using kvm

All the three modes above run the exact same kernel, with only a different implementation of the arch-abi injected. This actually is quite convenient as one can just run and debug the kernel like any normal app. No need to hook gdb through qemu or that kind of tricks.

So far it allows me to play my favorite games from my youth again on my razer laptop which is very satisfying. You can use it by just copying the kernel into your ext4 /boot directory, setup grub entry and /home/retroos becomes c: . You have access to your linux tools by starting shell.elf in c:\boot , but this is still work in progress (ls/cat/echo work but I'm not close to full linux environment). Of course I recommend qemu and installing it on your computer as in the video above is at your own risk. Anyway the project is complete enough that it might appeal to some retro hobbyist.

Of course I used AI as a "compiler" to compile DOS syscall spec to rust, compile the DPMI spec to rust, linux syscall API to rust. But the design and architecture is mine and you can see that that is still very similar to my code written back in 2023 in this repo. The design of the OS seems to occupy a somewhat new/original spot in the OS design space, sharing features and ideas with many other concepts in kernel design but in a unique way.

It is a monolithic kernel, one elf linked together, but it shares many ideas with microkernels. Arch is a microkernel , but uses just function calls instead of messages. The arch design is more like a hypervisor then the standard osdev tutorial/linux flow, which allows to abstract the core as a library. I haven't seen the trait factorization, ie. providing different ways of running the same kernel, done this way, but it of course strongly reminds one of UM-linux.

What I certainly havent seen before is using recursive paging in a way that unifies 32bit PAE paging and x64 paging, allowing the kernel to seamlessly toggle between 32bit and 64bit mode, which allows vm86 and 64-bit code to execute under one kernel (without the virtualization instruction set).

Specs:
It should run on 386/bios all the way up to x64/uefi without CSM. If you have an old computer with an actual sound blaster, games can use it natively. Otherwise sound blaster/adlib (experimental gus) is supported over hda/ac97 systems. Also when vga is not available, vga is emulated over the regular framebuffer. The video is RetroOS running on a razer (2025) with realtek hda. Old 486/sb I only tested through qemu/bochs/86box emulators.

Hi, @gsos,
This is one very interesting project. Maybe I'm wrong, but at first glance it looks to me like a DOS (compatible) kernel without COMMAND.COM support.

aVd wrote on 2026-07-12, 07:45:

Hi, @gsos,
This is one very interesting project. Maybe I'm wrong, but at first glance it looks to me like a DOS (compatible) kernel without COMMAND.COM support.

Yes it’s a dos compatible kernel (but also Linux compatible) it has a very basic command.com the forks address space to start programs. I use dos navigator as the tui to the os for the retro feel. It DN invokes “command.com /c program.exe” to start programs which forks internally. Look for command.c in the repo it is compiled by Borland c using retro os itself as part of the build to build command. Com . But command. Com is not a shell currently no

Hi there! I like DN, too - good choice! 🙂 DN is small and quick. A bit like NC 1.0 if run via NCSMALL.
This *nix/DOS crossover is interesting, I think. MS-DOS 2 used to have POSIX elements, I remember.

Yeah I used NC as a child and still like orthodox file managers the best. NC is proprietary and DN is better and free to distribute, hence.

The origin of the project was more OS design focused, my goal was to decouple syscall api and other kernel specifics from managing resources. This worked out well, I'm planning to add OS/2, windows and freebsd personality in the near future. For now I'm mostly focused on getting the old hardware that effectively is part of the dos api (as programs would program those directly) emulated correctly . This is vga (some modes are not behaving properly see jazz jack rabbit), GUS music doesnt maintain exact tempo currently, roland emulation (still to do).

Also need drivers for modern hardware like the touchpad for mouse and ideally ethernet drivers + tcp stack.

I addressed some sound issues, GUS starts sounding normal now, lag is now low enough to be unnoticeable to me and removing echos where the system couldn't keep up. This was an interesting exercise. The source of the problem is that intel really f'd up on the design in 32 bit mode with respect to interrupt flags, cli/sti trap however popf/iret just silently drop IF. The DPMI spec does say that users should use cli/sti or dpmi functions and not use popf to clear/set. Unfortuantely the typical dos-extenders were running code with iopl=3 which gave the dos-games full control over IF, something unacceptable for RetroOS, and doom/duke3d/raptor/etc... al rely on popf restoring interrupts. The solution I used was using the trap flag to single step when VIF=0 until a popf/iret restores VIF to prevent hangs. This was to brutal, doom DMX is mixing in VIF=0 and explosion of 100-1000x in instruction was causing starvation. I added a repair (where the kernel learns where to restore VIF after first single stepping) this makes most games run without single stepping and producing good sound.

A super interesting project. I’m curious about the bare metal, the ram requirements are similar to MSDOS? Not sure I’ve ever seen a 386 with less than 2mb, but if the system only had 640kb ram would it still load and have enough memory to run stuff like Wolf3D / Prince / Keen?

Thanks. Currently I haven't optimized the kernel for size too much, I'm sure there are a lot of things to make it smaller. The most egregious, currently kernel.elf contains command.com and dos navigator as a tarfs image in .rodata, so that it garanteed boots into DN without needing c: to be initialized in a specific way. This of course is nonsense and should go away. For now it needs some decent amount of memory available, but I haven't yet tested a workable minimum to be honest. But 640kb is not going to work, the boot process itself at the moment requires the kernel to be placed at 1mb. But I agree, it should support 2mb machines where the kernel lives >1mb and would have full 640kb available for dos programs with still something along ~500kb of memory free for ems/xms.

Future work definitely should include minimizing the kernel and perhaps add some paging/swap capability to allow it to run on minimal memory requirements is certainly a interesting project.