User-Driven Development
Custom Implementation
Responsive Support

A non-profit network of experts helping
the medical community use Vista

We live and breathe M code, so of course, we have some opinions on the matter.


Vista software is written in the M programming language, which was designed specifically for writing medical software (indeed, to this day most Electronic Health Record (EHR) software is written in M). It’s powerful, flexible, and forward-thinking, with features and design elements back in the 1960s that other languages didn’t discover until the 1990s or later.

Initially developed in 1966 at Boston’s Massachusetts General Hospital [MGH], the M language became an ANSI standard in 1977, and an ISO standard in 1992. Both standards have been updated over the years—however, the M Development Committee (MDC) has taken special care to ensure that older programs will still run on modern M systems. This has enabled several M-based systems to operate for decades without breaking whenever their M environment is updated.

“Mumps” and M

The original name for the language that MGH designed was called “MUMPS”. It was “backronymed” as the “Massachusetts General Hospital Utility Multi-Programming System” as a joke, but it wasn’t ever really an acronym. In the years since, in recognition of that, it’s often been spelled “Mumps.”

You’ll still see references to Mumps, but back in the late 1980s, implementors of the language expressed some frustration in trying to market a language named for a disease, and began to push to formally rename the language to something less evocative.

This wasn’t without controversy. Reactions in the community varied—some felt that the community of enthusiasts was being betrayed for marketing purposes and left the standards organization in protest, others adopted the compromise spelling of “M[UMPS]”, which treated the name the same way as M language elements (which had an abbreviated form and a full form), and still others were more ambivalent. But even today, a few M implementations are invoked with the command mumps, and many developers (an often stubborn and ornery bunch) still refuse to call it anything other than Mumps.

(Of course, these days, some would consider having a language with a “viral name” to be a good marketing strategy.)

Nevertheless, “M” was adopted as the formal designation for the language by the language standard of 1995, and we have followed suit (not without some residual nostalgia of our own).


|\ _,,,---,,_ /,.-'' -. ;-;;,_ |,4- ) )-,_..;\ ( `'-' '---''(_/--' `-'\_)

The beginnings of M date back to 1960, long before the Internet, email, the Web, and cat pictures. It didn’t stagnate, though; it evolved over time, anticipating all those things. (Well, maybe not the cat pictures, exactly.)

From the beginning, M had a built-in database; persistent and easy to use, and ran in its own virtual machine to isolate it from the underlying hardware to make the code as portable as possible. It supported complex data structures, advanced string processing. complex string processing, and was very parsimonious about memory.

It predated a number of fairly common programming conventions these days (such as the frequent use of regular expressions; M has its own syntax for pattern matching), and it breaks some of the most common conventions that exist in other languages. Yet some of those unusual qualities are strong points, and M routinely fares well compared to today’s hot buzzwords. (Imagine the expressions on M programmers’ faces when “NoSQL” was all the rage a few years ago.)

All these, upon first exposure to the language, tends to bring accusations of M being “too old” and “dead”—which couldn’t be further from the truth. It is true that M allows for very concise and hard-to-read code—it had to be back when RAM was measured in kilobytes and persistent storage was limited to a very small number of megabytes—but M adapts well to modern memory limits and evolving technology. Here at VEN, we routinely write readable, structured code, even while admitting that there is a lot of code in Vista that’s written in a very tight, abbreviated style. Whenever we have occasion to touch legacy code, we bring it up to date as part of the refactoring process to improve readability and make it easier to maintain.

One of the features of M was that the language continued to evolve, and there remains several active communities. Several standards of the language were pubished, and we support every effort to bring back the language’s development committee and publish the standards work that was put on hold in 1999.

M’s flexibility has enabled us to write fully-featured web applications, connect with all sorts of laboratory equipment, exchange data with other devices or organizations, and have fully Internet-aware applications—pretty reasonable for a language whose origins predate all that—while still allowing programs written decades ago to still run.


M is a standardized language and virtual-machine environment with several available implemeentations. Please note that we are not currently sponsored by any of these.

At this writing, there are three implementations of M that can support the Vista environment:

  • GT.M, created by Fidelity Information Systems (based on a much older version of M from Greystone Technologies). It’s an open-source implementation; the source code is on SourceForge, and you may install it by following the instructions that accompany the install script (this for GT.M 7.0-002, released at the end of March, 2022). It runs under Linux.

  • YottaDB, a well-crafted fork of GT.M—it remains fully compatible with GT.M, while adding some impressive capabilities. It, too, is open-source (hosted at GitLab), and is presently our favorite M implementation to use with Vista. Like GT.M, it runs under Linux, but it also has the ability to exchange data with programs written in other lanugages, such as C, Perl, Python, JavaScript, Go, and Rust (as of this writing). Very much worth checking out. The latest version is r1.34, released 2022-02-25.

  • The technology folk at VA, however, prefer to pay a lot of money for their preferred M implementation, which a company called InterSystems is all too happy to accommodate, so VA has traditionally used an expensive closed-source implementation called Caché—which is being discontinued—and we expect that VA is in the process of migrating to IRIS.

Each implementation has its strengths and weaknesses, and offers various implementation-specific features. Our developers work in all three of these environments with complete confidence (though we do try to avoid implementation-specific features so that code may remain as portable as possible).

We know of one other implementation that does not currently run Vista, but is actively working towards that, and we very much look forward to being able to run Vista on it as well:

  • Reference Standard M (RSM) is an open-source implementation by Fourth Watch Software (hosted at GitLab) written and maintained by the remarkable David Wicksell. It is the evolution of Mumps V1 (MV1), written by Ray Newman, who retired and left MV1 to David. It runs very well on a variety of operating systems, including Linux, FreeBSD, NetBSD, OpenBSD, AIX, MacOS, Windows (in Cygwin and WSL) and even the Raspberry Pi.

There are other M implementations that we’re familiar with, but they are not able to run Vista and we don’t expect them to have that capability anytime soon. These are:

  • FreeM, a fascinating project hosted on GitLab, actively maintained by John P. Willis of Coherent Logic Development. The latest version is 0.51.0, reeased 2022-01-03. John also has an excellent blog on all things M.

  • MiniM, actively maintained by Eugene Karataev. The current version is 1.31, released 2021-05-21. It runs under Windows, Linux, FreeBSD and MacOS, and provides data access to other languages like Java, C#, and others.

  • Open Mumps, by Kevin O’Kane. (It’s also variously called “Open Mumps,” “GPL Mumps” and “Mumps II.”) The latest version is 22.03.5, released 2022-03-05.

  • M21, a proprietary version of M maintained by Keith Snell and others at M21. It runs on several versions of Linux and Unix.