Modula-3 History Collection on Computer History Museum(softwarepreservation.computerhistory.org)

Paul McJones, editor
paul@mcjones.org
https://mcjones.org/dustydecks/

This is an annotated collection of documents, source code, and other materials concerning the birth, development, and use of the
Modula-3 programming language.

Modula-3 is a programming language designed in the late 1980s by Luca Cardelli, Jim Donahue, Mick Jordan, Bill Kalsow,
and Greg Nelson (the defining report was written by Lucille Glassman and Greg Nelson). It is intended to be both safe and efficient for a wide range of systems and application programming: from low-level code like device drivers to program development tools to scientific or business applications. Safety means the runtime state of a program is guaranteed to be faithful to the language semantics. Modula-3 was also intended to be as simple as possible given these goals; the designers exceeded their 50-page budget for the language definition by only six lines of text plus the syntax summary. The language features include interfaces, objects, generics, threads, isolation of unsafe code, garbage collection,
exceptions, and subtyping. Many of these have become more widespread by 2025, but in 1990 [Nelson1991] it was much less common, especially in a language supporting non-heap allocated data structures.

Modula-3's existence stems from a suggestion by Maurice Wilkes to Niklaus Wirth that Modula-2+ be revised and
standardized as Modula-3. (Modula-2+ extended Wirth's Modula-2 with threads, garbage collection, and exceptions based on previous experience at Xerox PARC with Mesa and Cedar. See Software Preservation > Mesa and Modula-2+.) A committee of people from Digital Equipment Corporation Systems Research Center (Cardelli, Kalsow, and Nelson) and Olivetti Research California (Donahue and Jordan) published the initial Modula-3 design in August 1988 [Cardelli1988a], as implementations began at both labs. Experience from writing Modula-3 compilers in Modula-3 led to a few revisions and generalizations in November 1989 [Cardelli1989a]. A final set of revisions were completed by December 1990 [Nelson1990]. In 1991, the book Systems Programming with Modula-3 introduced the language to a wider audience [Nelson1991].

Chapter 1 ("Introduction") of [Nelson1991] provides additional details about the history of the design
processs and the nature of the language. Chapter 8 ("How the language got its spots") is a fictional dialogue exposing a number of issues faced by the designers.

Implementations began at both companies immediately after the initial language definition was published. Olivetti
Modula-3 was used inside Olivetti for a time, but died out after Olivetti Research California was abruptly shut down in February 1991. All subsequent Modula-3 development (except a short-lived GNU project at UMass Amherst) was based on DEC SRC Modula-3.

Olivetti Modula-3 was implemented by Mick Jordan, Trevor Morris, David Chase, Steve Glassman, and Marion Sturtevant.
[Jordan1990, Nelson1991] The compiler was based on a general Abstract Syntax Tree (AST) mechanism called M3AST. Tools based on M3AST included the compiler front-end (parser, semantic analyser, and a control module), a code generator that produced C source code, the pre-linker (which dealt withglobal information such as determining module initialization order and checking for consistent compilation of interfaces and modules), and a "pickle" (object serialization/deserialization) stub generator [Jordan1990]. The first public release was October 1989 [Donahue1989]. After Olivetti Research California (ORC) shut down in February 1991, Mick Jordan and Steve Glassman moved to DEC SRC; Jordan brought the AST-based toolkit with him.

SRC Modula-3 was implemented by Bill Kalsow and Eric Muller [Nelson1991]. It was bootstrapped
via SRC's existing Modula-2+ language and compiler. The original version generated C and invoked GCC to compile it, but starting with version 3.0 it was modified to produce an intermediate language that could drive different backends. The most widely used backend was a small program that read a textual version of the intermediate language and called the GCC code generation libraries. For more details, see [Kalsow 1994, 1995a, 2021]. Bill Kalsow left SRC in July 1995, and development of the compiler at SRC shifted to maintenance mode. Nevertheless, other than the Olivetti compiler, all subsequent Modula-3 compilers and distributions were based on the SRC Modula-3 code base, with contributions from a variety of people.

For a full history of releases 1.0 through 3.5.3 (release 3.6 was minor changes to 3.5.3), see
[Heydon1997].

Prime Time Freeware for UNIX, Volume 3.1B via archive.org

In the late 1980s, Eliot Moss at the University of Massachusetts Amherst became interested in integrating programming language and
database features by adding persistence to programming language datatypes. He and his research group designed the Mneme persistent object store and then used it to prototype Persistent Smalltalk and Persistent Modula-3 [Moss1990].

Persistent Modula-3 [Hosking1990] was based on a new Modula-3 compiler, since they began before DEC SRC
Modula-3 was released [Hosking1991]:

"We have chosen the GNU C compiler as a base on which to build, its portability meeting the first of our requirements, and its
optimization phase allowing us to attack the problem of performance. Our implementation effort involves the construction of a Modula-3 front end to the compiler, along with the necessary modifications to the back end to support persistence and garbage collection."

The compiler generated assembly language and tables to allow the locally-developed garbage collector to precisely locate all
collectible objects [Diwan1992, Hudson1991].

The Caltech Mosaic C Multicomputer was based on single-chip nodes with a two-dimensional interconnect.
[Seitz1993] Rustan Leino designed Modula-3D, a distributed extension of Modula-3 for the Mosaic, for his Master’s thesis [Leino1992, 1993]:

"I think [the Mosaic] had 256 cores (or maybe that was the eventual goal), each of which had 64 KB of word-addressable (16-bit
words) RAM. My runtime system, with garbage collector, interprocess communication, and network objects used 32 KB of that memory on each core." [Leino, personal communication, 2021]

Abstract: In this note, we extend an object-oriented language to support programming fine-grain multicomputers.
The new constructs have a simple semantics and provide a nice way to write distributed programs. The semantics of the constructs are independent of how a program is distributed. We also show a set of simple conditions under which even the outcome of a program is independent of how its control and data are distributed. We show some strengths and weaknesses of the programming model, and describe and critique our implementation of the language.

Mary F. Fernández investigated the runtime overhead of extra indirections due to the interaction between Modula-3's opaque types and separate
compilation. She developed link-time optimizations to avoid this overhead:

"We describe opportunities for link-time optimization of Modula-3 and present two link-time optimization techniques. Data
driven simplification is a new technique. Using a program’s type hierarchy, it recovers completely the cost of opaque types and reduces the runtime overhead of methods. It also reveals other opportunities for optimization, such as constant and type propagation ancl procedure inlining and cloning. Profile-driven optimization uses profile data to transform those procedures that can benefit most from optirnizations made possible by data-driven simplification. Moreover, our techniques make it as easy to optimize procedures in libraries as those in applications." [Fernandez1995b]

To test these ideas, she ran benchmarks on a modified version of DEC SRC Modula-3 version 2.11, whose backend generated C source
code. She used her mlcc and mld, a machine-independent C compiler and a retargetable, optimizing linker. She only needed to make modest changes to the Modula-3 compiler, adding 87 new lines of code. Running benchmarks, she found:

"This is a version of
Modula-3 running on a plain DOS-PC. It is mainly addressed to students of undergraduate programming courses and other Modula-3 programming beginners. It was developed on the Department of Informatics, University of Klagenfurt. We use it in our introduction into programming courses. The system implements version 2.09 of the Digital Systems Research Centers
Modula-3 implementation. ...

The projects were supervised by László Böszörményi." [Weich1996]

"I cross-compiled from a DEC-Station to the DOS-Extender of DJ Delorie,
which was a platform for the GNU C Compiler on MS-DOS." [Preschern2026]

Klaus Preschern, who had been an intern with Bill Kalsow at DEC SRC in 1992, developed an alternative Modula-3 PC system, called EX32 after leaving the University of Klagenfurt. His first release was 27 March 1994 and was based on SRC M3 Version 2.11 [Preschern2026]. The final release was based on SRC M3 Version 3.1:

After completing the MS-DOS port, Preschern carried out a port of DEC SRC Modula-3 3.6 to IBM's OS/2. There were two different
variants for thread scheduling: one used a virtual timer (like a Unix signal) and the other used native threads. The first variant worked on OS/2 3.0 (Warp) and OS/2 4.0 (Merlin) and the second one, which used the x86 backend for code generation, supported native threads on Merlin. Both variants supported building of DLLs. With the help of XFree86 for OS/2 Trestle was available for both variants and the Merlin version included the Zeus algorithm animations.

Preschern recalls [Preschern2026]: "The Modula-3 runtime system required suspending threads during
garbage collection. As far as I remember, the Windows system calls for suspending other threads became available for Merlin, because IBM provided a toolkit to support porting of Windows software to OS/2, in an attempt to keep OS/2 alive. With the system calls, provided with Merlin for this Windows compatibility layer, it was then possible to implement calls like "SuspendOthers()" in RTThread.i3 for OS/2 threads, to suspend all threads in a process, except the caller."

Farshad Nayeri learned Modula-3 as a graduate student at UMass Amherst under Eliot Moss. Later, Nayeri and his group at GTE
Laboratories used Modula-3 to build a Distributed Object Manager [Nayeri1994]. Nayeri met Geoff Wyant through comp.lang.modula3; when they realized both worked in the Boston area they got together for lunch. Wyant was using Modula-3 for a series of distributed systems projects at Sun Microsystems Laboratories [Wyant1994, Waldo1995, Wollrath1995]. With encouragement from Wyant, Nayeri and his wife Lauren Schmitt founded Critical Mass in Cambridge, Massachusetts. In August 1995 they visited DEC SRC with a proposal for a cooperative partnership whereby Critical Mass would create a family of products based on SRC technologies and offer them with commercial support. The products were to include:

Each of these products would be a family, with core, team, and enterprise versions.

By fall 1995 the plan for Photon had evolved to a web-based user interface, "allowing the user to readily browse,
build, and manage large projects locally or over a network" [Schmidt1995]. Bill Kalsow joined Critical Mass in early 1996 and contributed greatly to the system. Among other things, support of the Windows NT platform was improved [Kalsow1997]. Michel Dagenais at Positron Industries was an early support customer for Positron's Power911 system. In late 1996, Critical Mass released Reactor, a web-based fast-turnaround environment for Modula-3 programming.

In the early days, the possibility of Geoff Wyant joining Critical Mass had been discussed, but on 16 June 1996 a tragic accident
in a light plane claimed Wyant's life [Sproull1996].

As Java emerged on the scene, Critical Mass built several products to take advantage of its increasing popularity. The first was
JVM, a Java virtual machine written in Modula-3 that could be embedded in an application (coded in C, C++, or Modula-3), allowing Java to be used as an extension language. Raygun was a final, unreleased, product: a flexible web-based cross-referencing tool that extended Reactor (which in turn extended m3browser [Kalsow1995b]) to additional languages including Java.

By 1998, Critical Mass had terminated active development of Modula-3. They open-sourced the code base in 2001. Support and
development was taken over by Elego Software Solutions in Berlin. The source code for Reactor (now called CM-IDE) was open-sourced in June 2008.

Unless otherwise noted, the HTML files below are from cmass.com via archive.org.

[Kalsow1997] describes the compiler and runtime changes made by Critical Mass up through April 1997.
Here's a brief summary: [Source: About CM3 at modula3.github.io]

"With release 3.6, in early 1996, DEC SRC Modula-3 reached a mature state. Bill Kalsow, responsible for the
compiler, left DEC SRC around that time and later joined Critical Mass, a commercial Modula-3 vendor. Since then, a number of advanced Modula-3 projects at DEC SRC continued in areas such as 3D animation, static verification, constraint based geometrical editor, and distributed applications. In many other areas, including the compiler and base libraries, few updates were made at DEC SRC. Moreover, these updates are available separately from the release and must be integrated manually.

At the same time, several contributions appeared from Modula-3 programmers around the world and included several bug
fixes, enhancements, and new libraries or tools such as a more platform independent version of Pickle, an integrated code generator for Linux ELF, a simplified single process version of m3build-m3-quake, a port of SRC Modula-3 to NT386 using gnu-win32, and several new packages such as CVSsup, M3COCO, and M3 TXL.

After consultations with several key academic Modula-3 programmers with similar needs, including Peter Klein, Blair
McIntyre, and Richard Watts, it was decided to create a new distribution based on SRC Modula-3. The new distribution is under CVS version control and is accessible to remote maintainers.

The first public release of PM3 included SRC release 3.6 with all patches applied, a fast integrated Linux ELF code
generator, a simplified m3build-m3-quake with accordingly simplified templates for platform customization, m3cc and m3gdb based on newer versions of gcc and gdb, full platform support for NT386GNU through gnu-win32, a simplified bootstrap and build process, a directory hierarchy to organize the 130+ packages, SGML/HTML based documentation, and an automated release procedure to produce updated sources, bootstraps and binaries every week."
[Dagenais, history.html, pm3 version 1.1.15 of 5 Sep 2000]

"... I began taking care of the comp-lang-modula3 FAQ in 1993 and stopped in 2002. From
September 1995 to August 1996, I was Director of Software Development at Positron Industries, in a team building their next generation 911 Emergency Call system in Modula-3. We used the services of Critical Mass (Farshad Nayeri and Bill Kalsow) to get the incremental garbage collector ported to Windows NT.

I later maintained the Polytechnique Montréal distribution of Modula-3 (PM3), with some documentation and minor
tools added. In 1996-1997 I wrote an online book draft, Building Distributed OO Applications: Modula-3 Objects at Work [Dagenais1997] and used it a few years in a course on Object Oriented programming. In 2002, coming back from a sabbatical, I gave up on Modula-3 (and PM3 and the FAQ) to concentrate on tracing and performance analysis tools for Linux."
[Michel Dagenais, personal communication, 30 August 2025]

After Dagenais gave up on PM3, Elego Software Solutions maintained it from 2001-2012, then maintenance moved to GitHub (https://github.com/modula3/pm3).

The snapshots and diffs of versions 1.1.0 through 1.1.15 were provided by Michel Dagenais.

SPIN is an extensible operating system whose extensions run in the kernel; protection of the kernel from the
extensions and between extensions is implemented through software (both compile-time and runtime) rather than hardware mechanisms. The kernel and the extensions are written in a version of DEC SRC Modula-3 (perhaps version 3.1?) with some additions and changes [Hsieh1996]:

As a graduate student, Antony Hosking had worked with Eliot Moss on a Persistent Modula-3 based on their GNU
Modula-3, Mneme persistent object store, and language-independent garbage collector toolkit. Hosking then joined the faculty at Purdue University, continuing his work on persistence, this time exploring orthogonal persistence: objects are persisted because they can be reached from a client-specified database root, rather than being declared at compile time to be an element of a persistent type. Persistent Modula-3 made no changes to the compiler.

"We track the Polytechnique Montréal Modula-3 release (version 0.x.y of Persistent Modula-3 corresponds to version 1.x.y of
Polytechnique Montréal Modula-3), which is itself based on SRC Modula-3 release 3.6"
[Hosking2003].

The main additions are the new packages database/GRAS3 and database/persistence;
these have also been merged into https://github.com/modula3/pm3.

Most of the distributions seem to include only executables for the compiler/build/IDE, but include source for the libraries. There are full source distributions and patches in the old/ subdirectory:

"Cambridge Modula-3 is a variant of SRC Modula-3 developed at the University of Cambridge Computer
Laboratory. It includes an updated build system with configuration file support (no more having to rebuild the distribution whenever you move it), language additions to allow debugging, NT386GNU support for gcc on Windows 95 and NT, a number of extra packages, and Blair MacIntyre's portable pickle package version 2.0. Its main aims are:

"Cambridge Modula-3 was developed to have an updated build system with better configuration file support. It extends SRC M3 with a few extra packages, and includes some other enhancements including pragmas.

Most, if not all, of the Cambridge Modula-3 enhancements have been folded into the Polytechnique Montreal Modula-3 system. I believe that CAM3 is slowly being phased out, but I could be wrong.

Currently, the web pages and software distribution of CAM3 don't seem to be accessible by the public, if they still exist at all. (The
link was https://www.cl.cam.ac.uk/m3doc/linux/cambridge.html)." [Olaf Wagner, modula3.org/implementations, July 1998]

"Ezm3 is a simpler, more portable distribution of the Modula-3 compiler and runtime libraries. It is designed for people who
would like to install CVSup on their systems as quickly and as painlessly as possible. Ezm3 is derived from the robust and comprehensive PM3 release of Modula-3. Only the components and features which are needed by CVSup were retained. Features which made the package harder to port and install were removed.

The goal of Ezm3 is for you to be able to install Modula-3 on your system in one try, without any patching or false starts."
[Polstra, EZM3: An Easier Modula-3 Distribution, 2001]

For a number of years, FreeBSD development was based on the CVS revision control system, using the program CVSup to replicate CVS
repositories. CVSup was written in Modula-3, and its author, John D. Polstra, maintained the EZM3 distribution of Modula-3. EZM3 was based on Polytechnique Montréal Modula-3 (perhaps version 1.1.15?).

Elego is a software product and services company in Berlin. After Critical Mass open-sourced
CM3 in 2000, Elego began providing the infrastructure for website, repositories, continuous integration, and bug tracking. In March 2002 Elego also took over the repository of the other active Modula-3 distribution, PM3, which had been maintained by Michel Dagenais at Polytechnique Montréal. After more than a decade, all Modula-3 based projects at Elego had been terminated, and it was no longer possible to justify the resources being expended. All the development activity moved to github.com.
[Olaf Wagner, personal communication, 1 September 2025]

"CM3 5.1 is the first open source release of the Modula-3 compiler and bundled software from Critical
Mass, Inc. It does currently not contain other products that were created by Critical Mass. The CM3 graphical user interface is called CM3-IDE. It is based on the original Reactor product produced by Critical Mass."
[https://www.cs.purdue.edu/homes/hosking/m3/]

"PM3—Polytechnique Montréal Modula-3 is the largest incarnation of the free Modula-3 development environments. It builds
upon the SRC M3 base and includes enhancements from Cambridge Modula-3.

With over 15,000 files of source code, there is a large and solid existing base of software to develop upon. Fortunately, there are binaries available for the most popular platforms.

In 2002, the server at Polytechnique Montréal has been shut down; CVS repository and web services for PM3 are now continued at the server of elego Software Solutions GmbH, Berlin, Germany.

Lately, Antony Hosking has merged the newer compiler from the CM3 distribution, and contributed all the persistence work done in his University research projects."
[https://www.modula3.org/implementations/]

During the Elego era, Antony Hosking converted the CM3 thread library to use native threads on POSIX platforms (the Win32 version had
always used native Win32 threads). He also updated the garbage collector to use a mostly-concurrent, mostly-copying algorithm
[Hosking2006].

The best overall description of CM3 during the elego years (2001-2012). Documentation is comprehensive. Download has a number of old releases. Resources>CM3 Change log itemizes all source changes, year by year.

After Elego Software Solutions could no longer justify dedicated support for Modula-3, the cm3 and pm3 CVS repositories were moved
to github.com/modula3 by Antony Hosking. The pm3 repository combines Polytechnique Montréal Modula-3 and Purdue Persistent Modula-3.

This distribution is based on a merge of the Polytechnique Montreal
Distribution of Modula-3 with the public release of CM3, plus enhancements for
persistence by Antony Hosking, Jiawan Chen and Adam Welc at Purdue University,
and packages (libraries, programs and documentation) from other sources.

The Polytechnique Montreal Distribution of Modula-3 is based on DEC SRC
Modula-3 release 3.6 with enhancements by Louis Dubeau, Jerome Collin and
Michel Dagenais, and several packages (libraries, programs, and documentation)
from other sources. The online documentation may be accessed before the build
by pointing your favourite WWW browser to intro/src/index.html."

https://modula3.github.io replicates some of the information previously located at https://modula3.elegosoft.com, https://www.modula3.org, and https://www.opencm3.net.

For earlier versions, see
[Birrell1987, 1989] in
Software Preservation > Modula-2+.

"This manual describes a collection of interfaces defining abstractions that SRC’s
programmers have found useful over a number of years of experience with
Modula-3 and its precursors. We hope the interfaces will be useful as a ‘starter
kit’ of abstractions, and as a model for designing and specifying abstractions
in Modula-3" [Horning1993].

[The first time Jim saw the cover of the printed report he told me, "For the rest of your life
you'll regret not putting your name first ." Now is the time to acknowledge that error.—PMcJ]

These interfaces were released in version 3.1 of DEC SRC Modula-3.

[*] Fingerprints are short tags for larger objects. They have the property that if two fingerprints are different then the corresponding objects are certainly different and there is only a small probability that two different objects have the same fingerprint The latter event is called a collision.

Trestle is an object-oriented window system based on the abstraction of a Virtual Bitmap Terminal (VBT) [Manasse1991, Manasse1992]. An earlier version of Trestle was built using Modula-2+.

Nearly 30 complete Modula-3 programs are presented to illustrate Trestle.

VBTkit is a user interface toolkit based on Trestle. It provides a library of "widgets" and the support
software that makes it easy to customize these widgets and to construct more widgets [Brown1993a].

VBTkit was influenced by an earlier system written in Modula-2+. See [Cardelli1987,
1988b] in Software Preservation > Modula-2+.

FormsVBT is a system for building graphical user interfaces. It consists of a language for describing an
application’s user interface, a stand-alone application for constructing the user interface, and a runtime library for communicating between an application’s code and its user interface. It extends Trestle and VBTkit [Brown1993b]. It is based on the design of an earlier Modula-2+ version: see FormsVBT in Software Preservation > Modula-2+.

JVideo extends Trestle, FormsVBT, and Obliq to support VideoVBTs that can display video in a window, using the J-Video hardware that was available for DEC Alpha-based workstations running Digital Unix, circa 1995. This work was done to support the Argo application, but was available for general use.

WebVBT is a VBT that displays an HTML page from the World-Wide Web. The page may contain oblets.

Oblet is an active object that is distributed over multiple machines. Oblets are written in Obliq,
an object-oriented scripting language for distributed computation. The high-level support provided by Oblets makes it easy to write collaborative and distributed applications.

ANIM3D is a 3D animation library targeted at visualizing combinatorial structures; it is particularly useful for algorithm animation.