The Linux kernel is the core system software that manages hardware and provides fundamental operating-system services for programs running on systems built around it. It manages processes, CPU scheduling, memory, device drivers, filesystems, networking, security mechanisms and communication between user-space programs and hardware. The kernel operates primarily in a privileged execution mode, commonly called kernel space, while ordinary applications run in user space with restricted privileges.
The Linux kernel is open-source software released under version 2 of the GNU General Public License, and its development involves contributors from around the world, including individuals and companies. It is used in servers, desktops, embedded systems, supercomputers, networking equipment and as the kernel foundation of Android.
Linux began in 1991 when Linus Torvalds developed an initial kernel as a personal project while studying at the University of Helsinki. The project was influenced by Unix and the POSIX ecosystem but was written independently rather than being a derivative of proprietary Unix source code. Early Linux was relatively small and supported limited hardware compared with modern versions. Over decades, the kernel developed into a highly portable and sophisticated system supporting many processor architectures, hardware devices, filesystems, networking technologies and virtualisation features. Torvalds remains the maintainer responsible for the final integration of changes into the mainline kernel, while thousands of other developers contribute code, reviews, testing and subsystem maintenance.
The kernel provides system calls through which user-space software requests operating-system services. Applications can request operations such as opening files, creating processes, allocating memory, communicating over networks and accessing devices through system-call interfaces. Libraries often provide higher-level programming interfaces that eventually invoke system calls, so applications do not normally interact with kernel internals directly. Process isolation prevents ordinary programs from arbitrarily accessing another process's memory or kernel memory. When an application needs privileged functionality, it enters the kernel through controlled mechanisms, the kernel validates the operation and then performs the required action subject to permissions and security policies.
Process and memory management are central kernel responsibilities. The scheduler determines which runnable tasks receive CPU time and supports multiple scheduling classes for different workload requirements. Virtual memory allows each process to operate within an address space that is logically separate from other processes, while the kernel maps virtual addresses to physical memory and manages page allocation and protection. Features such as copy-on-write, memory mapping and demand paging allow efficient use of memory. The kernel also handles process creation, termination, signals, inter-process communication and other execution-management mechanisms. These functions provide the foundation on which shells, servers, graphical environments and other applications operate.
The Linux kernel contains a large collection of device drivers and subsystem implementations. Drivers provide interfaces between the kernel and hardware such as network adapters, storage controllers, USB devices, graphics hardware and input devices. The kernel also implements or integrates filesystems, networking protocols, block-device layers, scheduling mechanisms and other subsystems. Hardware support can be built into the kernel or loaded as modules when needed. This modular architecture allows distributions to provide kernels supporting a wide range of hardware without requiring every driver to be permanently active. The kernel's ability to run on numerous architectures is another reason Linux is widely used beyond conventional PCs.
Networking is a major Linux-kernel capability. The kernel implements TCP/IP and other networking functionality, manages network interfaces and provides sockets through which user-space programs communicate. It can perform routing, packet filtering, traffic control, tunnelling and other network functions. Linux networking facilities are heavily used in servers, routers, firewalls, virtualisation hosts and container platforms. Kernel features such as network namespaces and control groups also provide essential foundations for modern containerisation. The kernel's networking subsystem therefore serves both ordinary applications and infrastructure software that uses Linux as a networking platform.
Security mechanisms in the Linux kernel include traditional Unix permissions, user and group identities, capabilities, namespaces, secure computing filters and other facilities. Linux security modules provide an extensible framework for mandatory access-control systems such as SELinux and AppArmor. Namespaces isolate views of resources and are central to container technologies, while cgroups regulate and account for resource consumption. Kernel security is reinforced by mechanisms such as address-space layout randomisation, executable-memory controls and other hardening features, although exact availability and configuration vary by architecture and distribution. A kernel vulnerability can be particularly serious because the kernel has privileged access to hardware and system memory, which is why timely security updates are important.
The Linux kernel should be distinguished from a Linux distribution and from the Linux operating system as a complete user-facing environment. The kernel is the core privileged component; a distribution adds shells, libraries, utilities, package managers, services, graphical environments and applications. The kernel is also not itself a bootloader or desktop interface, although it participates in the boot process after a bootloader loads it.
Its broad importance derives from its combination of portability, hardware support, open-source development, modular architecture and extensive networking, storage and virtualisation capabilities. Android uses a modified and integrated Linux kernel as part of its platform, while conventional distributions such as Debian, Ubuntu and Fedora build complete operating systems around Linux kernel releases.
