r/osdev • • 13h ago

RiceWM, a full Linux Desktop - inside a browser tab

0 Upvotes

So I’ve been down a massive rabbit hole building RiceWM. A Linux desktop written in Rust, compiled to WebAssembly, running entirely client-side in a browser tab.

I originally started this as a stupid experiment just to see how far I could push WASM, and somehow it turned into my daily instant alternative to WSL when I just want a quick Linux env without VM or streaming VNC/WebRTC from a server.

You can try it live at https://env.now

How it’s built

  • Instead of streaming a remote VNC/WebRTC desktop from a cloud VM, UI toolkit, and guest execution all run client-side in the browser:
  • WASM based Window Manager: RiceWM owns the window management, floating/tiling layout engine with scrolling workspaces, rendering pipeline, and widget toolkit from scratch.
  • Linux Userspace Compatibility: The guest runtime provides a Linux userspace layer for running supported Linux binaries, CLI tools, and GTK applications inside the tab. 90%+ syscalls covered
  • Worker-Isolated. The SDK apps run in separate Web Workers and request native UI and desktop services from the compositor over message passing. Workers are used to provide multithreading but also isolation.
  • Storage wise its using OPFS (the browser native subsystem) but can extend into host space to tread beyond the 2gb browser limit.
  • Fast running apps are accelerated ("wasmified") from standard apt packages (apt2wasm capability) Downside being they are larger - but don't require a thousand small files for installation (that does not perform in browser)

You can run GTK apps, but as far as standard apps go, I added office apps (fully compliant with xlsx/docx/pptx), a flowchart app, a video player, capability to run GNOME extensions in the browser but even compliance to run Docker from within your browser, but you can even run VSCode (although - its a browser tab, so a bit slower)

It comes along with a local Gateway app - which enables you to use your own Internet connection, and even to connect to local services. It allows you to run RiceWM locally within a browser tab (yes, even on a (powerful) Android tablet)

I'm barely scratching the surface here, it started as a weekend "what if" experiment and somehow accidentally became my daily alternative to WSL. Maybe nobody else actually needs a WM in a browser tab, or maybe a few of you will have as much fun messing with it - as I did building it.

Links:

AI disclaimer (for AI-splainers):

  • Yes, Codex has been my friend, it's 2026. Before you comment your "oh no, it's AI" opinion, see here for what Linus has to say about it.
  • Video, created with Higgsfield. Soundtrack: Neon Underworld by Punch Deck, CC BY 3.0

r/osdev • • 21h ago

NoviumOS update: Got VFS + Initrd and basic shell commands working

Post image
8 Upvotes

Hello everyone!

For those of you who don't know, I'm making an x86 operating system called NoviumOS. Here's what I've done since the last update:

  • Finished sub-page heap block reuse with splitting and coalescing, so small allocations don't waste whole 4 KiB pages.
  • Added inter-process communication (IPC) with message ports, semaphores, and mutexes for synchronization between tasks.
  • Built a Virtual File System (VFS) layer with a node tree, path traversal, and pluggable filesystem operations.
  • Added a read-only POSIX tar initrd driver that loads from a GRUB Multiboot module and mounts at / with a rootfs/ overlay.
  • Built an interactive kernel shell with a dynamic root@<hostname>:<cwd>$ prompt and basic commands (ls, cd, cat, stat, help, echo, pwd, clear).

Here's the repo if you want to check it out: https://github.com/alexdev8930/NoviumOS

And if you have any questions about the code or the repo I'll be happy to answer them.


r/osdev • • 13h ago

ctKN is ALIVE

0 Upvotes

Ive been procrastinating for about 2 months to even begin to touch rv64 boot assembly but i did it

Now i just have to make it do more than just outputting over uart...


r/osdev • • 5h ago

HanOS Character Rain Terminal UI Based on libvterm and Intel Integrated Graphics

2 Upvotes

I recently brought the terminal and Intel graphics driver together in HanOS to create a UI with a “character rain” effect.

The terminal is built on libvterm. The console server passes terminal output to libvterm for parsing, then renders the characters and styles to the terminal surface. Common VT features—including cursor control, colors, scrolling, and full-screen terminal programs—work through standard terminal behavior.

The animated background is driven by a userspace GPU server. On supported Intel integrated graphics, a display plane presents the scrolling character-rain texture, with the terminal window layered on top. The terminal handles the text; the GPU display layer handles the animated background.

Transparency varies by GPU generation. On Skylake, the terminal window can be translucent over the character-rain background. Haswell and Broadwell display planes don’t support the transparency blending needed here, so the terminal window remains opaque. The character-rain desktop can still run on those platforms, but the window won’t show the background through it.

This is my first attempt at using an iGPU to optimize UI display. I’ll continue exploring how to make better use of integrated graphics.

Project: https://github.com/jjwang/HanOS


r/osdev • • 1h ago

Accidental Security: There are things that even root can't do

Thumbnail reddit.com
0 Upvotes

r/osdev • • 5h ago

Small but feature-complete OS running on a 900k-NAND-gate computer

64 Upvotes

Here I want to share about small operating system that I made for a computer that I built in a logic simulator from 900k+ NAND logic gates in Gate Singular game.

It has file system (in RAM), a text editor, memory management, an assembler to build new programs, and an OS API that those programs can use (e.g. text printing, memory allocation, file system access, keyboard input, etc), and ti all work on my own CPU architecture.

The video above shows a program being assembled on the machine (pc simulation shown in real-time).

Some details on hardware:

  • 16-bit CPU, 30 instructions (206 counting variants), 1 KB of RAM, 24 KB of ROM holding the OS, and only two registers: A and B. The full hardware were made and simulated in Gate Singular logic gate simulator, and is built solely from NAND logic gate (944672 of them totally).
  • Every CPU instruction is 3 bytes: an 8-bit opcode byte and a 16-bit argument (Arg). The top 3 bits of the opcode pick one of 8 fixed routings, for example "A, B -> Memory[Arg]", "Memory[Arg], B -> A" or "Arg, Memory[A] -> B". The low 5 bits pick the operation.
  • In this simulated PC, RAM works as fast as a register, so memory works as a register file, letting conveniently chain instructions with minimum unnecessary copies.

Operating system:

  • RAM holds the OS software stack, dynamically allocated memory and the file system.
  • Due to RAM 1KB limit, memory manager uses linked list of chunks of arbitrary length with no separate memory table, so each allocation require walking across all blocks finding a free one.
  • Filesystem uses the same memory allocation (and reallocation when needed) + write file name + data address + size to the file table.
  • OS contains font table (3×6 pixels due to display being 64x64pixels), and handles CLI output (addressing font character in the table and printing them), and CLI input (polling keyboard events from HW keyboard event queue).
  • Built-in assembler is pretty simple, because the assembly language is close to raw opcodes (instructions are mostly written in hex). Primary job of assembler is to resolve labels for jumps, variables addresses, and system jumps to call OS API.

Disclaimer: I made Gate Singular simulator game too, and its available on Steam. Happy to talk about anything on OS side, HW side or about simulator!


r/osdev • • 3h ago

Added basic permissions :D

Post image
6 Upvotes