Inferno (operating system)

Design principles

Inferno was created in 1995 by members of the AT&T Bell Labs Computing Sciences Research Center to bring ideas derived from their previous operating system, Plan 9 from Bell Labs, to a wider range of devices and networks. Lucent Technologies, the successor to that arm of AT&T, closed the Bell Labs Computing Sciences Research Center in 2005.

Inferno is a distributed operating system based on three principles:

• Resources as files: all resources are represented as files within a hierarchical file system
• Namespaces: a program's view of the network is a single, coherent namespace that appears as a hierarchical file system but may represent physically separated (locally or remotely) resources; derived from Plan 9 namespaces
• Standard communication protocol: a standard protocol, called Styx, is used to access all resources, both local and remote

To handle the diversity of network environments it was intended to be used in, the designers decided a virtual machine (VM) was a necessary component of the system. This is the same conclusion of the Sun Microsystems Oak project that became Java, but arrived at independently.

The Dis virtual machine is a register machine intended to closely match the architecture it runs on, in contrast to the stack machine of the Java virtual machine. An advantage of this approach is the relative simplicity of creating a just-in-time compiler for new architectures. This was inspired by AT&T's work on the CRISP processor.

The virtual machine provides memory management designed to be efficient on devices with as little as 1 MiB of memory and without memory-mapping hardware. Its garbage collector is a hybrid of reference counting and a real-time coloring collector that gathers cyclic data.

The Inferno kernel contains the virtual machine, on-the-fly compiler, scheduler, devices, protocol stacks, the name space evaluator for the file name space of each process, and the root of the file system hierarchy. The kernel also has built-in modules that provide interfaces of the virtual operating system, such as system calls, graphics, security, and POSIX compliant math modules.

Inferno Paper introducing the original Inferno release

The Bell Labs Technical Journal paper introducing Inferno listed several dimensions of portability and versatility provided by the OS as of first public release in 1997:

• Portability across processors: Inferno currently runs on Intel, Sun SPARC, ARM, SGI MIPS, HP PA-RISC, IBM PowerPC, and AMD 29k architectures and is readily portable to others.
• Portability across environments: it runs as a stand-alone operating system on small terminals, and also as a user application under Bell Labs Plan 9, Windows NT, Windows 95, and Unix. In all of these environments, Inferno programs see an identical interface.
• Distributed design: the identical environment is established at the user's terminal and at the server, and each may import the resources (for example, the attached I/O devices or networks) of the other. Aided by the communications facilities of the run-time system, programs may be split easily (and even dynamically) between client and server.
• Minimal hardware requirements: it runs useful applications stand-alone on machines with as little as 1 MiB of memory, and does not require memory-mapping hardware.
• Portable programs: Inferno programs are written in the type-safe language Limbo and compiled to Dis bytecode, which can be run without modifications on all Inferno platforms.
• Dynamic adaptability: programs may, depending on the hardware or other resources available, load different program modules to perform a specific function. For example, a video player might use any of several different decoder modules.

These design choices were directed to provide standard interfaces that freed content and service providers from concern of the details of diverse hardware, software, and networks of the 1990s over which their content was delivered. The majority of IoT hardware operating in 2024 used Linux in comparison to the hardware challenges that the Inferno designers faced.

Features

Application development and APIs

To ensure memory safety, applications are written in the Limbo programming language, which provides static typing, garbage collection, and built-in concurrency features, this allows the operating system to safely run without a hardware MMU; only kernel modules and internal parts of the Dis virtual machine itself can be written in C with a key example being the system sys module which contains the majority of the system calls. Limbo code is compiled into architecture-independent bytecode executed by the Dis virtual machine. The Dis VM can interpret the bytecode or compile it just-in-time into native instructions, allowing applications to run consistently across different platforms. Low level operating system functions such as process creation and inter-process communication are implemented within the Dis virtual machine itself; This means applications cannot access memory outside their allocated range and all resources such as file descriptors, network connections, and window manager objects are connected to the garbage collector; the garbage collector uses the very concurrent garbage collection algorithm. In hosted mode, kernel threads are handled by the host operating system.

Resource management

All resources in Inferno, such as devices, services, and network connections, are represented as files in a hierarchical namespace and accessed using standard file operations like open, read, write, and close. Inferno uses the Styx protocol, equivalent to Plan 9's 9P2000, to interact with both local and remote resources in a uniform manner. Hardware is also accessed through user mode file servers that present resources to the user-mode API from the native kernel. When Inferno is hosted, all of the hardware resources are managed by the host operating system and accessed through a namespace which binds to the specific exposed hardware interfaces of the host OS. Inferno64 further manages resources through the Owen labor exchange which also allows for intelligent network discovery and resource sharing, first conceptualised in 2004 for Inferno 4th Edition.

Security features

Security features include per-process namespaces, authentication, and encryption. Applications operate within restricted namespaces, limiting their access to only authorized resources. The system supports a range of cryptographic protocols, including RSA, Diffie–Hellman, and symmetric encryption methods such as RC4 and DES. Inferno64 continues this with support for the latest version of the SSH protocol and TLS 1.3. The owner based security model ensures that each module has a namespace that can only be fully controlled by an administrator, the default user owner is known as Eve in both hosted and native mode.

Filesystems

All provided filesystems are provided by file servers in a similar fashion to Plan 9 and file servers are written in Limbo. The native provided filesystem is kfs as used in the first and second edition of Plan 9. File servers can be implemented as a kernel module or as a user-mode application; files are manipulated using functions which translate to Styx messages.

Integrated development environment

The Inferno operating system is compiled with a modified variant of the Plan 9 compiler suite including mk that has been rewritten in ANSI C with POSIX extensions. This modified suite has served as a basis for the modern Plan 9 compiler suite of the 2020s.

Inferno provides a full development environment that includes a compiler, graphical debugger, scripting tools, and libraries for networking and user interfaces. The majority of the development tools operating on Inferno are Plan 9 tools rewritten in Limbo. It supports dynamic module loading and can operate with low resource requirements, such as systems with 1 MB of memory.

Inferno64 includes built-in AI coding agents and provides 64-bit JIT compilers.

Supported device platforms

Previous versions of Inferno could run either as a native operating system on historically supported architectures such as MIPS, PowerPC, SH-4, and SPARC or as a hosted application on historic operating systems, including 2.x versions of Linux, Unixware 2.x, Windows 2000, Plan 9 3rd Edition, FreeBSD, Solaris 7, Mac OS X Tiger, and IRIX.

The current development branch version of Inferno 4th Edition maintains support for AArch32 and IA-32 while the hosted ports are better suited for Linux and 9front. Inferno64 which abandons previous 32-bit processing platforms, supports x86-64 and AArch64.

History

Connection to Plan 9

Inferno is a descendant of Plan 9 from Bell Labs, and shares many design concepts and even source code in the kernel, particularly around devices and the Styx/9P2000 protocol. Inferno shares with Plan 9 the Unix heritage from Bell Labs and the Unix philosophy. Many of the command line tools in Inferno were Plan 9 tools that were translated to Limbo.

Lucent origins

In the mid-1990s, Plan 9 development was set aside in favor of Inferno. The new system's existence was leaked by Dennis Ritchie in early 1996, after less than a year of development, and publicly presented later that year as a competitor to Java. At the same time, Bell Labs parent company AT&T licensed Java technology from Sun Microsystems. The Inferno business unit was founded by Lucent Technologies after the AT&T spin-off and staffed with a team of 20 personnel.

In March–April 1997, IEEE Internet Computing included an advertisement for Inferno networking software. It claimed that various devices could communicate over "any network" including the Internet, telecommunications and LANs. The advertisement stated that video games could talk to computers – a PlayStation was pictured – cell phones could access email, and voice mail was available via TV.

Lucent used Inferno in at least two internal products: the Lucent VPN Firewall Brick, and the Lucent Pathstar phone switch. They initially offered to sell source code licenses of Inferno but found few buyers. Lucent did little marketing and missed the importance of the Internet and Inferno's relation to it. During the same time Sun Microsystems was heavily marketing its own Java programming language, which was targeting a similar market, with analogous technology, that worked in web browsers and also filled the demand for object-oriented languages popular at that time. Lucent licensed Java from Sun, stating that all Inferno devices would be made to run Java. A Java byte code to Dis byte code translator was written to facilitate that. However, Inferno still did not find customers; Lucent also held a Limbo programming contest in 1998 in an attempt to attract student developers.

The Inferno business unit ceased operations in 2000 within three years of its founding, and Lucent sold Inferno to Vita Nuova Holdings based in York, England.

Vita Nuova, renewed development

In 1996, Vita Nuova Limited was founded in York, England with the goal of commercializing both Plan 9 and Inferno. Lucent soon contracted Vita Nuova to produce a PowerPC port of Plan 9 for the BeBox. In 1997, Lucent created a new ventures group to exploit the commercial possibilities of everything produced at Bell Labs. It was through this ventures group that Vita Nuova became Vita Nuova Holdings and obtained the Inferno operating system. Vita Nuova would also offer a boxed edition of Plan 9.

Vita Nuova continued development and offered commercial licenses to the complete system, and free downloads under non-GPL compatible licenses for all of the system except the kernel and VM. They ported the software to new hardware and focused on distributed applications. In 2004, Vita Nuova released the 4th edition under more common free software licenses, and in 2021 they relicensed all editions mainly under the MIT License. In 2026, It was explained by former Vita Nuova architect Charles Forsyth that Vita Nuova became effectively defunct after 2022 but remains actively registered for historic copyright reasons.

Inferno64

In 2022, Inferno was forked into the active Inferno64 project which added 64-bit capabilities, although this made applications written for the original 4th edition 32-bit Dis virtual machine incompatible with the newer 64-bit version of Dis. As of 2026, Inferno64 development remains active. The previous official formal Dis Virtual Machine specification had been last published and revised in 2003.

30 years of Inferno and planned future development

As of 2026, 32-bit Inferno 4th Edition is maintained with occasional developments added by Charles Forsyth of Terzarima Systems and is held on the appropriate GitHub repository. A port of 32-bit Inferno OS to RISC-V has been discussed by Forsyth alongside an updated formal specification of the Dis virtual machine. A near complete RISC-V port had been previously developed at the Norwegian University of Science and Technology in 2021. Preliminary planning of the future 5th Edition Inferno release has begun but the features are yet to be fully decided.

Ports

Inferno runs on native hardware directly and also as an application providing a virtual operating system which runs on other platforms. Programs can be developed and run on all Inferno platforms without modifying or recompiling.

Native ports historically included these architectures: X86, MIPS, ARM, PowerPC, SPARC.

Historic hosted or virtual OS ports included: Microsoft Windows before XP, Linux, FreeBSD, Plan 9, Mac OS X, Solaris, IRIX, UnixWare.

Inferno could also be hosted by a plug-in to Internet Explorer. Vita Nuova director Michael Jeffrey stated that a Netscape plug-in was planned for 2002 but it was never released. The plug-in code was deleted from the current Inferno-OS branch in 2021.

The updated April 2026 Inferno 4th edition Inferno-OS development branch only has current ports for x86 and ARM.

Hosted ports supported by the April 2026 Inferno 4th edition Inferno-OS development branch are Linux, macOS, NetBSD, Windows 11, and Plan 9.

A timeline of various device ports

1990s: Acorn Archimedes, BeBox, IBM PC Series, JavaStation, Lucent Appliances, SA-1100 based VoIP phone

2000s: Compaq IPAQ, PowerQUICC II Series, Nintendo DS, NTT MAP-1000, XScale based devices

2010s: Android devices, Openmoko, SheevaPlug, Sun SPOT, Raspberry Pi

2020s: Raspberry Pi Pico, RISC-V System Emulator, Sparkfun MicroMod

Hosted Inferno64 is limited to modern 64-bit platforms such as macOS 12, Windows 11, 9front, and Android 10 or later.

Distribution

Inferno 4th edition was released in early 2005 as free software. Specifically, it was dual-licensed under two structures. Users could either obtain it under a set of free software licenses, or they could obtain it under a proprietary license. In the case of the free software license scheme, different parts of the system were covered by different licenses, including the GNU General Public License, the GNU Lesser General Public License, the Lucent Public License, and the MIT License, excluding the fonts, which are sub-licensed from Bigelow and Holmes.

In March 2021, all editions were relicensed under mainly the MIT License. Inferno64 continues under the same MIT License.