The last time Hackerfall tried to access this page, it returned a not found error. A cached version of the page is below, or click here to continue anyway

Inferno Os

Inferno is an


developed at


(the research arm of LucentTechnology


). They describe it as "an


for creating DistributedServices


". It is now wholly owned and developed by Vita Nuova

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:

Hosted or

Virtual OS

ports include:

Inferno applications are written in a language called Limbo (


) 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


. Dis execution is performed either by an interpreter or is compiled on-the-fly to native machine instructions by a JIT (Just


Time) compiler when a dis module is loaded.

Perhaps the most interesting aspect of the system is its philosophy of

services as files


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


, 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)


for an informal specification of the inferno virtual machine. Also see "The design of the Inferno virtual machine" by PhilWinterbottom





) Also there is a paper on Dis implementation of a concurrent garbage collector:

For more papers see:

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:

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:

Inferno has been compiled as a plugin module for


on Wintel machines: the plugin is less than a megabyte
  • 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:

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. --


  • 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:; 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:

See also




Continue reading on