← all systems · see it in The System
Operating system
An operating system (OS) is system software that manages computer hardware and software resources, and provides common services for computer programs; 'the layer of software that manages a computer's resources for its users and their applications' (src:wp:operating-system). It is 'difficult to define' (contention C-1368).
Properties published scienceour proposal
Sourced fields, and our own readings.
| born at | 1950s: 'rudimentary operating systems such as Fortran Monitor System (FMS) and IBSYS' on transistor mainframes; multiprogramming with OS/360 in the 1960s |
| born precision | decade |
| boundary | Inside: the kernel (always running) and the system software around it: device drivers, interrupt handlers, scheduler, memory manager, file system, network stack, protection, the system-call interface, and the shell or graphical interface that starts programs. Outside: the hardware it drives, the application programs it runs, the users, the developers who write it, attackers, and other computers. Where the line falls between OS and system programs is contested (C-1368); the hardware watchdog and the MMU sit on the line. |
| nested level | Built from the kernel and its drivers and managers; sits as the computer's L6 and the software stack's L3; carries applications, shells, network services and agent tools that run on it. |
| scale | technological |
Measures (23) published science
| characteristic clock: load-balancing call (Linux scheduler) | 4 ms |
| characteristic clock: Linux major release | 2-3 months |
| merge window | about 2 weeks |
| stabilisation after rc1 | 6-10 weeks |
| changes per release and per merge-window day | about 13,000 changesets per release; approaching 1,000 per day in the merge window |
| Linux developers over one year | about 2,000 developers |
| average fault lifespan, Linux 2.6 | slightly under 2 (as little as 1 for faults with visible impact) years |
| drivers' share of Linux source | 57 % (since Linux 2.6.29, excluding drivers/staging) |
| driver fault excess (Chou et al. 2001, Linux 1.0-2.4.1) | up to 7 times more of certain kinds of faults than other directories |
| characteristic clock: crashes, UNIX at Bell Labs 1973-74 | about 1 per 2 days |
| UNIX installations by 1974 | about 40 installations |
| UNIX cost (1974) | hardware from $40,000; under two man-years of system software USD; person-years |
| UNIX daily use (1974, one installation) | 1800 commands; 4.3 CPU hours; 75 logins per day |
| Unix size, 1972 and 2015 | 5,000-line kernel (1972); 26 million lines (2015); 659 thousand commits lines of code |
| seL4 kernel size | 8,700 lines of C and 600 of assembler lines of code |
| seL4 proof size | 200,000 lines of Isabelle script |
| one-way IPC cost (ARM11) | seL4 optimised C 224; OKL4 hand-crafted assembly 206; OKL4 non-optimised C 756 cycles |
| scheduler bug cost (Lozi et al.) | 13% higher latency for kernel make; many-fold degradation for synchronization-heavy applications |
| monitoring overhead | sanity checker under 0.5% (10,000 threads); systemtap profiling around 7% |
| operating system shares (web traffic, Nov 2025) | Android 38, Windows 33, iOS/iPadOS 15, macOS 4, Linux 1 (lead section); Windows 31 and macOS 7 in the body % share |
| smallest operating systems | under 10 kilobytes |
| swappiness range | 0-200 (100 = equal IO cost for swap and file paging) dimensionless |
| AIOS agent-serving speed-up | up to 2.1 times faster |
Open contentions (4) open contention
Where sources or readings disagree. Both stay on the map.
- C-1359 Which kind of operating-system core is most secure?
booked: The map records the summary that small cores are more secure, and keeps the large-core, minimal-core and mathematically proven designs alongside.
the other reading: monolithic kernels (most general-purpose OSes, Linux) as practical and 'still vulnerable if any part of the kernel is compromised'; unikernels improving security by minimising the kernel; formal verification (seL4) rather than architecture alone as the route to assurance - C-1367 Does open source make software more secure?
booked: The map keeps both: publishing the code avoids hiding behind secrecy, and open contribution lets people slip in weaknesses on purpose.
the other reading: open contribution lets anyone add code ('There are no restrictions on who can contribute code to open source operating systems'), and known cases exist of programmers 'deliberately implanting vulnerabilities, such as back doors' - C-1368 Where does an operating system end?
booked: The map counts the core plus the system software around it, and keeps the reading that the OS is only the core alongside.
the other reading: the OS is only the kernel, the software 'always running'; middleware 'functions similarly to an operating system' but 'is not a true operating system' - C-1372 Was Meltdown a hardware flaw or an operating-system one?
booked: The map follows its discoverers in placing the cause in the processor, and keeps the operating system's design choice that let it work alongside.
the other reading: the OS's own design choice (kernel memory mapped in every process's address space) as the condition that let it work, since unmapping it (KAISER) impedes the attack; Spectre: 'sound solutions will require fixes to processor designs as well as updates to instruction set architectures'
Cross-scale patterns seen here (25) our proposal
Shapes that recur when the same kind of problem is solved at different scales, and how each shows in Operating system. Each links to every other system that shows it.
- barrier-gates-complexity (structural)
Memory protection and user/kernel mode let many programs share one machine safely. Without the barrier: 'With cooperative memory management, it takes only one misbehaved program to crash the system'; embedded systems that load no user software 'do not need protection between different applications, - borrowed-then-held (structural)
Borrowed: transistor mainframes still needed professional operators 'who manually do what a modern operating system would do, such as scheduling programs to run'. Held: time-sharing and multiprogramming OSes schedule inside the machine ('Time-sharing operating systems schedule tasks for efficient us - holding / entrainment (structural)
The OS sets when its processes are born (fork is the only way after bootstrap), when they run (time slices, preemption), how many there are (init recreates each terminal's process) and when they die (the kernel terminates violators; the OOM killer kills a rogue task). - runaway from an unstable balance (structural)
Thrashing: past the point where main memory holds the working sets, 'each is displacing another's pages in an attempt to have its own pages present', which 'can easily result in a large number of programs stalled'. The balance point (enough memory for the working sets) is named. Interrupt livelock i - same role, different builds (structural)
One job, protecting a program's memory, is done by 'memory segmentation and paging'; access control by UNIX permission bits and set-user-ID or by Windows' access-control lists and security descriptors; and the job of regulating a system's parts by E. coli's transcriptional regulatory network and Lin - seed (structural)
UNIX: 'a carefully selected set of fertile ideas' in a 'five thousand line kernel' (1972) unpacked into 'a widely-used 26 million line system' and a family of incompatible descendants (System V, BSD, Linux, Android's kernel); its pipes let a few commands combine 'in nearly unlimited ways'. - symmetry breaking (name the cut) (structural)
fork makes two identical images ('The two processes have independent copies of the original core image'); the cut is the return value: 'each image existing after a fork may determine whether it is the parent or child process', and from that cut the child goes on to execute a different program. - templating (structural)
One module reused unchanged: the System/360 line 'All of them ran the same operating system—OS/360'; POSIX APIs let one program work on many UNIX systems; device drivers swap in per device so the OS works 'without modification over different hardware'. - The carry (structural)
All three faces. Overflow passed on: memory that does not fit is swapped to disk 'to make that space available for use by other programs'. The wait: a process blocked on I/O sits in the wait queue until the device's interrupt; a feature that misses the merge window waits 'for the next development cy - The Payment to Entropy (structural)
Every hand-off between programs, or between a program and the kernel, pays a toll: mode switches have a 'direct cost' plus 'the indirect pollution of important processor structures (like CPU caches, the instruction pipeline...)'; an interrupt per character costs 'a significant amount of CPU time'; l - the whole sets the local reference (structural)
Each process reads its addresses as its own continuous memory, but the kernel sets what they mean: virtual memory lets it 'use the same memory locations for multiple tasks', and the same address in two processes names different memory, so the local readings do not close into one global frame. The sc - trade one property for another (structural)
Protection is paid for in time: the library OS skips 'the usual overhead of context switches' by giving up separate protection domains; hard real-time systems buy exact timing as 'just a library with no protection'; embedded systems buy simplicity by loading no user software. The kinds of OS spread - Umwelt: each system carves its own slice of one shared medium (structural)
The OS carves its own slice of the shared world: interrupts from its devices, a clock, sensors for 'acceleration, geomagnetic field strength, or angular change' on a phone, temperature in its thermal zones; and 'software-based sensors' derived from those. A server OS and a phone OS on the same kerne - who opens the door (structural)
Every incoming door is a port the kernel opens ahead of time: the interrupt vector table ('The integer is an offset to the interrupt vector table'), drivers' interrupt service routines, device registers set before the write, init opening each terminal line before anyone dials in. Counter-case: Meltd - causal ceiling (partial)
Per-core runqueues bound what each core sees: 'We could have each core check not only its runqueue but also the queues of other cores, but this would defeat the purpose of per-core runqueues', and in the observed bug 'Core 0 only considers its sibling core and cores on the same node'. A limit set by - coordination-before-mapping (partial)
Processes in a pipeline coordinate with no model of each other: 'A read using a pipe file descriptor waits until another process writes'. The kernel itself keeps tables (a map of devices and waiters), so this is the processes' side only. - lightning (partial)
Two discharges: the crash ('an unscheduled system reboot or halt', about one every other day on 1974 UNIX) and the interrupt storm, where interrupt handling runs away until 'the system spends all of its time processing interrupts'. Meltdown's disclosure (3 January 2018) changed what every OS had to - nested ladder (partial)
Real-time guarantees form a ladder: hard real-time requires exact timing, soft real-time accepts 'the occasional missed event'; and seL4's proof is a ladder of refinement, the C implementation proved consistent with the executable and abstract specifications above it. - outside-to-inside (partial)
The machine itself moves inside: 'A hypervisor is an operating system that runs a virtual machine. The virtual machine is an application that emulates hardware'. The outside (real hardware) comes first; the partition between machines becomes one inside a machine. - partner-becomes-part (partial)
Drivers from outside the tree enter through drivers/staging, 'an incubator for new drivers', and are then carried in every release; the TCP/IP stack is now 'usually' included in the OS. Gain/gain and carried on (inheritance by release), but the before-fusion partnership is thinly sourced. - red-queen (partial)
Defenders harden (ASLR, control-flow integrity, verification) and attackers move down to the hardware (Meltdown: 'The root cause of Meltdown is the hardware'); Linux's faults per line fall while the code doubles, and the average fault lifespan stays 'comparable to that observed for previous versions - same shape, opposite sign (partial)
Yan et al. compare one shape, a hierarchical regulatory network: the cell's has 'a few global regulators at the top and many targets at the bottom; conversely, the call graph has many regulators controlling a small set of generic functions'; and in evolution biology 'tightly constrains the evolution - same toolkit, independent builds (partial)
UNIX ideas (fork from Berkeley's time-sharing system, I/O calls and Shell from Multics) rebuilt in new code: MINIX 'inspired' Linux, written fresh with 'UNIX System V syntax'; Windows NT rebuilt VAX/VMS features. Shared ancestry is close (dark twin), so partial. - conservation law plus closure (surface)
The scheduler's interval is a fixed budget ('a fixed time interval during which each thread in the system must run at least once') that predicts nothing until a second rule closes it: 'The interval is divided among threads proportionally to their weights.' Surface: a budget rule, not a physical law. - namespace completeness (the map predicts its gaps) (surface)
Every device gets a name in one namespace ('Each I/O device supported by UNIX is associated with at least one such file', all under /dev). A complete catalogue, but nothing in the structure predicts devices not yet found: surface by the firing rule.
Valence: what it trades, and with whom (31) published science
Each exchange with a neighbour, read from both sides: who gains, who pays, and what carries it.
- Computer memory via sys:electromagnetic-field · Operating system gain
- Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them via sys:electromagnetic-field · Operating system gain
- Central processing unit via sys:electromagnetic-field · Operating system gain
- Thermal energy (heat, temperature and heat flow) via sys:thermal-energy · Operating system loss
- Human (Homo sapiens) via sys:sensory-environment · Operating system gain
- Software via sys:software · Operating system gain
- Internet via sys:electromagnetic-field · Operating system mixed
- Computer via sys:computer-hardware · Operating system gain
- Open-source software via sys:written-record · Operating system gain
- Malware via sys:operating-system · Operating system loss
- Information security via sys:electromagnetic-field · Operating system mixed
- Computer hardware via sys:electromagnetic-field · Operating system gain
- Computer network via sys:electromagnetic-field · Operating system gain
- Programming language via sys:computer-hardware · Operating system gain
- Digital signatures and certificates via sys:written-record · Operating system mixed
- Compiler via sys:computer-hardware · Operating system gain
- Authentication via sys:computer-hardware · Operating system gain
- Access control via sys:computer-hardware · Operating system gain
- Intrusion detection system via sys:written-record · Operating system even
- Incident response via sys:computer-hardware · Operating system gain
- Denial-of-service attack via sys:operating-system · Operating system loss
- Firewall (computing) via sys:computer-hardware · Operating system gain
- Database via sys:computer-hardware · Operating system even
- Cloud computing via sys:computer-hardware · Operating system gain
- Software vulnerability via sys:software · Operating system loss
- Secure software development via sys:software · Operating system even
- Security information and event management (SIEM) via sys:written-record · Operating system mixed
- Digital forensics via sys:computer-hardware · Operating system even
- Vulnerability management via sys:software · Operating system mixed
- Formal security policy model via sys:operating-system · Operating system mixed
- Computer science (the field: the practice and the computation it studies) via sys:sensory-environment · Operating system gain
Partners and parts published science
Built from / builds (15)
- Software
- Computer
- Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them
- Device driver
- Kernel
- Interrupt handling
- Scheduler
- Memory manager and virtual memory
- File system
- Shell / user interface
- System-call interface
- Cloud computing
- Attacking programs against kernel isolation (Meltdown)
- Malware authors against code-signing trust
- Cold-boot readers against disk encryption for keys left in DRAM
Sits inside / holds (3)
expressed by (29)
- Generation/Synthesis
- Recombination/Composition
- Scaffolding/Enablement (Meta-Tooling)
- Templating / Standardization
- Quality Improvement/Refinement
- Interoperability/Transduction (Bridging)
- Encapsulation & Modularity (Abstraction)
- Amplification/Scale-Up (Manufacture & Distribution)
- Evolvability/Plasticity Engineering (Design for Future Variation)
- Distributed Autonomy/Decentralized Execution (Subsidiarity)
- Internal Coordination/Regulation
- Sensing/Scanning
- Mapping/Modeling
- Trail-Marking / Externalized Memory (Stigmergy)
- Surprise / Change-Point Detection
- Quick Harm Avoidance
- Reactive Response
- Proactive Defense
- Physical/Virtual Barrier
- Self-Monitoring
- Validation of Identity/Intention
- Validation of Effectiveness
- Enclave/Segregation
- Resilience & Repair
- Redundancy & Diversity
- Triage & Prioritized Allocation
- Quality Control & Error Correction
- Bridging Supply Gaps (Store & Dormancy)
- Scheduled Build-and-Dismantle (On-Demand Structure)
floor filled by (43)
- Computer memory
- Software
- Internet protocol suite (TCP/IP): the layered datagram protocols every host and router runs, the RFC record that specifies them, and the community that keeps them
- Computer
- Central processing unit
- Human (Homo sapiens)
- Memory protection (role: shell)
- Device driver
- Direct memory access
- Application software
- Processes (programs running)
- Open-source software
- Access control
- Information security
- Kernel
- Interrupt handling
- Scheduler
- Memory manager and virtual memory
- File system
- Shell / user interface
- System-call interface
- Graphical user interface
- Computer hardware
- smartphone sensor
- thermal management
- memory management unit
- Programming language
- Digital signatures and certificates
- Compiler
- Malware
- Authentication
- Intrusion detection system
- Incident response
- Botnet
- Denial-of-service attack
- Database
- Computer network
- Cloud computing
- Software vulnerability
- Secure software development
- Security information and event management (SIEM)
- Digital forensics
- Formal security policy model
Kinds (19)
- Software
- Time-sharing OS
- Multicomputer OS
- Distributed system (and middleware)
- Embedded OS
- Real-time OS (hard and soft)
- Hypervisor
- Library OS (unikernel)
- Mobile OS
- Hobby OS
- LLM agent operating system (AIOS)
- UNIX
- Linux
- Microsoft Windows
- macOS
- MINIX
- OS/360
- CP/M
- MS-DOS
wired (4)
Notes published science
- In 1965 Gordon Moore wrote that if you shrank a computer down to just its components, 'we would expect it to glow brightly' (src:moore-1965). Today's chips carry a thermostat: a thermal sensor trips, the operating system steps in, and the chip slows itself until it cools (src:brooks-martonosi-2001-dtm).
- In 1970 the US Defense Science Board's task force concluded that the technology of the day could not build a secure computer for 'an open environment' at all; the only safe computer was one walled off with cleared users in a guarded room. Two years later the Anderson study moved that wall inside the machine, as a 'reference monitor' checking every single access, the design idea still under today's operating systems (src:ware-1970, src:anderson-1972).
- Biologists have long called the genome 'the operating system for a living organism', and when Yale researchers compared E. coli's gene-control network with Linux's call graph, they found the same layered shape upside down: the cell has a few master regulators over many targets, while Linux has many controllers leaning on a small set of shared generic functions (src:yan-2010).
- For about a decade the Linux scheduler had bugs that left processor cores sitting idle 'for seconds while ready threads are waiting', though Linus Torvalds had said in 2001 that scheduling 'is easy'; the bugs caused many-fold slowdowns for some scientific programs (src:lozi-2016).
- Unix began in 1972 as a five-thousand-line kernel and had grown by 2015 into a 26-million-line system with 659 thousand recorded changes, while the formally verified seL4 kernel is only 8,700 lines of C, backed by 200,000 lines of proof (src:spinellis-2015, src:klein-2009).
Layers
The ways it takes in its world, where they meet, and how it acts back, each from L1 (where it meets the world) up.
development: the kernel as written, merged, released and passed on (Linux, with Unix before it)
- L1: Patches (changesets): source changes written by developers
- L2: Collected, tested and staged ahead of time; immature drivers incubated in drivers/staging
- L3: The merge window: about two weeks in which stable code enters the mainline
- L4: Stabilisation: release candidates, fixes only
- L5: The release: a new major kernel every two or three months
- L6: Passed on: derivatives and distributions built on the released code (Unix's descendants, thousands of Linux distributions)
- L7: The developer community and its processes
the boardroom (shared floors)
- L4: Resource managers: the CPU scheduler and load balancer, the memory manager, the file system, the network stack, the thermal and sensor frameworks
- L5: Protection and isolation: user and kernel mode, memory protection, access control, security domains
- L6: Services and abstractions: processes, threads, files, sockets, virtual memory, reached through system calls
- L7: The users and applications served: the shell and graphical interface, and the programs people run
the operating system as OS designers describe it: the hardware up to the users and applications it serves (reader's view)
- L1: The hardware the operating system drives: processor time, memory, input/output devices (disks, network cards, keyboards, screens), clocks and sensors
- L2: Device drivers and interrupt handlers: the ports where hardware events arrive
- L3: The kernel's mechanisms: traps and interrupt dispatch, saving and restoring state, context switches, user mode and kernel mode
- L4: Resource managers: the CPU scheduler, the memory manager and virtual memory, the file system, the network stack, thermal and sensor frameworks
- L5: Protection and isolation: memory protection, access control, security domains (kernel, processes, virtual machines)
- L6: Services and abstractions offered: processes and threads, files and directories, sockets, virtual memory, reached through system calls
- L7: The users and applications served: shells, command lines and graphical interfaces, and the programs they start
virtual memory: pages between physical memory and disk (the memory manager's stack)
- L1: Physical memory shared by programs that time-share
- L2: Paging and segmentation hardware (the memory management unit) and its protected-mode registers
- L3: The page fault: an access to allocated but absent memory interrupts the kernel
- L4: The working set: each process's most recently used pages, the basis for deciding what stays in memory
- L5: Swapping: less used memory moved to disk to make room for other programs
- L6: The illusion offered: a memory larger than the machine has
way in: Device sensors: motion, environment, position (mobile operating systems)
- L1: Forces, fields and the ambient environment acting on the device
- L2: Hardware-based sensors built into the handset
- L3: The sensor framework, including software-based sensors derived from the hardware ones
way in: Faults and exceptions from the processor (page faults, protection violations, illegal instructions)
- L1: The running program divides by zero, executes a malformed instruction or touches an invalid address
- L2: Protected-mode registers tell the processor which addresses the program may touch
- L3: The violation interrupts into supervisor mode, putting the kernel in charge
- L4: The memory manager adjusts the program's virtual memory range (a page fault served)
way in: Hardware watchdog timer
- L1: A hardware countdown that resets the machine unless pinged
way in: Network packets
- L1: Messages sent and received between computers (in a multicomputer, between CPUs)
- L2: Network traffic arrives as interrupts
- L3: The kernel's network stack (TCP/IP)
way in: Storage: disk and flash blocks arriving by direct memory access
- L1: Data held on magnetic disks or flash memory
- L2: A DMA controller moves the data without the processor, one interrupt at the end
- L3: The handler reads the device's number from the data bus to find the waiting process
way in: System calls: requests from running programs
- L1: Application code runs directly on the hardware and asks the OS for services
- L2: A software interrupt instruction enters the kernel through the interrupt vector table
- L3: The kernel saves the caller's registers in its process control block
- L4: The resource manager does the work (files created, read, written) on the program's behalf
- L5: Every access checked for authority
way in: Temperature (thermal zones)
- L1: The temperature of a thermal zone and its trend
- L2: Thermal zone devices (sensors) registered with the thermal management
- L3: Polled at a set delay
way in: The kernel's own state: runqueues, working sets, memory pressure
- L1: Runqueues held as red-black trees, page tables, the task list
- L2: Readings of use: each process's most recently used pages
- L3: Loads compared across cores
way in: The scheduling clock (timer interrupts)
- L1: The scheduling-clock tick
- L2: The timer interrupt arrives; ticks can be omitted on idle CPUs
- L3: The expected time slice ends and the kernel switches context
way in: Updates: patches and new releases from developers
- L1: Patches written by developers
- L2: Merged into the mainline in the merge window
- L3: Fixes only while the release stabilises
- L4: Released and deployed (e.g. KAISER against Meltdown)
way in: User input: keyboard, mouse, trackpad, touchscreen
- L1: A person presses a key, moves a mouse or touches a screen
- L2: Each keystroke or mouse movement raises an interrupt
- L3: Control passes to the interrupt service routine, the running process's state is saved
way in: Users' names and passwords (login)
- L1: A user's name and password
- L2: Typed at a terminal that init opened
- L3: Each user mapped to a unique user identification number
- L4: Every process carries an authentication token, every object a security descriptor
way out: Commands to devices (disk writes, device registers, DMA)
- L1: The machine instruction that starts the write
- L2: Buffer address and size placed in device registers
- L4: The device-status table records which process waits on which device
- L6: A block write requested by a system call
way out: Cooling and energy: fans and processor throttling, fewer clock ticks on idle CPUs
- L1: Cooling devices: the fan and the processor itself
- L3: Fewer scheduling-clock interrupts on idle CPUs
- L4: A trip point crossed: the critical or hot handler runs
way out: Create a process (fork, load, start)
- L1: Two independently executing copies with their own core images
- L4: Memory and priority assigned, the binary loaded
- L6: fork: the only way a new process comes into existence (after bootstrap)
way out: Messages to other computers (remote procedure calls)
- L1: Messages sent, with as little packet copying as possible
- L6: Remote procedure calls and distributed shared memory
way out: Panic, crash, reboot
- L1: An unscheduled reboot or halt
- L5: Panic on out-of-memory, if so set
way out: Run a program on the processor (dispatch)
- L1: The processor executes the program's own instructions directly
- L3: Context switch: the running thread's state saved, the next one's loaded
- L4: The scheduler picks the next thread to run
way out: Screen output: command line and graphical interface
- L1: The typed character or the moved cursor appears on the screen
- L7: Command-line or graphical interface (windows, icons, menus, pointer)
way out: Terminate or kill a process (protection faults, out-of-memory, signals)
- L1: The program ceases execution
- L3: A signal sent to the process
- L4: Out of memory: the OOM killer picks a task to kill
- L5: The offending program terminated and the error reported
way out: Watchdog ping from user space
- L1: Data written to the watchdog device
- L7: A user-space daemon tells the watchdog all is well