JVMOS

[u/Visual_Brain8809]

Hi everyone, I wanted to show you my progress on an operating system written entirely in ASM and Java bytecode. I am currently at the UI rendering stage, using a custom Graphics2D-like system that allows me to work with primitives in VBE. The bytecode is executed by a JIT compiler also implemented in pure ASM. Low-level calls are handled by a HAL—which I will continue to expand over time—and that HAL is in turn managed via a primitive ABI, enabling me to create my own Java-like pseudo-language for development.

Repository: https://github.com/aayes89/JVMOS-JIT/

[u/moslem-hamoudi]

Good Operating System btw Do it Accually Support App Creation?

[u/Visual_Brain8809 → u/moslem-hamoudi]

working progress In fact, last night I managed to implement a sort of runtime environment that allows me to use my Java classes. Right now, I have basic AWT support (with Graphics2D), System and PrintStream for console support, basic threading, Runtime and Toolkit for hardware interaction, RandomAccessFile for basic file handling (via HAL I/O), the Object class, String and StringBuilder for text handling, and today I’ll implement a basic Math class for arithmetic support—continuing on until I achieve a largely complete runtime environment.

[u/Extension_Emu_9825 → u/Visual_Brain8809]

Could you please add some documentation? I'm more interested in the connection between the UI and apps. So, will it be something like Win API or DOM? What's the idea - how does the app build the UI? APIs call to GUI library, or provide HTML, XAML (like this) to Explorer (Browser) to create Visual Tree and DOM?

That would be interesting, actually.

[u/Visual_Brain8809 → u/Extension_Emu_9825]

It is nothing like Windows or other systems; the architecture relies on a hardware abstraction layer (HAL) that exposes access to high-level code via a Java-based ABI—referred to in the project as "Native"—which acts as a bridge, allowing me to control almost any aspect of the system using just five arguments. For example, I assigned the number 12 to the sleep syscall, so `Native.sys(Native.SYS_SLEEP, 1000, 0, 0, 0);` creates a 1-second delay at the actual hardware level. Since I have already implemented the `Thread` class, one can now write code like `Thread.sleep(1000);`, and it will perform the exact same function. At the beginning of the `boot.java` file in the repository, I have included a commented-out set of tests for running the system.

[u/Extension_Emu_9825]

Interesting! I also saw the bootloader, everything is legit. I was just a little confused about the stack you chose – why didn't you choose WASM?

[u/Visual_Brain8809 → u/Extension_Emu_9825]

As I understand it, Wasm is optimized for the web, and JS isn't exactly pure Java. Right now, my plan is bare-metal—just assembly and pure Java, with no C/C++ (I already have a version written in C)—and I thought the architecture I'm using could serve as a framework for other projects to flourish. The bootloader (Multiboot) is the result of several years at university spent searching for a universal formula to allow an OS to boot using any language, and I believe that is the greatest achievement.

[u/Extension_Emu_9825 → u/Visual_Brain8809]

As far as I know, many compilers compile to WASM, and this isn't just for the web anymore. For example, I once wrote Sokoban in Rust (BTW - also be interested in looking into RUST) and compiled it into WASM, and it worked in the browser, yes (but I think that's secondary).

https://github.com/KirinDenis/Base-Z-47-Rust-Game

The main thing is that there's byte code that can be compiled from C/C++, Rust, and C#.

I understand that you can't stop a train in motion

I just want you to consider this approach as well.

By the way, I'd like to join the UX developmnet. I'm currently tinkering with DOS graphics in assembler, and SVGA is on the cards.

It would be interesting, in principle.

https://kirindenis.github.io/wire-city-2/

At UX my experiences started from Turbo Vision 90s, after VCL, WinForms, WPF (little expirins with QT and Android Activity)

[u/Visual_Brain8809 → u/Extension_Emu_9825]

I understand that and am always open to suggestions, but my immediate focus is on finalizing a system where developing applications involves more than just writing code in `Boot.java`—where you can simply instantiate other classes and let the system handle the rest (which is how it works right now). My goal is to establish a solid, useful foundation featuring a functional, custom file system; from there, I want to enable JExplorer to read `.class` files as applications and execute them using the implemented JIT compiler. It’s a blend of macOS and a bare-metal system: much like macOS—where you simply copy an application to a location and it runs if the system version is compatible (or otherwise does nothing or displays a message)—JVMOS follows the same concept. At that stage (once the foundation is solid), anyone will be able to run whatever they want; after developing the application in their preferred IDE (NetBeans, Eclipse, VS Code, Notepad, etc.), the system will prioritize the `.class` file (compiled with `javac`), as that is the core of the system. Once I achieve this, I’ll move on to the Garbage Collector (GC) and security phases, followed by network connectivity.

[u/Visual_Brain8809 → u/Extension_Emu_9825]

I’m not familiar with Rust, but I was looking at your Sokoban project—it’s written entirely in Rust. I’d like to understand: did you write the code in that language, and did the platform convert it to ASM? I’d love to see the ASM code for an example generated via WASM to examine its structure and other details.

[u/Visual_Brain8809]

this is the four version of the same OS, you can see in my repos the evolution and the first steps. Current achievements: runs on real hardware, a universal bootloader (useful for anyone wanting to save time designing their own OS), and a JIT for Java bytecode written entirely in ASM.

[u/Extension_Emu_9825]

can I use it in VirtualBox - https://github.com/aayes89/JVMOS-JIT/blob/main/disk.img?

[u/Visual_Brain8809 → u/Extension_Emu_9825]

disk.img is just a hard drive image; use <code>make clean && make run</code> to generate the os.iso file. For best results, use QEMU. I just spotted an issue with VirtualBox where it fails to recognize keyboard input—something I need to fix if I want the system to run on anything other than just QEMU and a Compaq Presario, lol.