EVOPEDIA

← 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 at1950s: 'rudimentary operating systems such as Fortran Monitor System (FMS) and IBSYS' on transistor mainframes; multiprogramming with OS/360 in the 1960s
born precisiondecade
boundaryInside: 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 levelBuilt 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.
scaletechnological

Measures (23) published science

characteristic clock: load-balancing call (Linux scheduler)4 ms
characteristic clock: Linux major release2-3 months
merge windowabout 2 weeks
stabilisation after rc16-10 weeks
changes per release and per merge-window dayabout 13,000 changesets per release; approaching 1,000 per day in the merge window
Linux developers over one yearabout 2,000 developers
average fault lifespan, Linux 2.6slightly under 2 (as little as 1 for faults with visible impact) years
drivers' share of Linux source57 % (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-74about 1 per 2 days
UNIX installations by 1974about 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 20155,000-line kernel (1972); 26 million lines (2015); 659 thousand commits lines of code
seL4 kernel size8,700 lines of C and 600 of assembler lines of code
seL4 proof size200,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 overheadsanity 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 systemsunder 10 kilobytes
swappiness range0-200 (100 = equal IO cost for swap and file paging) dimensionless
AIOS agent-serving speed-upup to 2.1 times faster

Open contentions (4) open contention

Where sources or readings disagree. Both stay on the map.

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.

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.

Partners and parts published science

Built from / builds (15)

Sits inside / holds (3)

expressed by (29)

floor filled by (43)

Kinds (19)

wired (4)

Notes published science

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)

  1. L1: Patches (changesets): source changes written by developers
  2. L2: Collected, tested and staged ahead of time; immature drivers incubated in drivers/staging
  3. L3: The merge window: about two weeks in which stable code enters the mainline
  4. L4: Stabilisation: release candidates, fixes only
  5. L5: The release: a new major kernel every two or three months
  6. L6: Passed on: derivatives and distributions built on the released code (Unix's descendants, thousands of Linux distributions)
  7. L7: The developer community and its processes

the boardroom (shared floors)

  1. L4: Resource managers: the CPU scheduler and load balancer, the memory manager, the file system, the network stack, the thermal and sensor frameworks
  2. L5: Protection and isolation: user and kernel mode, memory protection, access control, security domains
  3. L6: Services and abstractions: processes, threads, files, sockets, virtual memory, reached through system calls
  4. 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)

  1. L1: The hardware the operating system drives: processor time, memory, input/output devices (disks, network cards, keyboards, screens), clocks and sensors
  2. L2: Device drivers and interrupt handlers: the ports where hardware events arrive
  3. L3: The kernel's mechanisms: traps and interrupt dispatch, saving and restoring state, context switches, user mode and kernel mode
  4. L4: Resource managers: the CPU scheduler, the memory manager and virtual memory, the file system, the network stack, thermal and sensor frameworks
  5. L5: Protection and isolation: memory protection, access control, security domains (kernel, processes, virtual machines)
  6. L6: Services and abstractions offered: processes and threads, files and directories, sockets, virtual memory, reached through system calls
  7. 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)

  1. L1: Physical memory shared by programs that time-share
  2. L2: Paging and segmentation hardware (the memory management unit) and its protected-mode registers
  3. L3: The page fault: an access to allocated but absent memory interrupts the kernel
  4. L4: The working set: each process's most recently used pages, the basis for deciding what stays in memory
  5. L5: Swapping: less used memory moved to disk to make room for other programs
  6. L6: The illusion offered: a memory larger than the machine has

way in: Device sensors: motion, environment, position (mobile operating systems)

  1. L1: Forces, fields and the ambient environment acting on the device
  2. L2: Hardware-based sensors built into the handset
  3. 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)

  1. L1: The running program divides by zero, executes a malformed instruction or touches an invalid address
  2. L2: Protected-mode registers tell the processor which addresses the program may touch
  3. L3: The violation interrupts into supervisor mode, putting the kernel in charge
  4. L4: The memory manager adjusts the program's virtual memory range (a page fault served)

way in: Hardware watchdog timer

  1. L1: A hardware countdown that resets the machine unless pinged

way in: Network packets

  1. L1: Messages sent and received between computers (in a multicomputer, between CPUs)
  2. L2: Network traffic arrives as interrupts
  3. L3: The kernel's network stack (TCP/IP)

way in: Storage: disk and flash blocks arriving by direct memory access

  1. L1: Data held on magnetic disks or flash memory
  2. L2: A DMA controller moves the data without the processor, one interrupt at the end
  3. 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

  1. L1: Application code runs directly on the hardware and asks the OS for services
  2. L2: A software interrupt instruction enters the kernel through the interrupt vector table
  3. L3: The kernel saves the caller's registers in its process control block
  4. L4: The resource manager does the work (files created, read, written) on the program's behalf
  5. L5: Every access checked for authority

way in: Temperature (thermal zones)

  1. L1: The temperature of a thermal zone and its trend
  2. L2: Thermal zone devices (sensors) registered with the thermal management
  3. L3: Polled at a set delay

way in: The kernel's own state: runqueues, working sets, memory pressure

  1. L1: Runqueues held as red-black trees, page tables, the task list
  2. L2: Readings of use: each process's most recently used pages
  3. L3: Loads compared across cores

way in: The scheduling clock (timer interrupts)

  1. L1: The scheduling-clock tick
  2. L2: The timer interrupt arrives; ticks can be omitted on idle CPUs
  3. L3: The expected time slice ends and the kernel switches context

way in: Updates: patches and new releases from developers

  1. L1: Patches written by developers
  2. L2: Merged into the mainline in the merge window
  3. L3: Fixes only while the release stabilises
  4. L4: Released and deployed (e.g. KAISER against Meltdown)

way in: User input: keyboard, mouse, trackpad, touchscreen

  1. L1: A person presses a key, moves a mouse or touches a screen
  2. L2: Each keystroke or mouse movement raises an interrupt
  3. L3: Control passes to the interrupt service routine, the running process's state is saved

way in: Users' names and passwords (login)

  1. L1: A user's name and password
  2. L2: Typed at a terminal that init opened
  3. L3: Each user mapped to a unique user identification number
  4. L4: Every process carries an authentication token, every object a security descriptor

way out: Commands to devices (disk writes, device registers, DMA)

  1. L1: The machine instruction that starts the write
  2. L2: Buffer address and size placed in device registers
  3. L4: The device-status table records which process waits on which device
  4. L6: A block write requested by a system call

way out: Cooling and energy: fans and processor throttling, fewer clock ticks on idle CPUs

  1. L1: Cooling devices: the fan and the processor itself
  2. L3: Fewer scheduling-clock interrupts on idle CPUs
  3. L4: A trip point crossed: the critical or hot handler runs

way out: Create a process (fork, load, start)

  1. L1: Two independently executing copies with their own core images
  2. L4: Memory and priority assigned, the binary loaded
  3. L6: fork: the only way a new process comes into existence (after bootstrap)

way out: Messages to other computers (remote procedure calls)

  1. L1: Messages sent, with as little packet copying as possible
  2. L6: Remote procedure calls and distributed shared memory

way out: Panic, crash, reboot

  1. L1: An unscheduled reboot or halt
  2. L5: Panic on out-of-memory, if so set

way out: Run a program on the processor (dispatch)

  1. L1: The processor executes the program's own instructions directly
  2. L3: Context switch: the running thread's state saved, the next one's loaded
  3. L4: The scheduler picks the next thread to run

way out: Screen output: command line and graphical interface

  1. L1: The typed character or the moved cursor appears on the screen
  2. L7: Command-line or graphical interface (windows, icons, menus, pointer)

way out: Terminate or kill a process (protection faults, out-of-memory, signals)

  1. L1: The program ceases execution
  2. L3: A signal sent to the process
  3. L4: Out of memory: the OOM killer picks a task to kill
  4. L5: The offending program terminated and the error reported

way out: Watchdog ping from user space

  1. L1: Data written to the watchdog device
  2. L7: A user-space daemon tells the watchdog all is well

Sources (44) published science

Wikipedia: Operating system
Password (Wikipedia, via Wikimedia Enterprise) (behind its links)
Lozi, Lepers, Funston, Gaud, Quéma & Fedorova 2016, The Linux Scheduler: a Decade of Wasted Cores, EuroSys '16 doi:10.1145/2901318.2901326 (behind its links)
The Linux Kernel documentation: How the development process works (behind its links)
Palix, Saha, Thomas, Calvès, Lawall & Muller 2010/2011, Faults in Linux: Ten Years Later, INRIA RR-7357 (HAL inria-00509256) (behind its links)
Ritchie & Thompson 1974, The UNIX Time-Sharing System, Communications of the ACM 17(7) (electronic version by E. Brewer) doi:10.1145/361011.361061 (behind its links)
Spinellis 2015, A Repository with 44 Years of Unix Evolution, MSR '15 doi:10.1109/MSR.2015.6 (author's HTML draft) (behind its links)
Klein et al. 2009, seL4: Formal Verification of an OS Kernel, SOSP '09 doi:10.1145/1629575.1629596 (behind its links)
The Linux Kernel documentation: Documentation for /proc/sys/vm/ (behind its links)
Mei et al. 2024, AIOS: LLM Agent Operating System, arXiv:2403.16971 (behind its links)
Denning 1968, The Working Set Model for Program Behavior, Communications of the ACM 11(5) doi:10.1145/363095.363141 (behind its links)
The Linux Kernel documentation: Generic Thermal Sysfs driver How To (behind its links)
The Linux Kernel documentation: The Linux Watchdog driver API (behind its links)
Wikipedia: Interrupt (behind its links)
Lipp et al. 2018, Meltdown, arXiv:1801.01207 (behind its links)
Software (encyclopedia) (behind its links)
Cloud computing (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01; page flagged 'AI-generated' additions 2025-26) (behind its links)
Android Developers: Sensors overview (behind its links)
Virtual memory (Wikipedia, WME) (behind its links)
Akhshabi, S. & Dovrolis, C. The Evolution of Layered Protocol Stacks Leads to an Hourglass-Shaped Architecture (extended version of the ACM SIGCOMM 2011 paper; read via fetch summary) (behind its links)
Wikipedia: Central processing unit (behind its links)
Programming language (Wikipedia via Wikimedia Enterprise, cached research/showcase/cache/wme) (behind its links)
Code signing (Wikipedia) (behind its links)
Compiler (Wikipedia, rev 1373605841, 2026-09-06, via Wikimedia Enterprise) (behind its links)
Malware (Wikipedia, via Wikimedia Enterprise snapshot) (behind its links)
Mandatory access control (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Denning, An Intrusion-Detection Model, IEEE Transactions on Software Engineering SE-13(2), 1987 (doi:10.1109/TSE.1987.232894) (behind its links)
Cichonski P, Millar T, Grance T, Scarfone K (2012) Computer Security Incident Handling Guide. NIST Special Publication 800-61 Rev. 2. doi:10.6028/NIST.SP.800-61r2 (US government work, not subject to copyright) (behind its links)
Handley, Rescorla (eds.), IAB 2006, RFC 4732: Internet Denial-of-Service Considerations (doi:10.17487/RFC4732) (behind its links)
Anderson JP (1972) Computer Security Technology Planning Study, Vol. I (ESD-TR-73-51) (behind its links)
Computer hardware (Wikipedia, via Wikimedia Enterprise snapshot) (behind its links)
Scarfone K, Hoffman P. Guidelines on Firewalls and Firewall Policy. NIST Special Publication 800-41 Revision 1, 2009 (doi:10.6028/NIST.SP.800-41r1) (behind its links)
Database (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
Peterson & Davie, Computer Networks: A Systems Approach (CC BY 4.0), §1.3 Architecture (behind its links)
Vulnerability (computer security) (Wikipedia, via Wikimedia Enterprise snapshot) (behind its links)
Saltzer and Schroeder, The Protection of Information in Computer Systems, Proceedings of the IEEE 63(9), 1975 (doi:10.1109/PROC.1975.9939) (behind its links)
Uetz, R., Herzog, M., Hackländer, L., Schwarz, S. & Henze, M. (2023). You Cannot Escape Me: Detecting Evasions of SIEM Rules in Enterprise Networks. arXiv:2311.10197 (its artifact note points to USENIX Security 2024) (behind its links)
Lyle JR, Guttman B, Butler JM, Sauerwein K, Reed C, Lloyd CE (2022) Digital Investigation Techniques: A NIST Scientific Foundation Review. NIST IR 8354. doi:10.6028/NIST.IR.8354 (behind its links)
Souppaya M, Scarfone K. Guide to enterprise patch management planning: preventive maintenance for technology. NIST SP 800-40 Rev. 4, 2022 (doi:10.6028/NIST.SP.800-40r4) (behind its links)
Bell DE (2005). Looking Back at the Bell-La Padula Model. Proceedings of the 21st Annual Computer Security Applications Conference, 337-351. doi:10.1109/CSAC.2005.37 (behind its links)
Computer science (Wikipedia, via Wikimedia Enterprise snapshot 2026-11-01) (behind its links)
The Linux Kernel documentation: NO_HZ: Reducing Scheduling-Clock Ticks (behind its links)
Yan, Fang, Bhardwaj, Alexander & Gerstein 2010, Comparing genomes to computer operating systems in terms of the topology and evolution of their regulatory control networks, PNAS 107(20) doi:10.1073/pnas.0914771107 (PMC2889091) (behind its links)
Jia, Wang, Song & Chen 2024, Agent Centric Operating System: a Comprehensive Review and Outlook for Operating System, arXiv:2411.17710 (behind its links)