KolibriOS
KolibriOS is an open-source operating system designed for 32-bit x86 architecture computers, featuring a monolithic preemptive kernel written entirely in FASM assembly language.[1][2] It originated as a fork of MenuetOS in 2004, following the latter's shift toward closed-source development, and has since been independently maintained by the KolibriOS Project Team.[1][3] The OS is renowned for its extreme compactness, with the core kernel under 100 KB and the entire system fitting on a single 1.44 MB floppy disk, requiring minimal hardware such as a Pentium-compatible processor and at least 8 MB of RAM.[1][2] Key features include rapid booting in under five seconds, instant application launch times, and a graphical user interface with pre-installed applications such as a word processor, image viewer, web browser, and over 30 games.[4] It supports a wide range of file systems, including full read/write for FAT12/16/32, read-only NTFS, and Ext2/3/4, alongside extensive hardware drivers for sound, networking, and graphics.[4][5] KolibriOS emphasizes efficiency and portability, running from floppy disks, CDs, USB drives, or as a live system, making it suitable for legacy hardware and embedded applications.[3][2] Development remains active as of 2025, with nightly builds available and community contributions encouraged through an official Git repository and forum.[4][6] The project supports programming in multiple languages beyond assembly, including C, C++, and Python, fostering ongoing enhancements while preserving its minimalist ethos.[6] Licensed under GPL, KolibriOS continues to evolve as a lightweight alternative to larger operating systems, prioritizing speed and resource conservation.[1][2]Introduction and Overview
Design Principles
KolibriOS embodies a core philosophy centered on extreme minimalism, aiming to deliver a fully functional graphical operating system that fits entirely on a single 1.44 MB floppy disk while providing essential computing capabilities such as multitasking, networking, and multimedia support.[7][8] This design choice prioritizes efficiency and portability, enabling the OS to boot and run instantaneously on resource-constrained environments without the overhead of larger systems.[7] To achieve this compactness and performance, KolibriOS is written almost exclusively in assembly language using the Flat Assembler (FASM), which allows for fine-grained control over code size and execution speed, eliminating the bloat associated with higher-level languages.[7][9] The resulting codebase remains lightweight, with the kernel under 100 KB, facilitating rapid development and optimization for x86 architecture.[10] At its heart lies a monolithic kernel that integrates core services like file systems, device drivers, and memory management into a single address space, promoting simplicity and low latency.[8] It supports preemptive multitasking to ensure responsive operation across multiple applications, balancing the trade-offs between a unified kernel design and the need for concurrent execution without compromising the OS's small footprint.[11] Released as open-source software under the GPL-2.0-only license, KolibriOS encourages community contributions and modifications.[12][8] By targeting low resource requirements—such as 8 MB of RAM minimum and minimal disk space—KolibriOS seeks to revive aging hardware, making it ideal for hobbyists, educators, and experimentation in embedded or retro computing scenarios.[7][8] Its fork origins from MenuetOS further underscore this commitment to lean, assembly-based innovation.[9]System Requirements
KolibriOS features exceptionally low minimum system requirements, enabling it to operate on legacy hardware from the mid-1990s onward. The essential prerequisites include an i586-compatible CPU, such as a Pentium or equivalent processor from AMD or Cyrix (with 486 and earlier models unsupported), at least 8 MB of RAM for basic functionality, a graphics card supporting VESA standards (with VGA modes also compatible for 640x480x16 resolution), and initial storage via a 1.44 MB floppy disk or equivalent medium like a USB flash drive.[13][14][15] These specifications allow the system to boot and run its core graphical interface without additional peripherals, though a PS/2 or USB keyboard and mouse are needed for interaction.[14] For optimal performance, particularly with multitasking and running applications, a recommended configuration includes 32 MB or more of RAM, storage via IDE or SATA interfaces for faster access times, and hardware supporting USB for connecting peripherals such as external drives or input devices.[13][15] The official distribution notes that 12 MB of RAM suffices for loading the full set of included applications alongside the GUI, highlighting the system's efficiency on modest setups.[16] KolibriOS supports multiple boot methods to accommodate various environments, including direct booting from a 3.5-inch floppy disk, USB flash drive (formatted in FAT32), hard disk (via LBA mode), CD/DVD, or even network booting.[13][14] For integration with existing Windows installations, a dedicated loader such as nt2klbr.exe enables booting KolibriOS directly from NT-based systems like Windows 2000 or XP, potentially replacing the host OS during runtime.[17] The operating system is designed exclusively for 32-bit x86 architectures and provides no support for 64-bit processors or non-x86 platforms, ensuring compatibility with older PCs while limiting scalability on modern hardware.[2][10] In terms of storage, the core KolibriOS image occupies less than 2 MB, allowing installation on minimal partitions, though additional space is required for saving data or installing extra applications via the built-in package manager.[15][16] These requirements reflect the minimalist design principles that prioritize compactness and speed over broad hardware versatility.[13]History and Development
Origins and Fork from MenuetOS
KolibriOS originated as a fork of MenuetOS in 2004, led by Russian developer Marat Zakiyanov, known by the pseudonym "mario79." MenuetOS, created by Finnish programmer Ville Turjanmaa, was a compact operating system written entirely in assembly language, evolving from a multi-run program for DOS in the late 1990s into a standalone 32-bit OS with a graphical interface.[18] The fork addressed specific limitations in MenuetOS, particularly the need to repair and enhance drivers for the Russian-language distribution, which suffered from compatibility issues with local hardware.[19] The primary motivations for the fork included improving hardware support, advancing internationalization—especially for Russian users—and fostering community-driven enhancements to keep the 32-bit architecture viable amid MenuetOS's shift toward a proprietary 64-bit version.[18][20] Early efforts focused on maintaining the lightweight, floppy-disk-bootable design while resolving integration problems that hindered broader adoption in Russian-speaking regions. The project name "Kolibri," meaning "hummingbird" in Russian, was proposed by Zakiyanov to symbolize its agility and compactness.[19] Initially conceived as a hobby project within Russia's developer community, KolibriOS quickly transitioned into a structured open-source initiative under the KolibriOS Project Team, with source code obtained directly from Turjanmaa.[19][18] Key early contributors formed an international team, predominantly from Russia, Kazakhstan, and Ukraine, with additional participants from Belarus, Belgium, Germany, Moldova, Uzbekistan, and Estonia joining to expand development efforts.[18] This collaborative foundation emphasized open accessibility, culminating in the project's formal open-source release under the GPL license by 2006.[18]Major Releases and Milestones
KolibriOS originated as a fork from MenuetOS in 2004, with its first public version, 0.1.0.0, released on May 16, 2004, primarily as a driver-fix update for the Russian-language distribution.[17] Subsequent early releases, such as 0.2.0.0 in August 2004 and 0.3.2.0 in March 2005, focused on stabilizing core functionality and providing source code availability, laying the groundwork for broader hardware compatibility.[17] By 2006, KolibriOS reached version 0.6.0.0 on September 4, introducing the nt2klbr.exe loader for booting directly from Windows environments and enhancing USB support alongside initial networking improvements.[17] The progression continued with minor updates like 0.6.5.0 in February 2007, leading to the 0.7 series starting with 0.7.0.0 in June 2007, which added more applications and refined system stability.[17] Version 0.7.7.0, released on December 13, 2009, marked a significant milestone with expanded LiveCD support and over 100 bundled applications, emphasizing incremental enhancements in drivers and kernel efficiency.[21][17] In the mid-2010s, key milestones included the integration of read/write support for exFAT and ext2/3/4 file systems, enabling better compatibility with modern storage formats alongside read-only NTFS handling.[1] By 2024, the ecosystem had grown to include over 200 bundled applications, such as multimedia players, browsers, and games, demonstrating sustained community contributions.[22] Development has since relied on SVN and Git-based versioning, with ongoing nightly builds under the 0.7.7.0+ banner, such as build +8801 in February 2025.[23] Recent 2025 updates, including kernel revisions up to r8715 and the KolibriACPI branch (last modified October 2025), have incorporated ACPI improvements for enhanced power management and hardware detection, alongside updated network drivers for the new BSD-compatible stack and the introduction of ATIKMS for AMD/ATI 3D acceleration and video decoding.[24] Additionally, October 2025 saw the addition of HTTPS proxy support. As of November 2025, nightly builds continue with the latest at +8930 (September 29, 2025), and kernel revisions have progressed beyond r8715 to at least r9115, incorporating further optimizations.[23][25] These incremental enhancements, tracked through revisions like r7696 to r9115, prioritize driver reliability and kernel optimizations without formal major version increments beyond 0.7.7.0.[24]Development Branches and Community
KolibriOS development is organized around specialized branches that address particular technical goals, with the main repository hosted at git.kolibrios.org. The KolibriACPI branch extends support for Advanced Configuration and Power Interface (ACPI) features, enabling improved power management and compatibility with modern hardware components such as laptops and energy-efficient systems. This branch includes updates to kernel modules for ACPI tables and event handling, with builds available as recently as October 2025.[26] Similarly, the Kolibri-A branch represents an exokernel variant designed for embedded systems and hardware engineering, initiated in July 2010 to tackle limitations in driver development and resource isolation.[27] It optimizes for minimal overhead on platforms like AMD APUs, supporting targeted applications in resource-constrained environments. The community driving KolibriOS has been active since 2004, comprising over 80 contributors from more than 10 countries, including Russia, Poland, Germany, and others, coordinated by a core team of system programmers like Trans (Sergey Kuznetsov) and Mario79 (Marat Zakiyanov).[28] Development is managed through the central Git repository at git.kolibrios.org, where participants submit patches and pull requests for kernel enhancements, drivers, and applications.[29] The project emphasizes assembly language coding using the FASM assembler, integrated directly into the build process, though higher-level languages like C and C++ are supported for certain components.[30] Contributions follow an open process, welcoming patches for drivers, applications, and libraries, with new developers encouraged to start by fixing bugs or implementing small improvements before tackling larger features. The bug tracker at bugs.kolibrios.org, powered by MantisBT, facilitates issue reporting and resolution, with recent entries from 2024 addressing areas like network stability and input device handling.[31] Nightly builds, generated automatically and accessible at builds.kolibrios.org, provide the latest changes for testing, with updates as frequent as monthly and the most recent from September 2025.[32] KolibriOS has participated in Google Summer of Code in 2014, 2016, 2024, and 2025, fostering student contributions on projects like NVMe drivers and SDL2 ports, with 2025 ideas focusing on file systems and widget toolkits.[33][34][35] As of 2025, KolibriOS remains actively maintained, with monthly updates reflected in Git commits—such as the October 2025 addition of HTTPS proxy support—and ongoing forum discussions at board.kolibrios.org for coordination, support, and idea sharing among the international contributor base.[25][36] The core team oversees integration of branch work into the trunk, ensuring sustained progress on hardware compatibility and system efficiency.[28]Technical Architecture
Kernel and System Design
KolibriOS employs a monolithic preemptive kernel that integrates core system services, including process management, memory handling, and I/O operations, within a single address space to optimize performance and minimize overhead.[1] This design allows the kernel to remain exceptionally compact, measuring less than 100 kilobytes in size, enabling rapid loading and execution on resource-constrained hardware.[1] The kernel supports multitasking through system calls that facilitate parallel execution, allowing multiple processes to run concurrently without blocking critical operations.[1] The system is built for 32-bit x86 architecture, utilizing a flat memory model where all code and data reside in a linear address space, simplifying memory access and reducing complexity compared to segmented models.[37] To prioritize speed on systems with limited RAM, KolibriOS forgoes virtual memory swapping, relying instead on physical memory allocation for all operations.[38] Key components include built-in drivers that are loaded during initialization for essential hardware support, such as USB and networking stacks, and a mechanism accommodating up to 255 concurrent processes through efficient slot-based scheduling.[1] The boot process begins with a custom loader embedded in the kernel image, which parses the executable format, sets up the protected mode environment, and initializes core hardware components like the CPU, memory controller, and interrupt handlers.[39] Once hardware detection and basic services are established, the loader transitions control to the kernel proper, which then launches the default shell to present the user interface. This streamlined sequence contributes to KolibriOS's fast boot times, often under five seconds on compatible hardware.[40] Security in KolibriOS features basic separation between user and kernel modes, leveraging x86 protected mode rings to restrict user applications from direct hardware access or kernel data manipulation.[37] However, as a hobbyist-oriented system, it implements minimal privilege enforcement and lacks advanced features like mandatory access controls, emphasizing simplicity and performance over robust isolation. The kernel's assembly-based implementation further enables this compact and efficient design by avoiding higher-level language overheads.[40]Programming and Build Process
KolibriOS is developed predominantly in FASM (Flat Assembler) assembly language, with the kernel, most drivers, and a significant portion of applications written entirely in assembly to achieve compact code size and high execution speed. This approach allows for fine-grained control over system resources, resulting in an operating system that fits within minimal storage constraints while maintaining efficiency on x86 hardware.[8][41] The build process relies on the FASM toolchain as the core assembler, supplemented by the Tup build system for orchestrating compilation of the entire OS from source. Developers initialize the build environment withtup init in the repository root and execute tup to generate the output, producing a single bootable image file, kolibri.img, approximately 1.44 MB in size, which encapsulates the kernel, drivers, and bundled programs. Individual components, such as applications, are compiled directly via FASM commands like fasm program.asm, often requiring inclusion of language selection files (e.g., lang.inc) for localization support. While some higher-level programs may use makefiles for GCC or MSVC integration, the assembly-centric core ensures a streamlined, resource-light compilation workflow.[42][43][44]
The official development kit is distributed via the DOCPACK utility within KolibriOS, containing the FASM compiler, system API headers (e.g., macros.inc for system calls), and example source files for creating custom applications. These examples demonstrate structures like the MENUET01 header format, which specifies entry points, memory allocation, and stack details, enabling developers to write event-driven programs that handle GUI interactions via interrupts like int 0x40. Applications support inline assembly integration, allowing mixed-language development while adhering to the 32-bit flat memory model.[30][41]
Source code management occurs through a Git repository hosted at git.kolibrios.org, featuring a modular directory structure that separates the kernel (in /kernel/), drivers (in /drivers/), and user programs (in /programs/). This organization facilitates targeted contributions, with the repository mirroring available on GitHub for broader accessibility.[25][8]
The assembly-focused programming paradigm enables optimizations such as direct hardware manipulation without abstraction layers, contributing to the OS's small footprint and rapid boot times, but it inherently restricts portability to non-x86 architectures and increases the complexity of debugging and maintenance compared to higher-level languages.[41][7]
User Interface
Graphical Desktop
KolibriOS features a lightweight graphical desktop environment centered around the Eolite file manager, which serves as the default shell and provides an icon-based interface for navigating files and launching applications. Eolite resembles the Windows Explorer in layout, displaying drives, directories, and files in a hierarchical view with 16x15 pixel icons for quick visual identification. Users can interact with the interface through standard mouse operations, including double-clicking icons to open files or programs directly from the desktop or file views.[45][46] The desktop supports basic drag-and-drop functionality within Eolite for moving or copying files between directories, enhancing usability in the icon-driven environment. Graphics rendering relies on built-in VESA 2.0 and 3.0 drivers, enabling resolutions in 16-bit, 24-bit, and 32-bit color depths as supported by the hardware's VESA BIOS, with common modes up to 1024x768 and higher depending on the graphics adapter. The windowing system allows for overlapping windows, managed through simple stacking and focus switching, contributing to a responsive GUI experience enabled by the OS's preemptive multitasking.[46][15][47] Key UI components include a main menu accessible via the "@menu" daemon for launching system applications and a taskbar or panel bar ("@taskbar") that displays running programs, system tray icons, and quick access options. As of 2025, the @taskbar has been updated to support tunable positioning (bottom or top), hotkeys such as Win+D for desktop show/hide, and configuration via file.[48][49][50] Skinning support permits customization of the desktop appearance, with users able to view and apply different skins dynamically through the desktop application or configuration settings, making changes persistent via resource files. Recent enhancements include movable desktop icons via @icon with PNG transparency support, new desktop applications like ColorDialog, deskcfg, and appearance for UI customization, along with system fonts featuring scaling, smoothing, and Unicode support integrated into the kernel. New window resize mouse cursors change shape when hovering bounds, and tunable non-linear mouse pointer acceleration is available via system functions. The Boxlib library has been updated with new widgets such as TextEditor, ProgressBar, and FileBrowser. Multi-monitor setups are limited to basic configurations where the primary display handles the full GUI, without advanced spanning or independent desktop extension. Input handling integrates standard PS/2 and USB mouse and keyboard support, with automatic detection for pointing and text entry across the desktop and applications. For scenarios requiring touch-like interaction or accessibility, the Zkey on-screen keyboard provides a graphical alternative for input, invocable as a bundled utility. Customization extends to themes through skin resource files, allowing users to alter visual elements like window borders and colors, while application launching supports both double-click actions in Eolite and system-wide hotkeys such as Alt+Tab for window switching or Ctrl+PrintScreen for screenshots.[15][45][51]Shell and Command Line
KolibriOS provides a lightweight command-line interface through its default shell, known simply as SHELL, which serves as the primary text-based interaction layer for users seeking non-graphical operations.[52] This shell is implemented as a console application utilizing the console.obj library and supports over 30 basic commands as of 2025, emphasizing simplicity and efficiency in line with the operating system's assembly-language design. Recent additions include mv for moving files, ren for renaming, kfetch for system information, lsmod for loaded modules, and pkill for process killing, along with features like echo redirection to files and navigation using Home/End keys.[52][50] It enables fundamental file system navigation and manipulation, akin to basic DOS or Unix utilities but without the complexity of full-featured shells like Bash. Key commands includecd for changing directories, dir (aliased to ls) for listing files, copy (aliased to cp) for duplicating files, and direct execution of applications by name to launch programs.[52] Additional utilities cover tasks such as mkdir for creating directories, rm for deletion, echo for output, ps for process listing, and kill for terminating processes, allowing users to manage system resources and perform routine maintenance.[52] The shell maintains a command history limited to the last five entries and supports aliases for customizing command shortcuts, facilitating repeated operations without full retyping.[52]
Scripting in the shell is basic, relying on simple script files that can be executed directly, similar to DOS-style batch files but without advanced control structures or a dedicated scripting language.[52] These scripts execute sequences of shell commands, enabling automation of straightforward tasks like file backups or application launches, though they lack features such as conditional branching or loops found in more robust environments.[53]
The shell integrates with the graphical desktop by providing access through dedicated terminal applications, offering power users a bridge between visual navigation and precise command-driven control.[52] This setup positions the command line as a supplementary tool rather than the primary interface, prioritizing the GUI for most interactions while retaining CLI utility for advanced or embedded scenarios. Limitations include the absence of environment variables, such as PATH, and no support for piping between commands in standard versions, reflecting a design focused on minimalism over Unix-like extensibility.[54][55]