Puter is a full-stack, self-hosted 'internet computer' — a browser-based desktop environment (file manager, app launcher, AI services, static-site hosting, serverless workers) backed by a Node.js kernel. The repo is a monorepo of five interlocking sub-packages: a TypeScript backend kernel (`src/backend`), a browser GUI (`src/gui`), a published JavaScript SDK (`src/puter-js`), a CLI (`src/cli`), and a Cloudflare-Worker port (`src/worker`) plus an MCP connector (`src/mcp-connector`). The kernel is the centerpiece: it layers clients (MySQL/Postgres/SQLite, DynamoDB, S3, Redis, email, alarms), stores (user, app, FS entry, session, share, permission, group, KV, OIDC, notification, subdomain), services (auth, FS, metering, permission, ACL, broadcast, notification, OIDC, app-icon, health), controllers (REST + WebDAV + WISP + Peer endpoints), and drivers (AI chat/TTS/STT/image/video/OCR, KV, apps, subdomains, notifications, workers) behind a custom `PuterServer` that wires them together with ordered peer-dependency construction. Configuration is a three-tier deep-merge (config.default.json → config.json → PUTER_CONFIG_PATH) computed at startup. The backend is well-tested with vitest unit, integration, and benchmark suites; the SDK ships with Playwright e2e tests. The GUI is a large, jQuery-based desktop UI with its own webpack build and a component system. Notable engineering: a type-safe permission/ACL system with rewriters and implicators, a metering/subscription model in microcents, a multi-engine database abstraction with ordered migrations, a driver pattern with per-operation cost tables, a token v1→v2 silent-migration path, a reauth coordinator with shared in-flight promises, and a worker-types package that provides template-literal route-param inference for the worker runtime. The codebase is actively maintained (June 2026), uses current Node 24 / TypeScript 5.9 / Express 5 tooling, and has CI for backend tests, docs builds, release-please, and Docker image publishing.
Asterinas is a production-grade, memory-safe operating system kernel written in Rust that aims to be Linux-compatible. It implements a framekernel architecture combining monolithic performance with microkernel-inspired separation, providing system call interfaces, device drivers, filesystems, networking, and process management. The project includes the OSDK (OS Development Kit) for building, running, and testing Rust kernels, and supports multiple architectures (x86-64, RISC-V, LoongArch) with varying tier levels. While it has strong research roots (evidenced by recent academic papers), its primary focus is on creating a usable OS that can run real-world applications via NixOS distribution.
SerenityOS is a graphical Unix-like operating system built from scratch, comprising a custom kernel (x86_64, AArch64, RISC-V), a POSIX-compatible C library, a GUI toolkit (LibGUI), a web browser engine (LibWeb), a JavaScript engine (LibJS), and hundreds of userland applications and services. The codebase demonstrates high engineering effort with consistent patterns (ErrorOr, reference counting, IPC frameworks, object macros) and extensive test coverage across kernel, libraries, and web standards. However, it bears some technical drift: many POSIX functions are stubs, kernel features are incomplete on newer architectures, and the ports system for third-party software requires ongoing maintenance. The repository is actively developed with frequent commits and issue triage.
Hermit-rs is a Rust-based unikernel (library OS) that enables applications to run directly on hardware or hypervisors without a traditional operating system. The repository provides the build infrastructure (the `hermit` crate), the system call ABI (`hermit-abi`), and a collection of example applications demonstrating networking, file systems, TLS, WASM execution, and more. The actual kernel is maintained in a separate submodule. The project is actively developed with CI testing across x86_64, aarch64, and riscv64 architectures, and supports running under QEMU, Uhyve, and KVM. It is a hybrid of a system library and an application framework, but its dominant character is an application platform for building unikernel images.
ChimeraOS is a build system for creating a custom Arch Linux-based operating system image tailored for gaming consoles. It provides a set of shell scripts, configuration files, and GitHub Actions workflows to assemble a complete system image with Steam, RetroArch, gamescope, and other gaming-related packages. The build process uses a Docker container to create a reproducible environment, installs packages from Arch repositories and the AUR, applies custom configurations, and produces a compressed Btrfs image. The repository includes scripts for session management, hardware quirks, and system migrations, all designed to create a console-like experience on PC hardware. It is not a runtime application but a build toolchain, and the code is well-structured for its purpose, with several reusable utility scripts and migration patterns.
This repository is the build system for AvyOS, a Linux distribution that compiles all packages from source using a custom Go-based tool called 'ignite'. The system defines hundreds of YAML recipes under `elements/` for building the kernel, system libraries, desktop environments (KDE, GNOME, Xfce, Sway, etc.), development toolchains, and applications. The ignite tool handles dependency resolution, source fetching, containerized builds (via bubblewrap), and image generation (ISO, disk images, OSTree commits). The architecture is a declarative recipe system with reusable includes, patch management, and a web dashboard for monitoring builds. Key entry points are the `ignite` CLI and the YAML recipe files. External dependencies include upstream source tarballs, patches, and a custom build environment. The repository also includes configuration for secure boot, A/B updates, and live ISO booting. While the codebase is well-structured and demonstrates significant engineering effort, it is a personal project with limited documentation, many TODO comments, and potential drift due to custom kernel versioning and future-dated Go version requirements.
This repository implements Composite, a component-based research operating system where kernel policies (scheduling, memory management, synchronization) are implemented as user-level components. It runs on x86-32, x86-64, and ARMv7a architectures, primarily under QEMU. The system provides a minimal kernel with capability-based security, synchronous invocation (sinv) for inter-component communication, and shared-memory channels. It includes a full musl libc port for POSIX compatibility, a DPDK-based network stack, an lwIP adapter for TCP/IP, and a simple VMM with virtio-net and device emulation. The architecture is closer to a microkernel than a traditional monolithic kernel, with components loaded and composed via a Rust-based composer tool that reads TOML specifications. A large suite of microbenchmarks measures IPC, scheduling, and synchronization latency. The codebase is pre-alpha quality, with many FIXMEs and incomplete features, but demonstrates strong craftsmanship in its abstraction layers (assembly stubs, channel library, scheduler framework, perfdata utility).