Table of Contents
    Home / Definitions / Kernel

    The kernel is the central module of an operating system (OS) responsible for memory management, process and task management, and disk management.

    What does the kernel do?

    It is the part of the operating system that loads first, and it remains in main memory. Because it stays in memory, it is important for the kernel to be as small as possible while still providing all the essential services required by other parts of the operating system and applications. The kernel’s code is usually loaded into a protected area of memory to prevent it from being overwritten by programs or other parts of the operating system. Kernels connect the system hardware to the application software. Every operating system has a kernel. For example, the Linux kernel is used by numerous operating systems including Linux, FreeBSD, Android, and others.

    What are the kernel’s functions in an operating system?

    Establish Communication Between User & Hardware

    Because kernels run in privileged mode, it’s able to communicate with the hardware directly. It acts as a bridge between applications and data processing executed at the hardware level using system calls and inter-process communication.

    Kernels also allow interaction of user and device drivers with hardware and virtual devices like folders and files.

    Decide State of Incoming Processes

    The kernel controls processes by suspending the execution of the process running on the CPU and executing another process. Each process is represented by a process descriptor describing its current state. When the kernel halts process execution, it saves the contents of processor registers in the process descriptor.

    Disk Management

    The kernel manages disk space. It tracks the usage of specific files on the hard disk and cache memory. It’s in charge of the allocation of physical storage space in computer systems with a hard disk drive.

    Disk management includes important tasks such as creating and deleting partitions, adding or removing storage devices, making file system partitions, and mounting partitions on appropriate directories.

    Memory Management

    Every process—and the kernel itself—needs some memory space. The kernel allocates and deallocates memory for process execution. The performance of the entire system relies on how efficiently dynamic memory is managed.

    In order to conclude memory mapping, the kernel keeps a page table for each process. The table records the mapping relationship between physical address and virtual memory address and is stored in a CPU’s Memory Management Unit (MMU).

    Task Management

    The kernel’s Task Manager runs tasks in the background. It monitors a system, constantly looking for tasks requested by foreground jobs. The Linux kernel stores a list of processes in a list called The Task List. Each component in the list is a process descriptor defined in <linux/sched. h>. The file contains all the information about a specific process.

    The kernel’s history & development

    In the 1950s and early 1960s, before the operating system (and kernel) were developed, programs were directly loaded and executed on the “bare metal” machine (on logic hardware without an intervening operating system). Computers would be reset and reloaded between the execution of different programs.

    Later on, program authors started leaving small ancillary programs like program loaders and debuggers in memory between runs or loaded them from ROM. These led to the development of early operating system kernels.

    In 1969, an operating system was developed for the RC 4000 minicomputer–the RC 4000 Multiprogramming System. It introduced a small nucleus upon which an operating system could be built.

    Time-Sharing Operating System

    The Time-Sharing Operating System (TSOS) is an obsolete OS developed by the Radio Corporation of America. It was designed for the Spectra 70 series mainframe computers. TSOS was specifically built for the Spectra 70/46 and soon morphed into the Virtual Memory Operating System.


    AmigaOS is a family of proprietary native operating systems designed for the Amiga and AmigaOne PCs. The OS was originally developed in 1985 by Commodore International and introduced during the launch of the Amiga 1000.


    This operating system was first developed in the 1960s and has been in constant development since. The term Unix now refers to a family of multi-user computer operating systems that are based on the original AT&T Unix. The GNU Mach microkernel, a replacement for the Unix kernel, has been under development since 1990 and is offered as free software under the GNU General Public License.

    Mac OS

    macOS is a Unix-like operating system developed by Apple Inc. in 1984. It has been the primary operating system for Apple’s Mac computers since 2001. The Mac OS 8.6. released in 1999, had a nanokernel design. The modern macOS uses a hybrid kernel called XNU.


    The first version of Windows was developed by Microsoft Corporation in 1985 and was an extension of its existing disk operating system (MS-DOS). It featured the first graphical user interface and dominated the PC market for many years.

    Microsoft’s first multi-architecture operating system, Windows NT, was released in 1993 but was initially designed for high-end and business users. It was introduced to general users in Windows XP (2001) and is still in use today in Windows 11. The OS uses a hybrid kernel which comprises a kernel, hardware abstraction layer, drivers, and services collectively named Executive.

    Types of Kernels


    In monolithic kernels, all OS services run in the kernel space. The operating system software framework holds all privileges to memory, access input/output (I/O) devices, the CPU stack, and hardware interrupts. Because kernel services and user services are implemented in the same memory space, the Kernel and OS are larger and processes are executed faster.

    With monolithic kernels, there are dependencies between system components. The kernel provides memory management, file management, CPU scheduling, and other operating system functions through system calls. Examples of the monolithic kernel are Linux, Microsoft Windows, BSD (NetBSD, OpenBSD, FreeBSD), OpenVMS, DOS, and Solaris.


    In a microkernel, the kernel services and user services are implemented in different address spaces. Kernel services are kept in the kernel address space, while user services are kept in the user address space. This helps reduce the size of the kernel and the operating system.

    A microkernel provides minimal process and memory management services. The interaction between services running in the user address space and the client application is established through message passing. This reduces the speed of microkernel execution.

    Because the kernel and user services are isolated, the OS is unaffected. If user services fail, kernel services are unaffected. The kernel is also extendable. New services are added to the user address space and not to the kernel space. It’s also secure, lightweight, and reliable.

    Microkernels are typically implemented in C++ or C languages with little assembly. They can also be used in other programming languages with some high-level code. Examples of microkernel-based OSs include Mac OS X.


    This kernel combines microkernel and monolithic kernel architectures. It merges the modularity and execution safety of a microkernel with the speed and simpler design of a monolithic kernel. Unlike in a microkernel, all (or almost all) operating system services in a hybrid kernel are in kernel space. There are no performance benefits of having services in user space, as in microkernels.

    Hybrid kernels may keep the bus controllers and virtual files system inside the kernel and the storage drivers and file system drivers outside the kernel (as user mode programs). This design retains the design principles and performance of a monolithic kernels. Well-known examples of a hybrid kernel include the Microsoft NT kernel and the XNU kernel used in macOS.


    A nanokernel offers hardware abstraction but without system services. Larger nanokernels have more features and manage more hardware abstraction. Modern microkernels also lack system services, so the terms nanokernel and microkernel are at times used interchangeably.

    In a nanokernel, the total volume of code is quite small. A hardware abstraction layer forms the kernel’s lowest level, while a virtualization layer (a hypervisor) is located beneath the operating system. One good example of a nanokernel is EROS, the high-performance capability system that runs on commodity processors and hardware.


    This is an operating system that was developed at MIT that offers application-level management of hardware resources. It separates resource management from protection to facilitate application-specific customization.

    App developers using exokernels have the freedom to use abstractions as and when needed. There is no forced abstraction, and this is what makes exokernels different from monolithic and microkernels.

    The kernel’s responsible for allocating the machine’s basic physical resources (memory, processor time, and disk blocks) to multiple application programs. Each program then decides what to do with these resources.

    What Is a Kernel Security Check Failure?

    Kernel Security Check Failure is an error message displayed by Windows 10 when some data files are corrupted. The main cause may be incompatible settings, virus and malware infections, incorrect Registry changes, or memory issues.

    This definition was reviewed and updated in April 2022 by Alice Musyoka.