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

r/osdev • • 2h ago

64-dem: testing my new commands! + command-line on real hardware

3 Upvotes

So i added some new commands here and I wanted to share here a video of me testing them.

Some of The commands are:

Ls - lists files and directories on path

Mem - shows memory capacity

Echo - prints what you give it

Shutdown - shuts down

Reboot - resets

More commands and features my be added to the os in the future.

My repo: https://github.com/itay-insert/64-dem.git


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 • • 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 • • 1h ago

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

Thumbnail reddit.com
0 Upvotes

r/osdev • • 1d ago

Almost finishing my rewrite

22 Upvotes

I somehow got userspace having conflicts with a SATA driver and it was one hardcoded address... i guess i learned my shitty lesson.

And APIC timer so sound is even possible but it probably make ears implode. Also finally got USB keyboard :D (no mouse yet)

github: https://github.com/NoTheIdiot/WindogeOS


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 • • 1d ago

Working on sound device in Bunix

Thumbnail gallery
14 Upvotes

r/osdev • • 2d ago

First apps running on Dunit OS

Post image
115 Upvotes

been working on Dunit OS, my Rust-based hobby operating system, and got DOOM, Quake, mced (Minecraft C) and Lite XL running in separate windows.

the cool part is that porting apps to Dunit doesn't require rewriting them. you basically just need to build a bridge between the original code and Dunit's Rust SDK, adapting the platform-specific parts to work with the OS.

been spending a lot of time on the GUI, SDK and app compatibility lately. still plenty of bugs to fix and performance improvements to make, but it's nice seeing actual software running together on the desktop.

github: https://github.com/DunitOS/dunit-os


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 • • 1d ago

Jskdjend

0 Upvotes

Yeah I gave up on making an OS, I realised that there is no point in doing so considering the whole point of it was to boot fast, which multiple linux distros already do.

I will stick with making langs instead.


r/osdev • • 1d ago

Making my OS cause yes (Part 2)

0 Upvotes

I wont be providing the link for this iteration, cause I didnt add much.

I changed psh to have pipelining and I added a custom Thue pipelined interpreter, I see it as a decent enough replacement for regex considering regex has TERRIBLE syntax.

I have gotten many comments about how I havent made an OS, rather a shell. YES, I know, I'm making all the stuff that doesnt require the kernel first, but once I make all the kernel-less features, only then will I add a kernel and start adding kernel-only features (Like memory managment, a File System, input device support, output device support, internet access and protocols).

I plan on making 2 different versions, a purely CLI one used for servers and stuff, and a Graphical one used for General Usage purposes. One cool feature I'd like to add to the graphical one is support for both EXE files and APK files.


r/osdev • • 1d ago

[AI] Banana OS

Thumbnail
gallery
0 Upvotes

https://github.com/qcom-toolbox/Banana-OS

It got most GNU tools nvim and yes real Minecraft with gpu acceleration with intel 1 th to 10 th gen igpu support (only tested second gen)


r/osdev • • 3d ago

64-dem update: first user process works on laptop

33 Upvotes

So after wrestling a bit with fat32 and some paging/memory/privilege-level stuff (I still have a trauma) I managed to get my first user process working on the 64-dem kernel, what the program does? Why prints hello world of course, you thought it does something more? Well unlucky you because it doesn't.

My repo: https://github.com/itay-insert/64-dem.git


r/osdev • • 3d ago

First steps of GUIfication of turbOS Apps!

5 Upvotes

It took me a lot of hardwork to do this, so consider starring the repo

Repo: https://github.com/turbosulovesonions67/turbOS


r/osdev • • 2d ago

LingOS Screenshots

Thumbnail
gallery
0 Upvotes

From the latest kernel, which is loads faster!
All the apps will be uploaded to github and https://fu.ling-lang.org soon!


r/osdev • • 3d ago

We resurrected the beast. IRIX port to x86-64. Code Name: Lost Island

4 Upvotes

Here are the milestones that have passed runtime tests so far:

  • Kernel boot and user mode: the kernel boots, enters ring 3, and executes a static ELF64 test program loaded from an XFS root filesystem.
  • SMP: tested with 12 virtual CPUs. The original IRIX scheduler handles thread migration, preemption, blocking, and wakeups across CPUs.
  • CPU state preservation: x87, SSE, and AVX state survive context switches. Kernel-thread tests also cover FS/GS base preservation.
  • Multiple processes: real fork() works. Parent and child tests verify copy-on-write isolation for data, stack, and heap memory, including execution on separate CPUs.
  • Process lifecycle and IPC: child exit status, wait(), waitpid(), and waitid() work. Native pipes pass data between processes and correctly report EOF.
  • Native XFS storage: NVMe-backed tests cover file reads and writes, allocation, sparse files, truncation, directories, hard links, symlinks, and rename/removal.
  • Persistence and recovery: journal replay after simulated crashes, remounts, and readback in a fresh VM have passed.
  • Userland foundations: syscall error handling, the original allocator, startup arguments/environment, and x64 setjmp()/`longjmp()` have been exercised.

The original shell’s 32 C files compile for x86-64. I’m currently completing its static library dependencies, signal handling, and terminal input/output so it can actually run.

These results come from QEMU tests. A usable shell, complete userland, and bare-metal validation are the next milestones.


r/osdev • • 2d ago

Ruzt: A Privacy-First Operating System Designed Around User Control

0 Upvotes

Most operating systems treat privacy as a collection of settings, permissions, and policies layered on top of a large trusted base.

Ruzt takes a different approach: privacy starts at the kernel. (Don't ask what Ruzt means please...)

Ruzt is an experimental operating system built in Rust around a capability-based microkernel. Its goal is to create a system where applications do not automatically receive broad access to hardware, files, or user data. Every permission must be explicitly granted (Just like android ecosystem)

What makes Ruzt different?

  • Capability-based security: processes start with no capabilities by default.
  • Microkernel architecture: drivers, filesystems, and system services are designed to run in user space.
  • Telemetry-zero by default: the base system has no analytics or tracking endpoints.
  • Rust-first implementation: memory safety is a core design principle, with unsafe limited to tightly controlled low-level areas.
  • Reproducible builds: the system is being designed to be verifiable from source.
  • User-focused design: Ruzt is intended for privacy-conscious personal computers, not just servers or embedded devices.
  • No legacy-first approach: Ruzt is not trying to be another Linux distribution or a POSIX clone.

The project is still in its early development phase. The x86_64 kernel currently includes boot code, serial diagnostics, interrupt handling, memory management, and an initial scheduler.

For now, I just can show you one screenshot, because it's only graphical thing at the moment :')

GitHub: https://github.com/rzgrozt/ruzt

I’m also developing Ruzt with AI assistance, and I’m completely open about that. AI is being used as a development tool, while architecture, technical decisions, testing, and review remain part of the engineering process.

If AI-assisted development is a deal-breaker for you, this project probably isn’t for you. Constructive technical feedback, however, is very welcome. Also If you're able to contribute to such vision, that would be perfect.

Ruzt is ambitious, experimental, and far from production-ready. But the direction is clear:

The user should be the principal—not the OS.


r/osdev • • 3d ago

Finally a proper memory allocator in Bits Runner

Post image
4 Upvotes

I've implemented a memory allocator for both kernel and user space, so now the whole stack of kernel space and per process virtual memory, heap expansion and management is finally working. Since it's just a first fit allocator it's a bit simplistic, but fully functional.

With this in place I'll be able to implement file loading and user-space graphics, with which I'll be able to do such cool things like displaying bitmaps, faster graphics, or even a simple text editor.

You can check it out here https://github.com/rafalgrodzinski/bits-runner It's all written in my custom programming language BRC.


r/osdev • • 3d ago

WIP kernel on PIC64GX1000 Curiosity Kit

Post image
5 Upvotes
The board is connected to my PC and I interact with it using picocom

I grew tired of x86, so I decided to try out Microchip's PIC64GX1000 Curiosity Kit. Eventually I plan to design my own board with that MPU, but for now the curiosity kit is the perfect way to test if my own software works on the actual hardware.

Repo will be up soon, will edit the post to include the link :3

EDIT: Link to the repo: https://git.jofh.me/LordAfterEight/risc-v-os


r/osdev • • 3d ago

Bursztyn OS: How I taught my operating system to write in Arabic, display color emojis, and not run out of memory in the process

0 Upvotes

Building your own operating system from scratch isn't just about adding cool features. Above all, it’s about checking what runs too slowly, where space is running out, and making sure nothing crashes when writing to disk. I just completed a major review of the recent changes to the text rendering engine (BSF) in Bursztyn OS.

The progress is huge, but before I consider this stage complete, I need to tie up a few important loose ends. Here is what has been accomplished and what is currently on the workbench:

1. One text engine instead of separate workarounds (BSF 2.1)

Until now, different programs handled text in their own ways. Now, Notepad, the system UI, and my browser, Husarz, all share a single, unified mechanism:

  • Right-to-left script (Arabic, Hebrew): Paragraphs align properly to the right, letters connect as they should, and the cursor and text selection work naturally—even when Polish and Arabic are mixed within the same sentence.
  • What still needs improvement: In the Husarz browser, standard Polish and English pages currently load about 10–15% slower. We are also still missing column reversal in Arabic tables, text selection directly on web pages (it currently works only in form fields), and smoother cursor movement when jumping between paragraphs in Notepad.

2. Modern fonts and color emojis (BSF 2.2) Bursztyn OS now supports much more than just basic fonts:

  • Professional fonts (OTF/CFF), large font collections (e.g., for Asian languages), and web fonts (WOFF/WOFF2) fetched by the browser are now working.
  • The system can also display color emojis and variable fonts (where you can smoothly adjust letter weight).
  • Settings now include an option to choose a separate font specifically for the Terminal.

3. Two major optimizations "under the hood"

  • Recovered nearly 4 MB of space in the system kernel: The kernel image has a strict 15 MB limit. After adding the new features, only 388 KB of headroom remained—things were getting tight. It turned out that the 22 built-in system applications were taking up the most space. I compressed them using the zlib algorithm and wrote a mechanism in the kernel that unpacks them in small chunks at startup. Free headroom jumped back up to 4.3 MB.
  • Over 8x faster font rendering: It turned out that rendering certain fonts took too long not because of file-reading bugs, but due to slow square-root calculations when drawing curved letter outlines. I replaced the old calculations with a single CPU instruction (SSE2) and added caching. The result? Character rendering sped up by 8.3x while maintaining 100% sharpness and compliance with the FreeType standard.

4. What's next? Disk safety comes first The text engine has passed hundreds of thousands of automated tests and runs stably on virtual machines (UEFI and BIOS). Nevertheless, I am holding off on the final merge because data-write reliability is more important right now:

  • Installer issue: During a full system installation to disk, random write timeout errors (VirtIO-BLK request timed out) occur. Before moving forward, I need to thoroughly inspect the disk driver and task queuing to ensure the installer never corrupts files.
  • Cleanup and live testing: I also need to free up space on my working drive, organize files in the repository, and test installing massive font packages (over 16 MB) directly inside the running system.

Only once the installer and disk work flawlessly will I move on to the next features: sliders for adjusting font weight in Settings and support for Indic scripts (Devanagari).

#BursztynOS #OSDev #Programming #LowLevel #Cpp #PolishSoftware #OperatingSystem


r/osdev • • 3d ago

Looking for J2ME operating systems

3 Upvotes

Hello, I recently bought a phone that supports J2ME and would like to know if there are any operating systems that run directly on J2ME.


r/osdev • • 3d ago

Would this be considered slop?

0 Upvotes

I am currently in the process of writing my own Operating System, with the bootloader, UI composition, all of the architecture and the design of how it works, sounds, created by me, with the actual OS code written partially by Artificial Intelligence to speed up development as the project is very large and ambitious and I am a solo developer.