Paul McJones, editor
paul@mcjones.org
https://mcjones.org/dustydecks/
Last updated 13 October 2025
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. 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); it was designed at the DEC Systems Research Center. [Rovner1985, 1986; vanLeunen1986] 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 design in August 1988 [Cardelli1988a], as implementations began at both labs. Experience from writing a Modula-3 compiler 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.
See the m3tk package present in most Modula-3 distributions.
![I [heart] M3](I_Heart_M3-tshirt.jpg)
![I [heart] M3](I_Heart_M3-badge.png){kind=icon}
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].
| Version | Date | Release description | Source | Original | Unpacked |
|---|---|---|---|---|---|
| 1.5 | 23 Jul 1990 |
>http://mail.digiater.nl/openvms/decus/lt90b2/m3/ | online | unpacked | |
| 2.05 | 13 Mar 1992 | newdoc.dvi in doc directory of 2.11 | – | – | |
| 2.07 | 20 Jul 1992 | Scan of hardcopy from Paul McJones | – | – | |
| 2.09 | ? | – | Klagenfurt's M3/PC | online | unpacked |
| 2.10 | ? | – | Bill Kalsow's TK50 cartridge | – | – |
| 2.11 | 7 Jan 1993 | online | unpacked | ||
| 3.1 | ? | – | Klaus Preschern's M3forDOS | online | unpacked |
| 3.5.3 | Jun 1995 | – | gatekeeper.dec.com via ftp.zx.net.nz | online | – |
| 3.6 | Sep 1996 | – | gatekeeper.dec.com via ftp.zx.net.nz | online | docs |
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 wa 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]
*** Antony Hosking believes he may still have a copy of the source code for this compiler.
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.
"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. ...
Credits
The projects were supervised by László Böszörményi." [Weich1996]
- Klaus Preschern did the first port of Modula-3 to the PC.
- Carsten Weich rewrote parts of Klaus Preschern's port and wrote the m3shell.
Klaus Preschern, after leaving the University of Klagenfurt, developed an alternative Modula-3 PC system, called EX32.
[Klagenfurt M3/PC readme]- - -
EX32 ("A 32-bit Extension of DOS") is a environment for the developement and execution of 32-bit applications with DOS. EX32 is a collection of DOS programs (drivers + kernel). It provides services for applications executed in protected mode. It does process management, virtual memory management, interprocess communication via pipes and it offers a file system with 32 character filenames. EX32 runs on MS-DOS 5.00, 6.00 and 6.02. You need a i386/i387 (coprocessor required) or upward (i486, Pentium). EX32 supports DOS XMS memory (but not EMS, VCPI or DPMI). No support for the i286. You should have at least 4 MB memory (8 MB or more recommended). The whole package occupies unzipped and untared approximately 44 MB of disk space. EX32 comes with GNU C++ (version 2.4.5), SRC Modula-3 (version 3.1, including threads), two C libraries, a graphics library for VGA and a number of commands (i.e. ls, cp, rm, mkdir, make, ...).[Preschern, AREADME.1ST, 1 June 1996]
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).
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:
- To provide facilities we would like for our research work.
- To provide facilities for our undergraduates.
- To provide a hackable base for future extensions." [Cambridge Modula-3, 1997]
- - -
"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.
"The PM3 distribution of 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.
See section 9 of [Cardelli1992].
This report is an earlier version of [Birrell1991b], describing a Modula-2+ version of the Thread interface and discussing its implementation in the Taos operating system for the Firefly multiprocessor workstation.
This report is an earlier version of [Birrell1991a], describing a Modula-2+ version of the Thread interface.
Chapter 3 of [Nelson1991] adds these:
"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+. [Cardelli1987, 1988]
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]
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.
Obliq-3D extends ANIM3D with the ability to program it using the Obliq programming language.
Open Network Computing (ONC) Remote Procedure Call (RPC), commonly known as Sun RPC, is a protocol originally developed by Sun Microsystems for their Network File System (NFS). David Nichols and Marvin Theimer, then at Xerox PARC, developed an implementation for Modula-3. This consists of a library (writtten in Modula-3 and C), a stub generator (written in C), and a set of examples. The README for version 1.3 notes it was adapted for version 2.06 of the DEC SRC Modula-3 compiler.
"Network objects provide functionality similar to remote procedure call (RPC), but they are more general and easier to use. Our network objects are not mobile, but we make it easy to communicate objects either by copying or by reference. Our objects are passive: they have no implicitly associated thread of control, nor is there any implicit synchronization associated with calling their methods. Our objects are not persistent or replicated. They are sufficiently lightweight that it would be perfectly practical to use one per menu button. We provide strong inter-program typechecking." [Birell1994]
The shared object package is designed to complement network objects. A network object allows an object to be shared by multiple processes, possibly on different machines, by creating surrogate objects in all processes except the one in which the object actually exists. From the point of view of the programmer and the executing program, the surrogate object behaves exactly like the original object. However, all method calls to the surrogates are synchronously sent to the original object where they are executed, with return values or exceptions propogated back to the calling process. ... The [shared object] model is the opposite of the network object package and is intended to complement rather that replace it. Instead of the object being stored at one location and remote method calls being used to access the object, shared objects are fully replicated in all interested processes, with any updates to the object being applied to all copies. [MacIntyre, sharedobj package DEC, circa 1995]
[Birrell1994a] observes:
"Powerful marshaling. As in any distributed programming system, argument values and results are communicated [by the Network Objects system] by marshaling them into a sequence of bytes, transmitting the bytes from one program to the other, and then unmarshaling them into values in the receiving program. The marshaling code is contained in stub modules that are generated from the object type declaration by a stub generator. Our marshaling code relies heavily on a general-purpose mechanism called pickles. Pickles use the same runtime-type data structures used by the local garbage collector to perform efficient and compact marshaling of arbitrarily complicated data types. Our stub generator produces in-line code for simple types, but calls the pickle package for complicated types. This combination strategy makes simple calls fast, handles arbitrary data structures, and guarantees small stub modules."
The implementation is described in Section 2.2 of [Birrell1994a]; it's based on an earlier Modula-2+ version described in [Birrell 1987b], which evolved out of ideas from Xerox PARC's Cedar system.
The original Modula-3 pickle package assumed that a pickle would be read on a computer with the same architecture (e.g., word size, byte order, and number representation) as the one on which it was written. When Blair MacIntyre was building systems for exploring distributed virtual environments, he wanted to support heterogeneous systems, and so wrote a new version of the pickle package that handled conversion between word size and byte order.
"The Inter-Language Unification system (ILU) is a multi-language object interface system. The object interfaces provided by ILU hide implementation distinctions between different languages, between different address spaces, and between operating system types. ILU can be used to build multi-lingual object-oriented libraries ("class libraries") with well-specified language-independent interfaces. It can also be used to implement distributed systems. It can also be used to define and document interfaces between the modules of non-distributed programs." [ILU 1.8 tutorial, May 1995]
ILU was developed at Xerox PARC by Bill Janssen and Mike Spreitzer, with contributions by others inside and outside PARC. Modula-3 was supported in early versions but dropped in version 2.0.
JVM was an application-embeddable Java Virtual Machine library released by Critical Mass in 1997.
"Using the JVM API, your native application (written in C, C++, or M3, for example) can load Java classes at run-time, call interpreted Java code, and implement Java native methods." [cmass.com/jvm via archive.org]
The following items are from cmass.com via archive.org:
[Conolly1995] contains some independent notes on the same idea.
Mscheme is a Scheme interpreter designed by Mika Nyström that is tightly coupled to Modula-3. It has a stub generator that can create a Scheme binding for any Modula-3 interface; it's even possible to implement a Modula-3 object type using Scheme to write the methods.
The original design was based on Peter Norvig's Jscheme. [Norvig1998]
Quest stands for Quantifiers & subtypes — a language to unify functional and object-oriented programming through subtyping. An implementation was built in Modula-3.
This program allows viewing and browsing graphs using a software analog of a fisheye lens, which is a very wide angle lens that magnifies nearby objects while shrinking distant objects. It is a tool for seeing both “local detail” and “global context” simultaneously. While such a view can be implemented using solely geometric transformations, we use a more general transformation that allows hierarchical or structured information about the graph to affect the view, extending previous research in fisheye views.
- - -
"The prototype is implemented using Modula-3 and Trestle, a portable X-toolkit. This project was the first Trestle application to be written, [*] beyond the handful of small examples in the distribution package. A number of features that we needed for red time animation (e.g., fast double buffering), and aesthetic drawings (e.g., curves and lines of arbitrary thickness) were not functional when the initial prototype was developed during the summer of 1991. We are currently upgrading to the latest release of Trestle.
[*] A Modula-2+ version of Trestle that doesn’t use the X-toolkit has been operational for a number of years at DEC SRC." [Sarkar1992b]
"Zeus is a kernel for both multi-view editors and algorithm animation systems. To a first approximation, it follows the spirit of BALSA, [Brown1984] but implemented in a multi-threaded environment using an object-oriented, strongly-typed language."
Hector was a set of tools and a feasibility study on high-tech corpus lexicography. Oxford University Press provided the lexicographers and a corpus of 20 million words of running English text; Digital Equipment Corporation Systems Research Center provided the high tech tools to enable the lexicographers to do all of their work on-line.
The Siphon facilitates joint software development between groups working at distant sites connected by low bandwidth communication lines. It gives users the image of a single repository of individually manageable units, typically software or documentation components. Users can lock and modify each unit, the result being propagated automatically to all sites. The repository is replicated at each site, and possibly on multiple file servers for greater availability and reliability. It was originally built using Modula-2+ and conventional RPC and later rewritten in Modula-3 using network objects. [Birrell1993a]
"Postcard is a user interface for reading and composing personal electronic mail, and for reading newsgroups and bulletin boards. It combines in an X-windows interface most of the functions of mail handling programs such as mh or xmh, and news-reading programs such as rn or xrn.
In addition, Postcard provides an integrated user interface for browsing the accumulated spool of newsgroups and bulletin boards, with a query language that includes full text indexing. This browsing is done through the ni(1) news indexing program." [Postcard man page, 1994]
Fsub is a Modula-3 [Nelson1991] implementation of the F<: calculus [Cardelli1991d],[2],[4]. This is the "smallest possible" calculus integrating subtyping with polymorphism. The type structure consists of type variables, "Top", function spaces, bounded quantification, and recursive types. The implementation supports type inference ("argument synthesis"), a simple modularization mechanism, and the introduction of arbitrary notation on-the-fly." [Readme.txt, Fsub 1.5.0]
Obliq is a lexically-scoped untyped interpreted language that supports distributed object-oriented computation. An Obliq computation may involve multiple threads of control within an address space, multiple address spaces on a machine, heterogeneous machines over a local network, and multiple networks over the Internet. Obliq objects have state and are local to a site. Obliq computations can roam over the network, while maintaining network connections. Obliq uses Network Objects.
Winner of the Most Influential POPL Paper Award in 2005 (for 1995).
"Visual Obliq is a programming environment for multi-user applications, expressed in the Obliq language.
In the Visual Obliq model, a distributed session is started by loading an application into an Obliq interpreter. This creates a session with a certain unique public name. Users running interpreters at other sites can connect to the session via the session-name. The act of joining a session causes the appropriate client code and user interface specification to migrate to the client's address-space and run there.
All the above activities can be supported and coordinated within the World-Wide Web framework. A Visual Obliq program may be regarded as a document with an appropriate MIME type. The text of an application is disseminated as a MIME-encapsulated document by a Visual Obliq gateway (vocgi)." [https://github.com/modula3/cm3/blob/master/m3-obliq/visualobliq/DESC]
Argo allowed medium-sized groups of users to collaborate remotely from their desktops in a way that approaches as closely as possible the effectiveness of face-to-face meetings. In support of this goal, Argo combined high quality multi-party digital video and full-duplex audio with telepointers, shared applications, and whiteboards in a uniform and familiar environment.
The JVideo library was written for Argo.
Juno-2 is a constraint-based double-view drawing editor designed by Greg Nelson and Allan Heydon. It followed Nelson's earlier system, Juno. [Nelson1985]
The goal of Virtual Paper was "making on-line reading more attractive than paper": the Lectern document viewer was based on a grayscale image-based document format, with OCR on DEC platforms and text-from-PostScript extraction on all platforms.
[The seed for this archival project was an email from Hansen Hsu asking if I was the Paul McJones referenced in the video.]
DeckScape is an experimental World-Wide Web browser based on a deck metaphor. A deck consists of a collection of Web pages, and multiple decks can exist on the screen at once. As the user traverses links, new pages appear on top of the current deck. Retrievals are done using a background thread, so all visible pages in any deck are active at all times. Users can move and copy pages between decks, and decks can be used as a general-purpose way to organize material, such as hotlists, query results, and breadth-first expansions.
Also, WebScape is an experimental World-Wide Web browser whose primary purpose is to test WebVBT.
WebCard allows the display of web pages within a folder-based email/newsreader. It was built using DEC SRC's established Postcard email/newsreader and the DeckScape web browser.
CAT is a web-based algorithm animation system. CAT augments the expressive power of Web pages for publishing passive multimedia infor- mation with a full-fledged interactive algorithm animation system. It improves on previous Web-based algorithm animations by providing a framework that makes it easy to construct new animations, including those that involve multiple views. Because views of the same running algorithm may reside on different machines, CAT is particularly well-suited for electronic classrooms.
ESC is a mechanical checker for software that catches many common programming errors, in particular array index bounds errors, nil dereference errors, and synchronization errors in multi-threaded programs. The checking is performed at compile-time. The checker uses an automatic theorem-prover to reason about the semantics of conditional statements, loops, procedure and method calls, and exceptions. The checker has been implemented for Modula-3. It has been applied to thousands of lines of code, including mature systems code as well as fresh untested code, and it has found a number of errors.
Millicent is a lightweight and secure protocol for electronic commerce over the Internet. It is designed to support purchases costing less than a cent. It is based on decentralized validation of electronic cash at the vendor's server without any additional communication, expensive encryption, or off-line processing.
ldb is a retargetable debugger for ANSI C. The original version supported MIPS, SPARC, VAX, and MC68000 targets. ldb has been shown to be very easy to retarget from machine to machine.
"SPIN is an operating system that blurs the distinction between kernels and applications. Applications traditionally live in user-level address spaces, separated from kernel resources and services by an expensive protection boundary. With SPIN, applications can specialize the kernel by dynamically linking new code into the running system. Kernel extensions can add new kernel services, replace default policies, or simply migrate application functionality into the kernel address space. Sensitive kernel interfaces are secured via a restricted linker and the type-safe properties of the Modula-3 programming language. The result is a flexible operating system that helps applications run fast but doesn't crash." [Brian Bershad, Craig Chambers, Susan Eggers—U. of Washington]
SPIN Modula-3 was based on DEC SRC Modula-3, with a set of additions and changes.
"Blair gave a demonstration of his 'augmented reality' system. Wearing a head-mounted display that reports three degrees of freedom (pitch, roll, and yaw), he showed a simple application in which the user is situated at the center of a compass, and various cities in the application's database appear as pyramids at the correct compass points (this is possible because the yaw value reported by the head-mounted display is an actual compass measurement).
The system is implemented in Modula-3 and Obliq, giving the programmer a toolkit that provides language-level support for building distributed virtual environments. The programmer can implement their applications in Obliq, Modula-3 or any combination thereof since all toolkit objects (such as trackers and graphical objects) are accessible from both languages. Data distribution is almost entirely transparent, encouraging the programmer to make heavy use of threads communicating via shared objects.
His system is based on the distributed data-object paradigm for distributed shared memory. He implemented a SharedObj package, similar in flavour to Modula-3 Network Objects, which allows any data object to be declared as a shared object that is replicated fully in any process that is interested in it. These shared objects support asynchronous data propagation with atomic serializable updates, and asynchronous notification of updates. To accomplish this, he relied on existing Modula-3 packages, especially Network Objects and Obliq-3D." [1995 Modula-3 Users Group]
- - -
COTERIE is a testbed for fast prototyping of distributed virtual environment systems (MacIntyre and Feiner 1996). It is designed to support the creation of virtual environments with multiple simultaneous users interacting with many heterogeneous displays and input devices. The testbed is designed around a multi-threaded, modular, object-oriented programming model and supports fully transparent distributed communications via both client-server and replicated distributed objects. By building applications as groups of cooperating threads, a single programming model can be used for both single and multiprocess programs. Both interpreted (Obliq) and compiled (Modula-3) languages are simultaneously available to the application programmer. [COTERIE home page at graphics.cs.columbia.edu, 199x]
- - -
"I even still have all the old code from my grad school days 😂." [MacIntyre, personal communication, 22 September 2025]
CVSup is a general-purpose tool for mirroring collections of files over the internet. It also includes special features and optimizations specifically tailored to CVS repositories. It was originally developed by John D. Polstra for the needs of the FreeBSD Project.
These were important resources in the 1990s:
These web sites were active during the Elego years:
This web site is the current center of Modula-3 activity:
These tutorials and reference materials are a useful starting point:
See also [Nelson1991], [Böszörményi1996], and [Dagenais1997].
Errata. 22 March 1993, 6 pages. PDF
Threads: The Modula-3 Systems Journal. Issues 1-3, Fall 1995-Fall 1997. https://www.modula3.org/threads/
