a monolithic kernel
The kernel is the one program that the operating system trusts completely: it runs underneath all your applications, controls the hardware directly, and decides who is allowed to do what. A monolithic kernel is the design where almost everything the operating system does - managing memory, scheduling processes, talking to disks and network cards, implementing the filesystem - lives inside that one big trusted program, all running together in the same privileged address space. Picture a single large workshop where every specialist works at the same bench, freely handing tools to one another.
Concretely, in a monolithic kernel a request flows through ordinary function calls. When your program reads a file, it makes a system call that lands in the kernel; the kernel's filesystem code calls the kernel's block-device code, which calls the kernel's disk-driver code - all of these are functions in the same binary, sharing one set of data structures, with no boundary crossings between them. Linux is the famous example: the scheduler, the virtual memory system, the TCP/IP stack, and most drivers are all compiled into (or loaded into) one kernel that runs in the CPU's privileged mode. Linux softens the 'one giant binary' image with loadable modules, which add or remove code at runtime, but a loaded module still runs in the same trusted kernel space as everything else.
The trade-off is the whole point. Because all the parts share an address space and call each other directly, a monolithic kernel is fast - no message passing, no context switches between subsystems. The price is fragility of trust: a single bug in any driver or subsystem runs with full privilege and can corrupt unrelated kernel data, crash the whole machine, or be a security hole. This is the central tension the microkernel design tries to escape, and it is why 'monolithic versus microkernel' is one of the oldest debates in operating systems.
read(fd, buf, n) -> [kernel] sys_read() -> vfs_read() -> ext4_file_read_iter() -> block layer -> nvme_driver -- all plain function calls inside one privileged binary, no boundary crossings.
In a monolithic kernel one file read threads through filesystem, block, and driver code as direct calls, all in the same trusted address space.
Monolithic does not mean 'cannot be modular.' Linux is monolithic yet highly modular via loadable kernel modules - but a loaded module still runs with full kernel privilege in kernel space, so modularity here is about organization and runtime loading, not about isolation or a trust boundary.