Inferno Os

Inferno is an OperatingSystem developed at BellLabs (the research arm of LucentTechnology?). They describe it as "an OperatingSystem for creating DistributedServices?". It is now wholly owned and developed by Vita Nuova http://www.vitanuova.com

Inferno runs directly on native hardware and also as an application providing a Virtual Operating System over other platforms. Applications can be developed and run on all Inferno platforms without modification or recompilation.

Native ports include:

x86
MIPS
ARM/StrongARM/Thumb
Power PC
SPARC

Hosted or Virtual OS ports include:

Plan 9
FreeBSD, OpenBSD, NetBSD
Linux/x86
Solaris/SPARC
Windows 95/98/ME/NT/2000

Inferno applications are written in a language called Limbo (LimboLanguage) which directly provides support for multi-threading and synchronised inter-thread communication using a channel mechanism based on Tony Hoare's CSP. Limbo is compiled to Dis bytecode, representing the instruction set of a VirtualMachine. Dis execution is performed either by an interpreter or is compiled on-the-fly to native machine instructions by a JIT (JustInTime) compiler when a dis module is loaded.

Perhaps the most interesting aspect of the system is its philosophy of services as files and per-process namespaces. All devices and OS services are presented as names (think: files) in a hierarchical namespace (think: filesystem). Namespaces can be composed on a per-process basis with resources being imported from other processes and other machines. All resources can then be accessed using standard file access primitives such as Open, Read and Write.

A good example of the efficacy of this approach is remote debugging in Inferno. Each Inferno process is represented by a directory under /prog where the directory name is the ID of the process. Each directory contains names such as "status", "stack" and "ctl". The Inferno debugger interacts with these "files". To perform remote debugging you simply import the remote machines /prog directory over the top of the local one. The local debugger then interacts with the remote processes, completely unaware that they belong to a remote machine.

Although it was created on PlanNineFromBellLabs, and retains a bit of a special attachment to it, it is a completely different operating system from Plan 9. There's a good comparison to be made with java, as they had similar design goals:

good performance (within an order of magnitude of C)
cross platform / virtual machine based (WriteOnceRunAnywhere, except actually delivered this time)
safe execution of untrusted code
powerful network / browser focus

However, they diverged in a few areas (probably to their advantage):

register based byte-code (as opposed to stack based), maps well to existing processors, JIT compilation works much better
supported as a native operating system (i.e., it'll easily run on bare hardware, for many values of hardware)

See http://doc.cat-v.org/inferno/4th_edition/dis_VM_specification for an informal specification of the inferno virtual machine. Also see "The design of the Inferno virtual machine" by PhilWinterbottom? and RobPike (http://doc.cat-v.org/inferno/4th_edition/dis_VM_design) Also there is a paper on Dis implementation of a concurrent garbage collector: http://doc.cat-v.org/inferno/concurrent_gc/

For more papers see: http://doc.cat-v.org/inferno/4th_edition/

Inferno's memory footprint is small: you can fit (say) the kernel and a non-trivial application into 1Mb of RAM.

It is specially suited to run in systems without an mmu because Dis ensures that applications can only access and manipulate their own memory without the help of the mmu. This also makes portability to new architectures easier as dealing with mmu peculiarities is usually one of the most tedious tasks when porting an operating system.

Inferno has been ported to the Play Station 2 and more recently to the Nintendo DS: http://code.google.com/p/inferno-ds/

Release 3 came out in the Summer of 2000, as of 2008 the code has been fully opensourced under the GPL and can be accessed at: http://code.google.com/p/inferno-os/

Inferno has been compiled as a plugin module for InternetExplorer on Wintel machines: the plugin is less than a megabyte http://www.vitanuova.com/inferno/pi

Q: Is anyone else playing with this -- or, better yet, developing a product? I am currently running the emulator under Windows'95, Windows'2000, Mac OsX, and Solaris. --ChrisGarrod
A: See for example the programming environment built on inferno/acme: http://code.google.com/p/acme-sac/

Expecting a cd in the mail in the next while, I'm quite interesting in playing with this natively as I've been very impressed with what I've seen so far. --WilliamUnderwood

Q: Are there any applications? It's hard to randomly Google for them with no distinctive word or name.
A: The browser is named Charon; the editor, AcmeProgrammingEnvironment; the DistributedFileSystem protocol is p92000; the shell, sh (not the same as Plan9's rc); the language, LimboLanguage; External software is available too, look for Inferno & Limbo on ohloh, freshmeat and google code search.
Q: If there really are ports to other architectures (the download mentions Irix, Solaris, FreeBsd, Linux, MacOsx, PlanNineFromBellLabs, and Windows at least), then where are they?
A: http://www.vitanuova.com/inferno/net_download4T.html; Inferno is an embedded operating system, you'll have to find the way that makes installing bare hardware easiest for you. Use plan 9's pxe boot loader (9pxeload) to boot an Inferno kernel (build it from inferno's os/pc/) over the network.

It has also been ported to Android. They stripped out the Java stuff and run it directly on the Linux/libc. Simpler, smaller TCB, etc. Link: http://arstechnica.com/information-technology/2011/09/if-it-aint-broke-break-it-inferno-environment-ported-to-android/