The MIT Exo kernel [28, , ] is an extreme approach to operating systems design. It attempts to lower the operating system interface to the hardware level, eliminating all abstractions that traditional operating systems provide, and concentrating on multiplexing the available physical resources.
All work traditionally done inside the kernel to provide abstractions, such as memory mapped I/O and complex thread packages, is moved into application-level software layers. The kernel simply allocates, deallocates, and multiplexes physical resources, for example memory, time-slices, access to I/O devices, disk storage, etc. This is similar to the Puma kernel approach, where many of the abstractions are pushed into the PCT (Process Control Thread) or user-level libraries. The Exo kernel takes this to an extreme, since all abstractions are removed from the kernel and no privileged user-level processes, such as the PCT, are allowed; every abstraction is provided by the application (usually in the form of a library). This allows applications to customize abstractions, choose the best fitting one among several, or circumvent libraries that are not efficient enough for the task at hand.
In principle, there should be fewer traps into the kernel, since most of the OS functionality is at the user-level. The traps should also be cheaper, since there are fewer services to dispatch inside the kernel. For cases such as TLB miss handling, user-level code can be inserted into the kernel. A combination of code inspection and sandboxing is used to insert untrusted user code safely into the kernel.