Academic Operating Systems

• Aegis/Exo-kernel (Massachusetts Institute of Technology)
  Group Members: Frans Kaashoek, Dawson Engler
  The Aegis kernel is built around the idea of an exo-kernel. An evolution from micro-kernels, exo-kernels export a virtual machine that securely multiplexes resourses among mutually distrusting spplications. The exo-kernel philosophy tries to export as few abstractions besides the basic hardware abstractions as possible, and to implement as little policy in the kernel as possible. Like SPIN, Aegis relies on techniques such as downloading code into the kernel to make the system fast.
• Alpha Kernel (Carnegie Mellon University) Group Members
• Amoeba (Vrije Universiteit)
  Amoeba is a powerful micro-kernel-based system that turns a collection of workstations or single-board computers into a transparent distributed system. It has been in use in academia, industry, and government for about 5 years.
• Angel (City University of London)
  Angel is designed as a generic parallel and distributed operating system, although it is currently targeted towards a high-speed network of PCs. This model of computing has the dual advantage of both a cheap initial cost and also a low incremental cost. By treating a network of nodes as a single shared memory machine, using distributed virtual shared memory (DVSM) techniques, we have addressed both the needs for improved performance and provided a more portable and useful platform for our applications.
• Cache kernel (Stanford University Distributed Systems Group)
  Group Members: David Cheriton, Kenneth Duda
  The supervisor-mode component of the V++ operating system. The Cache Kernel caches operating system objects such as threads and address spaces just as conventional hardware caches memory data. User-mode application kernels handle the loading and write-back of these objects, implementing application-specific management policies and mechanisms.
• Chimera (Carnegie Mellon University)
  The Advanced Manipulators Laboratory, at Carnegie Mellon University, has developed the Chimera Real-Time Operating System, a next generation multiprocessor real-time operating system (RTOS) designed especially to support the development of dynamically reconfigurable software for robotic and automation systems. Version 3.0 and later of the software is already being used by several institutions outside of Carnegie Mellon, including university, government, and industrial research labs.
• Choices (University of Illinois, Urbana-Champaign)
  Choices is written as an object-oriented operating system in C++. As an object-oriented operating system, its architecture is organized into frameworks of objects that are hierarchically classified by function and performance. The operating system is customized by replacing subframeworks and objects. The application interface is a collection of kernel objects exported through the application/kernel protection layer. Kernel and application objects are examined through application browsers
• COSY (University of Karlsruhe, University of Paderborn)
  Group Members: Wolfgang Burke, Roger Butenuth, Sven Gilles
  Cosy is an operating system for highly parallel computers, with hundreds or thousands of processors. All parts of the system are designed to scale up with the number of processors, without any one becoming a bottleneck.
• EROS (University of Pennsylvania) Group Members
  EROS (Extremely Reliable Operating System) is a new operating system being implemented at the University of Pennsylvania. The system merges some very old ideas in operating systems with some newer ideas about scheduling and performance. The result is a small, secure, high-performance operating system that provides transparent orthogonal persistence coupled with microkernel-style critical paths, including a high performance IPC subsystem.
• Flux (University of Utah) Group Members
  The Flux Project's objective is to develop a nanokernel-based decomposed operating system that achieves high performance while retaining inter-component protection and rich functionality. Such a system will overcome the performance/protection and performance/functionality tradeoffs that thwart traditional micro-kernel-based operating systems. This objective includes integration of selected research results of others, and free distribution of an unencumbered and usable version of the entire system.
• Fox (Carnegie Mellon University) Group Members
  The objective of the Fox Project is to advance the art of programming-language design and implementation, and simultaneously to apply principles of programming languages to advance the art of systems building. The starting point for the work on language design and implementation is the Standard ML programming language.
• GLUnix (University of California, Berkeley)
  Group Members: Thomaas Anderson, Doug Ghormley, David Petrou, et al.
  Currently, modern workstation operating systems do not provide support for efficient distributed program execution in an environment shared with sequential applications. The goal of our research is to pool resources in a NOW to provide better performance for both parallel and sequential applications. To realize this goal, the operating system must support gang-scheduling of parallel programs, identify idle resources in the network, allow for process migration to support dynamic load balancing, and provide support for fast inter-process communication.
• Grasshopper (University of Sydney) Group Members
  Despite the fact that the basic idea behind orthogonal persistence is very simple, research groups are finding it extremely hard to develop scalable and efficient persistent stores. One of the major difficulties derives from the fact that persistence provides a fundamentally different model of computing from that supported by conventional operating systems. In this project we are investigating the requirements of an operating system to support persistence and propose to design and construct a new operating system, known as Grasshopper, which has explicit support for persistent systems.
• GUIDE
  Guide (Grenoble Universities Integrated Distributed Environment) is an object-oriented distributed operating system for the development and operation of distributed applications on a local area networks connecting workstations and servers. Guide is a joint project of Bull and the IMAG Research Institute (Universities of Grenoble), which have created the Bull-IMAG joint Research Laboratory. It also has strong links with the COMANDOS Esprit Project (Construction and Management of Distributed Open Systems) and the BROADCAST Esprit Basic Research project.
• Hive (Stanford University Flash Project) Group Members
  The Hive OS Team is designing an operating system that is able to operate effectively in a traditional supercomputer environment as well as in a general-purpose, multiprogrammed environment. The latter environment poses significant challenges since general-purpose environments typically contain large numbers of processes making many system calls and many small I/O requests.
• Hurricane
  The Hurricane operating system is a hierarchically clustered operating system implemented on the Hector multiprocessor. Hierarchical clustering manages the system resources in clusters, using tight coupling within a cluster, and loose coupling across clusters. Distributed systems principles are applied by distributing and replicating system services and data objects to increase locality, increase concurrency, and to avoid centralized bottlenecks, thus making the system scalable.
• Kea (University of British Columbia)
  Group Members: Norm Hutchinson, Alistair Veitch, Peter Smith, et al.
  Kea is an operating system architecture designed to provide the applications running on top of it with the ability to dynamically replace parts of the system. Don't like your file-systems buffering policy? Write your own, the system will replace it for your application! Of course, there are lots of research and design issues over how we do this on a fine-grained scale, whilst maintaining system integrity and efficiency.
• L3 and L4
  Group Members: Jochen Liedtke
• Mach (Carnegie Mellon University)
  Mach is one of the giants in the operating systems research community. Originally started at CMU, Mach has become the basis for many research systems. Although work on Mach at CMU has largely stopped except real-time work and multi-server work, many other groups are still using Mach as the basis for research.
• Mach-US (Carnegie Mellon University)
  Related to: Mach
  The Mach-US system is an OS developed as part of the CMU MACH project. It is comprised of a set of servers, each of which supports orthogonal system services. For example, instead of one server supplying all of the system services as under the Mach BSD4.3 single server (UX), the Mach Multiserver (Mach-US) has several servers: a task server, a file server, a tty server, an authentication server, a network server, etc. It also has and emulation library that is mapped dynamically into each user process, and uses the system servers to support the application programmers interface (API) of the UNIX operating system.
• Maruti (University of Maryland) Group Members
  Maruti is a time-based operating system research project at the University of Maryland. With Maruti 3.0, we are entering a new phase of our project. We have an operating system suitable for field use by a wider range of users, and we are embarking on the integration of our time-based, hard real-time technology with industry standards and more traditional event-based soft- and non-real-time systems.
• Masix (Blaise Pascal Institute MASI Laboratory)
  Group Members: Rémy Card, Franck Mével, Julien Simon
  Related to: Mach
  Masix is a distributed operating system, based on the Mach micro-kernel, currently under development at the MASI Laboratory. Its primary goal is the simultaneous execution of multiple personalities, in order to run concurrently on a same workstation applications from the Unix, DOS, OS/2 and Win32 worlds. Furthermore, Masix pools the resources of a workstation local area network, independently from the personalities that run on each node. Masix also provides distributed services to the personalities.
• Merlin (University of Sao Paulo)
  An object-oriented, reflective operating system based on the Self programming language
• MetaOS (University of Victoria)
  MetaOS is an object-oriented system model, based on meta-levels, meta-spaces, meta-objects, and meta-interfaces, that allows applications to securely customize their run-time environment on the fly. Furthermore, it allows applications to share customizations with other applications, allows different types of security schemes to be implemented, and permits secure, remote troubleshooting of software.
• MOSIX (Hebrew University, Jerusalem, Israel) Group Members
  A solution to the NOW problem is now available in the form of a multicomputer operating system enhancements, called MOSIX. MOSIX is an enhancement of UNIX which allows users to use the resources of a NOW configuration, without any change to the application level. By using transparent, dynamic process migration algorithms, MOSIX enhances the network services, i.e. NFS, TCP/IP, of UNIX, to the process level, by supporting load balancing and a dynamic work distribution (leveling) in clusters of homogeneous computers.
• Mungi (University of New South Wales)
  A new operating system based on a single, flat virtual address space, orthogonal persistence, and a strong but unintrusive protection model.
• Nemesis (University of Cambridge, UK)
  Pegasus has produced an entirely new operating system, whose design is geared to support of high-performance applications which require a consistent quality of service (QoS), such as those which use multimedia. This operating system, called Nemesis, currently runs on a number of platforms including Intel, Alpha (21064 and 21164) and StrongARM.

  Nemesis is a single-address-space system, with an extremely light-weight kernel ('Nemesis Trusted Supervisor Code', or NTSC), and strong emphasis on performing operating system functions in the user's domain (thus avoiding the need for expensive protection regime changes).

• Oberon
  Oberon is a freely distributable OS written in the Oberon language in the Pascal-Modula tradition, developed by Niklaus Wirth and Juerg Gutknecht at the Institute for Computer Systems at the Swiss Federal Institute of Technology in Zurich (ETHZ). The most recent development of it is called Oberon System 3. It is available as Native Oberon for Intel-based machines which is self-contained and makes no use of any alien software layer. In addition, ports exist for all flavors of Windows: 3.1, 3.11, 95 and NT, as well as for Linux and for Macintosh.
• Opal (University of Washington)
  Related to: Mach
  Opal is a single-address-space operating system for 64-bit architectures. All Opal threads execute with a single global address space. The existence of a single address space simplifies sharing of complex (pointer-rich) data among cooperating applications, as well as persistent storage of that data, because pointers have the same meaning to all threads for potentially all time. Opal provides protection in the single address space; each thread executes within a protection domain that defines which pages it has the right to access.
• Paramecium
  This kernel uses an object-based software architecture which together with instance naming, late binding and explicit overrides enables easy reconfiguration. Determining which components are allowed to reside in the kernel address space is up to a certification authority or one of its delegates. These delegates may include validation programs, correctness provers, and system administrators. The main advantage of certifications is that it can handle trust and sharing in a non-cooperative environment.
• PEACE (Process Execution And Communication Environment) (GMD FIRST)
  PEACE is a family of operating systems with a truly object-oriented design developed at GMD FIRST. Emphasis is laid on subjects as performance, configurability and portability. It is the native operating system for the MANNA computer, a massively parallel computer facilitating a high-performance interconnection network. Ports to SunOS, FreeBSD and Parix were made and expand the scope of this system to other parallel computers as well as to workstation networks.
• Protection and Sharing through Shared Libraries (University of Notre Dame)
  Group Members: Arindam Banerji
  Protected Shared Libraries (PSLs) are based on the observation that shared libraries, with some modifications, could be used to implement user-level OS services with adequate protection and many degrees of sharing. Furthermore the dynamic nature of loadable shared libraries can be extended to provide a high degree of flexibility in the implementation of user-level services. Protected Shared Libraries add two different dimensions to the usual notion of shared libraries - protection domains and multiple forms of sharing through Shared Address Libraries.
• Roadrunner
  In traditional operating systems, input/output (I/O) subsystems implement a push-pull environment that provides system calls to allow user applications to pull data from or push data to a device. An important set of applications make combined use of push-pull to implement simple streaming, i. e. data is moved from one device to another with no transformations. Using push-pull I/O to implement these applications does not provide maximum performance. This work proposes a kernel design optimized for simple streaming applications. The Roadrunner operating system is being developed specifically to implement multiple, concurrent, high-speed speed data streams with Quality-of-Service (QOS) parameters.
• Real-Time Mach Project (Carnegie Mellon University) Group Members
  Related to: Mach
  Real-Time Mach is a research prototype real-time operating system intended for use as a vehicle for doing real-time systems research. The system is being developed by the ART Project in the School of Computer Science, Carnegie Mellon University.
• Scout (University of Arizona) Group Members
  The Scout project is a new operating system project that aims to build a fast, customizable operating system for networked systems by looking at novel ways to structure and construct operating systems. The Scout operating system is designed around the path, which is how data flows between end-points in a system. Paths are primary objects to which resources are allocated in Scout. The Scout system is also exploring new compiler technologies for system design and implementation, based on the insight that extensible operating systems are worthless if no one can build or extend them.
• Sombrero (Arizona State University)
• SPACE (University of California, Santa Barbara)
  Group Members: John Bruno, Dave Probert
  SPACE is an approach to operating systems which uses multiple protection domains rather than a single kernel to provide operating system services. Multiple instances of fundamental paradigms, such as threads and virtual memory, can coexist, since they are implemented as applications code. All that is left in what was the operating system kernel is a set of mechanisms to implement the protection domains. In SPACE these mechanisms.can be replaced as needed by the application to provide a fundamental level of extensibility not available in other adaptive operating systems.
• SPIN (University of Washington) Group Members
  SPIN is one of several research systems that aims toward run-time flexibility and specialization using techniques like type-safe languages and dynamic code generation to make a fast, dynamic, flexible system. It is an extensible operating system micro-kernel that supports the dynamic adaptation of system interfaces and implementations through direct application control, while still maintaining system integrity and inter-application isolation.
• Spring Real-Time Project (University of Massachsetts, Amherst) Group Members
  The Spring kernel has been designed and implemented to support/provide predictability, on-line dynamic guarantees, atomic guarantees, end-to-end scheduling and resource reservations. It utilizes a micro-kernel design for multiprocessor architectures and provides an interface to remote processes, support for distributed shared memory, and predictable low level communication. The kernel exists as a component of Spring's integrated environment. This environment extracts significant semantic information and this information is used at runtime to support flexibility. (ed: This is not the same as the Spring OS from Sun, which unfortunately has the same name.)
• Sprite (University of California, Berkeley)
  Sprite was a UNIX-like distributed operating system developed at Berkeley which ran on a number of different machines, and had a number of interesting features, such as load-balancing, a high-speed, aggressively-caching, distributed file-system, and a fast log-structured local file-system. Research on Sprite per-se come to an end, although various former members of the Sprite group are carrying on aspects of the original Sprite research.
• Synthesis (Columbia University)
  Group Members: Henry Massalin
  The Synthesis kernel was one of the first modern operating system projects to use run-time code generation (which Massalin called code synthesis) and fine-grained scheduling to construct a system that responded quickly and dynamically to high-speed devices. The main "draw-back" of Synthesis was that it was written is 68000 macro-assembler. Synthesis has influnced most of the modern extensible research operating systems, including SPIN, Aegis, Scout, and Synthetix.
• Synthetix (Oregon Graduate Institute)
  Group Members: Andrew P. Black, Charles Consel, Calton Pu, et al.
  The Synthetix project is investigating the application of a technique called incremental specialization, a combination of fine-grain modularity and dynamic code generation, to create operating systems which are both highly modular and high-performance. Incremental specialization takes advantage of particular circumstances, not just at compile time, but also at load time and run time, to make specialized optimizations.
• Tigger (Trinity College Dublin) Group Members
  The Tigger project is developing a framework for the construction of a family of distributed object-support platforms suitable for use in a variety of distributed applications ranging from embedded soft-real time systems to concurrent engineering frameworks. Customisability, extensibility and portability are put forward as the way to handle diversity and are thus the core design goals in Tigger.
• Tornado (University of Toronto)
  Tornado is a new operating system being developed for the NUMAchine that addresses NUMA programming issues using novel approaches, some of which were developed for our previous operating system Hurricane. Tornado uses an object-oriented, building block approach that allows applications to customize policies and adapt them to their performance needs. For research purposes, we intend to tune Tornado for applications with very large data sets that typically do not fit in memory and hence have high I/O demands. We also intend to provide applications with an operating environment that provides predictable performance behavior to allow performance tuning and to allow the application to appropriately parameterize its algorithms at run-time.
• Vino (Harvard University)
  VINO's key attributes are reusability of kernel mechanisms by user-level applications, application-directed kernel policy, and an access-method paradigm similar to that used by database management systems. The goal of VINO is to reduce the size of conventional operating systems by leaving the definition of complex kernel policies with applications. Additionally, the VINO system will provide improved performance for applications, since they can retain more control over their resources. Finally, VINO is designed to enable the development of new applications, such as real-time video, that require explicit control of system resources.
• x-kernel (University of Arizona)
  The x-kernel is an object-based framework for implementing network protocols. It defines an interface that protocols use to invoke operations on one another (i.e., to send a message to and receive a message from an adjacent protocol) and a collection of libraries for manipulating messages, participant addresses, events, associative memory tables (maps), threads, and so on.