BLISS

BLISS is a systems programming language created in 1969 at Carnegie Mellon University by William A. Wulf, D.B. Russell, and A.N. Habermann. Designed for writing compilers, operating systems, and other systems software, BLISS became Digital Equipment Corporation’s (DEC) official implementation language and played a central role in building the VAX architecture and the OpenVMS operating system.

History & Origins

BLISS emerged from the need for a high-level language suitable for systems programming - a domain dominated by assembly language in the late 1960s. The name is commonly expanded as “Basic Language for Implementation of System Software,” though Wulf himself offered “Bill’s Language for Implementing System Software” in a 2015 oral history.

Design Goals

BLISS was designed with specific systems programming requirements in mind:

1. Efficiency - Designed to generate code competitive with hand-written assembly, as demonstrated by the optimizing compiler techniques documented in Wulf et al.’s 1975 book
2. Structured programming - Deliberate omission of goto in favor of structured control flow
3. Expression-oriented - Every construct that is not a declaration is an expression that produces a value
4. Minimal runtime overhead - No garbage collection, minimal runtime library requirements
5. Powerful macros - Rich compile-time macro facility for code generation

The Carnegie Mellon Connection

The original BLISS compiler for the PDP-10 (known as BLISS-10) was notable for its sophisticated optimization techniques. These optimizations formed the basis of the influential book The Design of an Optimizing Compiler (Wulf, Johnsson, Weinstock, Hobbs, Geschke; Elsevier, 1975).

What Makes BLISS Unique

BLISS has several distinctive characteristics that set it apart from other systems languages:

Everything Is an Address

In BLISS, a variable name evaluates to the variable’s address, not its contents. To get the value stored at a variable, you must use the explicit “contents of” operator - the unary dot (.):

OWN x;
x = 5;           ! Store 5 at address x
y = .x;          ! y gets the contents of x (the value 5)
y = .x + .z;     ! Add contents of x and z

This design makes pointer manipulation natural and explicit, reflecting BLISS’s systems programming heritage.

No Goto Statement

BLISS was one of the earliest languages to deliberately omit goto, relying entirely on structured control flow constructs like IF-THEN-ELSE, WHILE, DO-UNTIL, CASE, and SELECT.

Expression Language

Every construct in BLISS produces a value. An IF expression returns a value, a CASE expression returns a value, and even a block returns the value of its last expression:

result = (IF .x GTR 0 THEN .x ELSE -.x);

value = BEGIN
    LOCAL temp;
    temp = .x + .y;
    .temp * 2
END;

Keyword Comparison Operators

Instead of symbolic operators, BLISS uses keyword operators for comparisons:

Typeless Design

BLISS is typeless - all data is manipulated in terms of the underlying machine’s word size. While this gave programmers direct control over data representation, it also meant the compiler could not catch type errors. This was considered a disadvantage compared to typed languages like Pascal and C, and contributed to BLISS losing ground as C gained popularity.

No Built-in I/O

BLISS deliberately lacks I/O statements. Input and output are handled through library routines and operating system calls, keeping the language itself minimal and platform-independent.

The BLISS Family

BLISS evolved into a family of dialects, each targeting a different DEC architecture. The numeric suffix indicates the word length in bits:

A portable subset called Common BLISS was defined across these dialects, enabling code to be written once and compiled for multiple architectures.

BLISS and DEC

In 1975, DEC adopted BLISS as its official implementation language for the VAX computer line. This decision had enormous consequences:

• Most OpenVMS utility programs were written in BLISS-32
• BLISS-32 and the VAX architecture “grew up together”
• DEC’s compilers, linkers, and development tools were built in BLISS
• The language evolved with each new DEC architecture through the Alpha era

Running BLISS Today

The blissc Compiler

The most accessible way to run BLISS today is through blissc, an open-source BLISS-M (machine-independent) compiler by Matt Madison. It uses LLVM as its backend and targets x86 32-bit and 64-bit systems.

Key characteristics of blissc:

• Front-end parser and macro facility are substantially complete
• Compiles BLISS source to object files via LLVM
• Object files are linked with gcc to produce executables
• Tested on Ubuntu 24.04 with GCC 13 and LLVM 14, 17, and 18
• Licensed under BSD 2-Clause

Important note: Since BLISS has no built-in I/O, programs that need to print output must declare external C library functions and link with a C wrapper that provides the main() entry point.

VSI BLISS for OpenVMS

VMS Software, Inc. (VSI) actively maintains commercial BLISS compilers for OpenVMS on Alpha, Integrity (Itanium), and x86-64 platforms. The x86-64 compiler uses LLVM as its backend code generator.

BLISS vs. C

BLISS and C were contemporaries solving similar problems - providing a high-level alternative to assembly language for systems programming. When C was in its early development at Bell Labs, there were debates about the merits of BLISS versus C. Both languages share common roots in BCPL, but took different design paths:

C ultimately won widespread adoption due to its portability, the influence of Unix, and its more conventional syntax. BLISS remained primarily within the DEC/VMS ecosystem.

The Creator: William A. Wulf

William A. “Bill” Wulf (1939-2023) was a pioneering computer scientist who created BLISS while at Carnegie Mellon University. He earned one of the first doctorates in computer science from the University of Virginia in 1968.

Beyond BLISS, Wulf’s contributions include:

• The C.mmp 16-processor multiprocessor system using PDP-11 processors
• The Hydra capability-based operating system
• Pioneering work in computer security
• Co-founding Tartan Laboratories (later sold to Texas Instruments)
• Serving as President of the National Academy of Engineering (1996-2007)

Wulf authored over 100 papers and three books, supervised over 25 Ph.D. students, and received five honorary degrees. He passed away on March 10, 2023, in Charlottesville, Virginia.

Module Structure

A BLISS source file is organized as a module:

MODULE example =
BEGIN

! Declarations and routines go here

GLOBAL ROUTINE my_routine : NOVALUE =
BEGIN
    ! Code here
END;

END
ELUDOM

The ELUDOM keyword (MODULE spelled backwards) marks the end of the module - a distinctive BLISS tradition.

Getting Started

BLISS source files use the .bli extension. Because BLISS has no built-in I/O, a Hello World program requires:

1. A BLISS module that calls an external C function
2. A C wrapper providing main() and the I/O bridge function

The compilation process:

1
2
3
4
5
6
7
8

# Compile BLISS to object file
blissc -o hello.o hello.bli

# Link with C wrapper
gcc -o hello wrapper.c hello.o

# Run
./hello

Continue to the Hello World tutorial to write your first BLISS program.