[Announcement/Showcase] Custom OSes, Languages & Tooling Pipeline.

[softwarewrighter]

FYI, I've been working on a few open source operating systems, using my own set of tools for planning, checking, measuring, validating work by multiple AI coding agents.

- sw-tos - a Tiny Operating System that runs on a 24-bit RISC FPGA soft cpu dev board and an emulator I wrote. It has preemptive multitasking. It is influenced by MINIX-1 and early S/360 operating systems like IBM MFT. https://github.com/sw-embed/sw-tos
It has a live demo of an n-curses-inspired multi-pane monitor, with a shell, debugger, clock, and cpu-hog app. It is largely implemented in cor24 assembler and in PL/SW, a system programming language I implemented inspired by IBM PL/S-III, PL/AS, and PL/X. Work is ongoing to add an I2C clock, and an SPI SD card and a file system.

- MLOS - Machine Learning O/S - very early, very experimental distributed O/S that considers ML data in the same light as MMU segments/pages. working towards having this run as a guest O/S on multiple systems with GPUs. The O/S is to manage weights, activations, engram tables, experts, routing, etc. across a high speed network (on top of Arch systems): https://github.com/sw-ml-study/sw-os-ml currently boots on Apple/ARM silicon only, plan to re-write for x64. Implemented in Rust.

(contributed to, not mine) MesaOS, https://github.com/softwarewrighter/MesaOS-fork -- I added an ascii clock example to this Linux-derived Rust O/S.

Note: I'm a retired platform engineer/engineering manager, former O/S developer (IBM MVS/370, /XA, /ESA, OS-390). I create "clean-room" open source projects for classic and future programming languages, too. https://sw-embed.github.io/web-sw-cor24-demos/

I started as a hardware technician and APL programmer, before becoming an O/S developer. I've written standalone utilities that boot from tape onto mainframes, in assembler and in IBM PL/X, that run with dynamic address translation and multi programming. I've written linkers, loaders, bootstraps, interruption handlers, dispatchers, storage mangers, and I/O drivers. I am now working on visualization, teaching, tooling, machine learning, AI coding tools, games, microcontrollers, FPGAs, and new ML programming languages.

Looking for feedback, collaboration, ideas to implement, problems to solve, ...

[Alexey1994]

Fair enough; I’m also a fan of sharing knowledge. I took a look at your *mlos* code but couldn't spot the ML component. The system-level code looks overly verbose due to the sheer number of comments. I think it would be easier to understand if you structured it as a standalone application rather than a general-purpose system. Right now, it looks more like LLM output. My recommendation to build an application instead of an OS comes from my own experience. I am writing this text in Russian myself and translating it.

[softwarewrighter]

Yes, thanks for the feedback. Working towards a demo. Just wanted to introduce what I am working on.

Like I said MLOS is early work (does not even use a GPU yet) but I am making progress.
1. DONE bare-bones "OS" boots, manages ML data like virtual storage pages PoC on arm64
2. DONE port 1. to x86-64 (yesterday)
3. TODO enable GPU support (within a week or so?)
4+ TODOs use host networking to connect multiple guest instances, share metadata, move work in a CUDA-like way from system to system. (can do this on high-core count Xeons if the GPU work gets stalled)

At that point I plan to demo a distributed MoE model running in parallel. (I have many MoE projects in other repos, models from scratch, reasoning model, etc.)

This work is driven by my "AI Cluster" (Lucy) which is a heterogeneous collection of refurbished Xeon servers and various NVIDIA GPUs. The motivation: how can I spread useful work (e.g. Rust coding agents) across diverse hardware effectively. (stretch goal, unlock (proprietary) Apple GPUs and connect them to the cluster--not sure if this is even possible)

Also, in parallel, I am working on new-style TPUs that plug into these systems to offload MoE experts to FPGAs, first via USB, later via SAS. Very experimental, unlikely to be fast at first.

And finally this is a prototype which I plan to throw away. The next iteration may start with homogeneous FPGAs implementing ternary compute nodes. This is a learning exercise to create a more-informed ML-oriented OS.

I will try to fix the verbosity, or at least provide literate programming documents to break it down into understandable chunks.