MuPAD

MuPAD, the Multi Processing Algebra Data Tool, is a computer algebra system and the programming language that comes with it. It was built by the mathematics group of Benno Fuchssteiner at the University of Paderborn, Germany, starting around 1990. It was unusual in two ways. It was designed from the start to run on parallel computers, which few general-purpose computer algebra systems attempted at the time. And for most of its life it was free for research and education, while its competitors Maple and Mathematica were expensive commercial products. MuPAD was later sold by the spin-off company SciFace Software, then bought by MathWorks in 2008. It disappeared as a product of its own but survives as the symbolic engine inside MATLAB’s Symbolic Math Toolbox.

History & Origins

A parallel algebra system from Paderborn

MuPAD came out of the Institut für Automatisierung und Instrumentelle Mathematik (AutoMATH) at what was then the Universität-Gesamthochschule Paderborn. The German Research Foundation (Deutsche Forschungsgemeinschaft) and the Heinz Nixdorf Institute funded the work. From 1989 the group published its own magazine, mathPAD. Its early issues reviewed other systems, including a 1991 benchmark comparison of Maple V, Mathematica 1.2 and Macsyma on a Sun 3/60. Within a few years nearly every issue was about MuPAD.

The project’s first public overview appeared in the September 1991 mathPAD, a special issue for the conference of the German Mathematical Society (DMV). The issue set MuPAD alongside REDUCE, Maple, Mathematica, Axiom, DERIVE and a dozen other systems. The overview, by Andreas Kemper, Oliver Kluge, Karsten Morisse, Holger Naundorf, Waldemar Wiwianka and Fuchssteiner, called MuPAD “a new computer algebra system” built for parallel machines. Its stated main goal was letting users handle data too large for other computer algebra systems. The design was:

• a kernel written in C;
• a target architecture of shared-memory multiprocessors, implemented first on a Sequent Symmetry with ten Intel 80386 processors;
• a second implementation that simulated a multiprocessor on a network of workstations using Caltech’s Cosmic Environment software;
• a memory manager that presented every machine to the programmer as shared memory, and stored identical data only once.

The article said plainly that the system was “still in the middle of development”. Planned work included a graphics package, larger libraries, and eventually automatic parallelisation of user programs.

Version 1.0 and CeBIT ‘93

Wiwianka, the project manager, published an article on MuPAD in the Sun user-group magazine SUGinfo in 1992. That year Naundorf also finished his diploma thesis on Mammut, the memory allocation unit under the kernel. No surviving source gives the date Version 1.0 was released. The group’s special issue on Version 1.0 was typeset in February 1993 as handout material for CeBIT ‘93 in Hanover, where MuPAD had its own stand. The issue describes a working system that was:

• free for research institutions and educational establishments;
• available for UNIX workstations and the Apple Macintosh, with further ports under way;
• equipped with an X Window front end (XMuPAD, built on XView), a hypertext help system based on TeX, a source-level debugger built into the kernel, and a 3D graphics tool called VCam (“Virtual Camera”);
• documented by a manual of about 450 pages that Birkhäuser published that year.

Wiwianka was killed in a road accident in Norway on 18 July 1993. In the November 1993 mathPAD, Fuchssteiner wrote that the system would not exist in its current form without him. On 29 September 1993 the German Federal Minister of Education and Science presented MuPAD with the German-Austrian university software prize as outstanding teaching software in mathematics.

Growth through the 1990s

Version 1.2 (described in late 1993 and early 1994) changed the language substantially, mainly through domains (see below). By March 1994 it was listed for Sun SPARCstation under SunOS and Solaris, IBM RS6000, Silicon Graphics, Linux PCs and the Macintosh. Prerelease versions existed for 80386 MS-DOS machines and the Sequent Symmetry. Version 1.2.1 (December 1994) added the linalg package and dynamic modules, routines written in C (with C++ promised “in the near future”) that were compiled to machine code and linked into the running kernel on demand, and could be unloaded again. Ports followed for DECstation/Ultrix and FreeBSD. In a May 2000 file listing, the official download mirror carries Unix builds of 1.2.9 through 1.4.2, plus OS/2, 68k and PowerPC Macintosh versions, and Windows installers for two editions, MuPAD Light and MuPAD Pro.

SciFace and the end of university funding

In 1997 the group founded SciFace Software GmbH & Co. KG to turn the research into market-ready products. From then on SciFace developed MuPAD together with the university group and partners elsewhere. A 1999 Linux Journal review of version 1.4 (released March 1998) called MuPAD the product of “one small and chronically underfunded research team”. It noted that the system was free for single users on Linux, with a free license key to lift its memory limits, while the more polished Windows interface cost money.

The free tier ended in 2005. heise online reported in November 2005 that Fuchssteiner, AutoMATH’s last remaining professor, would retire in 2006. The university would then dissolve the institute and had ruled out central funds to keep it going. SciFace had already taken the free MuPAD Light offline, so future school and university projects would need paid licenses. The company, in which Fuchssteiner held a significant stake, now had to compete head-on with the much larger Wolfram Research and Maplesoft.

MathWorks

MathWorks bought SciFace in September 2008. Until then, the Symbolic Math Toolbox for MATLAB had been built on the Maple engine. In R2008b it switched to MuPAD, which was then withdrawn from sale as a separate product. For years MATLAB users could still start a MuPAD notebook with the mupad command. MathWorks first stopped updating the notebook and then removed it in R2020a, recommending the MATLAB Live Editor instead and providing convertMuPADNotebook to turn notebooks into live scripts. Removing the notebook did not remove the engine. MathWorks staff wrote in 2023 that it is the MuPAD Notebook interface that was removed, “not the symbolic computation engine”.

Design Philosophy

MuPAD’s designers wanted to:

1. Scale beyond a single processor. The name itself says “Multi Processing”. The language had parallel constructs from its earliest versions, and they also ran on the sequential builds.
2. Stay open to the user. The 1993 overview stressed that users could inspect and change the system’s own library routines. Library code was written in MuPAD’s own language and shipped as readable source, and any system function could be overwritten by a user-defined procedure.
3. Feel familiar to programmers. The 1994 feature sheet describes “a functional programming language with procedural extensions and Pascal-like syntax”. Procedures and statements are ordinary data objects that can be manipulated at run time.
4. Be free for science and teaching. For its first decade and more, academic users paid nothing.

Key Features of the Language

Pascal-style blocks with explicit terminators

Every construct closes with a matching keyword, much like Pascal or Modula-2: end_if, end_for, end_while, end_repeat, end_case and end_proc. This procedure is the example from the 1993 language summary:

max := proc(x, y)
begin
  if x > y then x else y end_if
end_proc:

A procedure has no name of its own. It is a value, and it gets a “name” only by being assigned to an identifier, so after f := max the call f(3, 5) works exactly like max(3, 5). The documented control structures are if … then … elif … else … end_if, for … from … to … step … do … end_for, while … do … end_while, repeat … until … end_repeat and case … of … do … otherwise … end_case, plus break, next, error and return.

Sequences, ranges and sets as operators

Expression sequences are built into the language. The $ operator generates them:

a $ 3;              // a, a, a
i^2 $ i = 1..5;     // 1, 4, 9, 16, 25

.. builds ranges, and union, intersect and minus work on sets directly.

Evaluation and dynamic scoping

As in other computer algebra languages, a variable can have no value at all and stand for itself in a formula. The early manuals spend a lot of space on controlling evaluation, through hold, eval and evaluation levels. The 1994 language summary also explains that MuPAD then used dynamic scoping for global variables, so a procedure sees the bindings visible when it runs. Pascal, by contrast, uses lexical scoping.

Parallel constructs

The language specified two levels of parallelism. Micro-parallelism ran on a cluster of processors with fast communication. Macro-parallelism ran across a network of clusters, using message queues, pipes and network-wide global variables. The parallel for loop creates one task per iteration and puts it on a task stack, from which idle processors take work:

for i from 1 to 10 parallel private y;
  y := i^2;
  y + 1
end_for

The loop finishes only when all of its tasks have finished, and it returns the sequence of their results. A second form, for x in expr parallel …, runs over the operands of an expression. The 1991 overview also mentions a parbegin block.

Domains: user-defined algebraic structures

Version 1.2 introduced the domain data type, MuPAD’s way of defining abstract data types. A domain holds its own methods, and the kernel dispatches overloaded operators to them. The experimental domains package built category and axiom constructors on top of this. Klaus Gottheil wrote that “most of the concepts in the domains package can be traced back to ideas in AXIOM”. The difference was that in Axiom these are part of the strictly typed language, while MuPAD supplied them as a library over an untyped language. In this 1994 example, Zmod(7) builds the integers modulo 7, and its new method is an ordinary procedure:

proc(x) begin new(Zmod(7), x mod 7) end_proc

The system’s own libraries were also domains. The groebner library, for instance, began with groebner := domain(): and then filled in groebner::name, groebner::info and groebner::interface. In later versions this design is why an object such as a matrix carries its own operations. After A := matrix([[1,2],[3,4]]), expressions such as A + A, A^-1 and exp(A) all dispatch to the matrix domain’s methods.

Polynomials as a separate type

Gottheil noted that Maple and Mathematica represented polynomials as ordinary expressions. Version 1.2 instead added a dedicated type, DOM_POLY, with its own fast arithmetic and coefficient rings such as Expr and IntMod(n). The group’s reason was that MuPAD’s internal simplifier sorts the terms of sums, which made ordinary expressions a poor fit for fast polynomial arithmetic.

Extending the kernel

From 1.2.1, dynamic modules let users write routines in C, compile them, and link them into a running kernel; the December 1994 description gives speed and full access to the kernel’s internal data structures as the reasons. At first this worked only on SunOS/Solaris, Irix 5.1 or later and AIX 3.1 or later. Andreas Sorgatz, who was in charge of compiler and module management, later wrote a manual for the 1.4 module system. English Wikipedia adds that later versions could also embed Java code; that claim is not sourced there.

Graphics and the Notebook

MuPAD’s graphics are often described as a particular strength, though English Wikipedia flags that claim as needing a citation. VCam, the original plot tool, ran under both X Window and MacOS by 1994. In 1994 it already offered 3D surfaces drawn as wire frames, meshes, hidden-line images, colour patches or transparent objects, with user-defined colour functions written in MuPAD. German Wikipedia states that from January 2004 MuPAD was the first computer algebra system with transparent surfaces in 3D. That claim is unsourced there, and it conflicts with the 1994 feature list above, which already includes a “transparent” 3D style. Later commercial versions moved to a notebook interface, like a word processor, that mixed input, output, formatted text and embedded 2D/3D animations. MathWorks shipped that interface until R2020a.

Evolution

Current Relevance

You can no longer buy MuPAD as a product, and its Notebook interface is gone. The language is still running, though, because every symbolic computation in MATLAB’s Symbolic Math Toolbox goes through the MuPAD engine. MathWorks documentation still notes that evalin(symengine, …) and feval(symengine, …) take MuPAD syntax, and MathWorks still publishes a page on the differences between MATLAB and MuPAD syntax. Scientific WorkPlace and Scientific Notebook also embedded the MuPAD kernel. According to Wikipedia, when MacKichan Software closed in 2021, that dependency on the closed-source MuPAD kernel is the reason it gave for not releasing Scientific WorkPlace as open source.

Some of MuPAD’s community lives on elsewhere. MuPAD-Combinat, the algebraic combinatorics project led by Nicolas Thiéry and Florent Hivert, decided in June 2008 to move to the open-source Sage system, three months before the MathWorks acquisition. The work continued there as Sage-Combinat. Its old MuPAD code remains available under the GPL.

Why It Matters

MuPAD is a rare case of a full general-purpose computer algebra system built at a university, given away to academics for more than a decade, and then sold. It appears to have been one of the earliest general-purpose systems designed from the start for parallel hardware. Its domains brought ideas from Axiom into an untyped language with Pascal-like syntax. Its graphics are reportedly what many users remembered it for. Its history also shows how fragile university-funded software can be: the free tier ended when the founding professor retired and his institute was closed, and the code reached its widest audience only after a large company bought it and folded it into MATLAB.

Sources and Verification Notes

• Primary sources: the MuPAD group’s mathPAD journal, issues 1(2) April 1991, 1(3) September 1991, 3(1) March 1993, 3(2) November 1993, 4(1) March 1994 and 4(2) December 1994. These are PostScript files on the GWDG mirror (ftp5.gwdg.de/pub/math/mupad/mathpad/), whose README gives the issue dates. The mirror’s ls-lR.MuPAD (May 2000) and distrib/unix/ listings supplied the release file dates.
• Bibliography: the MuPAD BibTeX file at math.utah.edu, for Wiwianka’s SUGinfo 2/92 article and the 1993/1994 Birkhäuser books.
• News and reviews: heise online, “Schwere Zeiten für MuPAD”, 19 November 2005; Alasdair McAndrew, “MuPAD”, Linux Journal, July 1999.
• MathWorks: the “Symbolic Math in MATLAB” discovery page; R2021a mupad reference page (removed in R2020a); MATLAB Answers thread 1974104 (May–June 2023).
• Other: MacKichan’s CAS page (MuPAD kernel after 4.1 Build 2347); the Sage-Combinat wiki and the mupad-combinat.sourceforge.net page (June 2008 move); English and German Wikipedia for background only.

Not verified: the exact release date of Version 1.0. The year 1992 is the catalog’s, and it fits the evidence (the project was public in 1991, written about in 1992, and shown as Version 1.0 in early 1993), but no dated release announcement has been found. The exact date in September 2008 of the MathWorks purchase and of the product’s withdrawal (Wikipedia gives 28 September 2008) is also unconfirmed. So are the release dates of MuPAD 2.x–4.x, and German Wikipedia’s claim that 4.0.6 was the last SciFace version, so they are left out of the timeline. PTC user-forum posts say Mathcad 14 replaced Maple with MuPAD as its symbolic engine. No official PTC source was found, so this is not listed as a notable use.