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.
This repository implements 'moss', a monolithic, Unix-like operating system kernel written in Rust, targeting AArch64 (with stubs for x86_64). It boots on QEMU and aims to run unmodified Linux userspace binaries (e.g., bash, coreutils, strace) by providing a Linux-compatible syscall interface. The kernel features an asynchronous core: all non-trivial syscalls are async functions, and the scheduler (EEVDF) and synchronization primitives are designed for async operation. The architecture includes a Hardware Abstraction Layer (HAL) via the `Arch` trait, but the majority of the code is ARM64-specific, covering boot, exception handling, MMU, interrupt controllers (GICv2/v3), UART drivers, timers, RTC, virtio, and a virtio-GPU display driver. The kernel provides a full process model with clone, execve, signals, futex, epoll, inotify, ptrace, and POSIX credentials. Memory management includes demand paging, copy-on-write, mmap, brk, a slab allocator with per-CPU caches, and a buddy allocator for physical frames. The VFS supports multiple filesystems: tmpfs, ext4 (via the ext4plus crate), FAT32, procfs, devfs, sysfs, and a cgroupfs stub. Networking uses the smoltcp stack for TCP/UDP and provides Unix domain sockets. The codebase is experimental and contains many stubs and unimplemented syscalls, but it is actively developed with a working init process, shell, and basic tools. Key strengths include the clean separation of architecture-independent kernel building blocks in the `libkernel` crate, the async-friendly synchronization primitives (`WakerSet`, `CondVar`, `Mutex`), the generic page table framework, and the driver registration macro. The code is well-structured for a kernel of this complexity, with extensive use of Rust's type system for safety (e.g., typed addresses, user-copy abstractions). However, the project is not production-hardened, relies on nightly Rust, and has significant architecture-specific code that limits portability.
Bottlerocket is a free, open-source Linux-based operating system purpose-built for hosting containers. It is designed with a strong focus on security, immutability, and reliable updates. The system is configured entirely through an API-driven settings model, with all configuration stored as key-value pairs in a filesystem datastore. It supports multiple orchestrator variants (Amazon EKS, Amazon ECS, VMware, and bare metal) and cloud platforms (AWS, VMware, bare metal), with specialized variants for NVIDIA GPUs and FIPS compliance. The architecture is a minimal, Rust-heavy OS image built via a custom build system (Twoliter). The core components include a settings datastore with serialization/deserialization, a versioned migration framework for safe upgrades/downgrades, per-variant settings plugins loaded as dynamic libraries, and a TUF-based update mechanism with A/B partition flipping. The build system produces bootable images (AMIs, OVAs, raw images) and publishes them to TUF repositories. The codebase is organized as a Cargo workspace with hundreds of small crates, each handling a specific concern (migrations, defaults, plugins, models). Key entry points include the build system (cargo make), the settings datastore library (sources/api/datastore), the migration helpers (sources/api/migration/migration-helpers), and the per-variant settings defaults (sources/settings-defaults). The repository also contains tools for local VM testing, kernel config diffing, and secure boot key generation. While the codebase is well-structured and actively maintained, it suffers from significant duplication across many similar variants (e.g., Kubernetes 1.31 through 1.37) and a large number of archived migrations, which increases maintenance burden.
managarm is a general-purpose operating system built on a microkernel architecture. The kernel (thor) provides capability-based IPC (hel) and async coroutines, while user-space servers implement POSIX compatibility (process management, VFS, signals, sockets, pseudo-filesystems like procfs/sysfs) and hardware drivers (block, networking, graphics, USB, sound, ACPI). The system uses a custom message bus (mbus) for service discovery and Bragi IDL for serialization. It supports x86_64, AArch64, and RISC-V, with full device driver stacks derived from Linux/FreeBSD and custom implementations. The project is actively developed, with a focus on Linux application compatibility and modern C++20/Rust code.
Anoma is an Elixir/OTP implementation of the Anoma protocol - a distributed operating system for intent-centric applications. The codebase implements a full node architecture with multiple supervised engines: Mempool (transaction submission/ordering), Ordering (consensus sequencing), Executor (parallel transaction execution), Storage (Merkelized key-value store with RocksDB/Mnesia), Shard (partitioned KV store with watermark-based concurrency), IntentPool/Solver (intent matching and composition), Logging (event persistence and replay), and Transport (gRPC/IntraNode networking with proxy-based remote node communication). The system uses Nock/Noun as its core computation model (via anoma-lib), with a Cairo backend for shielded/zero-knowledge transactions. Transactions are submitted as jammed Nock nouns, executed in isolated workers, and results flow through an event-driven architecture (event_broker). The node supports distributed operation via gRPC transport with automatic peer discovery and advertisement. Key architectural patterns: CQRS-style engines (casts for mutations, calls for queries), typed event definitions with filters (defevent macro), supervisor hierarchies with dynamic child management, and a replay mechanism that validates persisted state on restart by spinning up a mock node. The codebase follows an "examples over tests" philosophy - extensive executable examples in lib/examples/ serve as both documentation and integration tests.
xv6 is a monolithic, teaching-oriented Unix-like operating system kernel for RISC-V, reimplemented from Version 6 Unix. The kernel provides process management (fork, exec, wait, exit), multiprocessor scheduling via a round-robin scheduler, virtual memory with SV39 page tables, a block-oriented file system with crash recovery via a write-ahead log, and essential device drivers (UART console, virtio disk). It boots in QEMU and includes a minimal init process, shell, and a suite of simple user commands (cat, grep, ls, etc.). The codebase is intentionally compact and clear, demonstrating core OS concepts with a focus on simplicity and directness rather than performance or production robustness. It is not a hybrid repo; it is purely a systems software application (an operating system).
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.
Bazzite is a custom Fedora Atomic (Silverblue/Kinoite) operating system image optimized for gaming on desktops, handheld PCs (Steam Deck, ROG Ally, etc.), and HTPCs. It provides a SteamOS-like experience with pre-installed gaming tools (MangoHud, vkBasalt, OBS VkCapture), hardware support (OGC kernel, HDR/VRR, DisplayLink, per-device audio profiles), and a suite of system management utilities. The repository is not a traditional application but a build system for generating container images and ISOs. The architecture is container-native: images are built via Containerfile and GitHub Actions, with modular overlays for different variants (desktop, deck, nvidia) and desktop environments (GNOME, KDE). Key components include a justfile recipe library for user-facing configuration (ujust), systemd services, udev rules, RPM spec files with patches for upstream packages (BlueZ, UPower, Xwayland, MangoHud), and hardware detection scripts. The build process is fully automated via CI/CD, with image signing and attestation. The project is actively maintained with a large community and extensive hardware support.
EmuTOS is a complete, GPL-licensed replacement operating system for Atari ST/TT/Falcon, ColdFire, and Amiga computers. It reimplements the entire TOS stack: BIOS (hardware drivers, boot), GEMDOS (file system, process management), VDI (graphics primitives), AES (windowing and event management), a desktop environment (EmuDesk), and a command-line interpreter (EmuCON2). The codebase is highly modular with clear layer separation, extensive conditional compilation for over a dozen hardware variants, and a build system that generates ROM images for each target. It is not a traditional application but a firmware ROM; however, from a software engineering perspective, it exhibits application-like structure with entry points (startup.S, biosmain, gem_main), a GUI, and a CLI. The system is actively maintained, with a rich history of reverse-engineering Atari TOS behavior and fixing emulator quirks. It relies on a 68k/ColdFire cross-compiler toolchain and GNU Make.
This is a bare-metal x86-64 operating system kernel written in Swift (using Embedded Swift). It boots on real hardware and emulators (QEMU, Bochs, VMWare) via both BIOS and UEFI. The kernel implements core OS primitives: memory management (page tables, slab allocator), interrupt handling (APIC, IOAPIC, PIC), ACPI table parsing and a full AML bytecode interpreter, PCI/PCIe bus enumeration, USB host controllers (UHCI, XHCI, EHCI), PS/2 keyboard/mouse, Intel i915 GPU driver, and a simple cooperative task scheduler. It uses a custom Swift toolchain (swift-kstdlib) and custom Swift macros for printf-style output. The project is a research/learning effort by a single developer, exploring Swift as a systems programming language for kernels. Architecture is modular with device driver tree, ACPI namespace, and separate memory management layer. Many drivers are functional but some remain incomplete or experimental (e.g., VMX virtualization, i915 only supports two GPU IDs).
This repository is a clean-room, portable reimplementation of Apple Macintosh System 7.1, targeting bare-metal x86, ARM (Raspberry Pi), and PowerPC hardware. It is a monolithic kernel that emulates the classic Mac OS Toolbox API, including subsystems such as the Event Manager, Window Manager, Menu Manager, Dialog Manager, QuickDraw, Font Manager, File Manager (HFS), and a Finder-like desktop environment. The codebase is written in C and assembly, with a hardware abstraction layer (HAL) for platform-specific drivers (USB, storage, timers, framebuffer). It boots via GRUB2 (x86) or custom bootloaders (ARM, PPC) and includes built-in applications like SimpleText and MacPaint. The project is explicitly a reverse-engineering effort based on public documentation and ROM analysis, with many subsystems partially implemented or stubbed. It is not production-ready but demonstrates deep knowledge of Mac OS internals and provides a foundation for running classic Mac software on modern hardware.
This repository is a custom operating system kernel project (UtopiaKernel) targeting x86-64 with the Limine boot protocol. The kernel entry point is written in Rust (using edition 2024, which is unstable) and is compiled as a bare-metal binary. The boot process uses the Limine bootloader, whose precompiled binaries for multiple architectures (x86_64, aarch64, riscv64, loongarch64, IA-32) are included in the repository. The only substantial source code beyond the kernel entry is a C utility (`limine.c`) for installing the Limine bootloader onto disk images and the Limine protocol header. The project demonstrates a modular adapter pattern for boot protocol abstraction, but the codebase is dominated by opaque binary blobs, limiting inspectability and reusability. It appears to be in active development but carries technical drift risk from using an unstable Rust edition and vendored third-party binaries.
This repository is a curated collection of code implementations, cheat sheets, and study resources for software engineering (SDE) interview preparation. It contains hundreds of independently written C++, Python, and C files covering fundamental data structures (arrays, linked lists, stacks, queues, trees, graphs) and algorithms (sorting, searching, dynamic programming, greedy, backtracking, string algorithms, etc.). The repo also includes problem sheets from popular SDE preparation resources (Striver's SDE Sheet, Love Babbar DSA Sheet), competitive programming patterns, and notes on core subjects like DBMS, OS, and CN. It is primarily a reference/learning resource rather than a cohesive application or data pipeline; the code is not packaged as a library and lacks tests, build systems, or dependency management. Many files are standalone textbook-style implementations. While the breadth is impressive, the depth and consistency of quality vary significantly across contributions, and the repository appears to be in a stale maintenance state with no recent meaningful code updates.