Is there an open source implementation of Mathematica-the-language?

Question

I've seen questions before such as "What is the best open-source equivalent for Mathematica?", but that specific question (and that line of inquiry in general) cares more about the computer algebra system and less about the core language and its unique and powerful features.

My interest in Mathematica come from a slightly different angle--namely, I find a tremendous amount of value in the power and flexibility of the language that Mathematica implements (I think of it as a slightly less scary looking syntax for Lisp with some very novel additions such as the powerful pattern matching system).

Are there any projects that have made a concerted effort to build a Mathematica-the-language work-alike instead of focusing on the Computer Algebra System?

Mathics is the closest project I've found so far (since it does, in fact, try to stay faithful to Mathematica syntax where it can), but even it pitches itself as a computer algebra system. And it was written in Python, which isn't bad by itself, but it sets itself up to not be as fast as Mathematica for computationally intensive tasks.

It seems to me that Wolfram Research would actually benefit tremendously from having an even bigger programmer community around Mathematica as a language and developer platform, because more packages would be produced to solve more off-the-shelf programming problems (just like almost any other programming language).

An open (or at least freely available) implementation of the core programming language wouldn't even dilute their secret sauce which I would say primarily lies in Mathematica's base of mathematical rules and algorithms, in the scientific computing tools that they've bundled into one enormous and broad package, and into the insanely well-integrated notebook experience that they should have no trouble keeping ahead of any kind of open source project.

Answer 1

I've been collecting these links for a while, so this question is a good excuse for a link dump. I'm not sure which project is the "best", but I think that mathics and symja are two of the more active and developed projects.

Lisp:
MockMMA is probably the first implementation of the Mathematica language. It was written by Richard Fateman who had a bit of a scuffle with Wolfram Research over the code.

Python:
Mathics (which you mentioned in the question) is primarily a syntax layer ontop of sympy and sage, not an independent implementation of the Mathematica language.
Pythonica is an abandoned python implementation of Mathematica.

Java:
symja is a pure Java library for symbolic mathematics that uses Mathematica notation and supports Rubi Integration rules.
omath is an project that is still under development that will have a Mathematica like syntax, but does not aim to blindly copy Mathematica.

Go:

expreduce an experimental computer algebra system written in Go.

---

The omath page also has some interesting links to papers describing some of the Mathematica language's algorithms:
Matching in flat theories by Temur Kutsia. A detailed description of Mathematica's flat pattern matching. (But quite technical!) (original link)

Mathematica as a Rewrite Language by Bruno Buchberger.

On the implementation of a rule-based programming system and some of its applications by Mircea Marin and Temur Kutsia. These people obviously understand Mathematica's pattern matching enumeration system forwards and backwards.

Discussions about whether computer languages can be copyrighted, 1, 2, 3.

Answer 2

Yes.

According to Mathematica's creator, Stephen Wolfram, Mathematica is just an implementation of a language that as of 2013 has been named Wolfram

Two other implementations have been developed by a Kernel Developer at Wolfram Research (poeschko.com).

One is called Mathador, which is implemented in C++ and is no longer maintained, but the source may be of interest to you.

The other is called Mathics and is currently (as of 2022) being maintained. It is implemented in Python, uses the SymPy package to perform symbolic computations, and has a web browser interface. You can check it out online at mathics.org.

Answer 3

Expreduce

Expreduce is a new MIT-licensed project that has a fairly complete implementation of the language semantics. Further, it has a nice collection of definitions that provide CAS functionality, along with documentation to match. There is also a large testing suite for verification. It aims to have a small core with most of the functionality implemented in the language itself using the rewrite rule paradigm. The kernel is written in Go. Here are some examples of what can be computed:

In[1]:= D[Cos[Log[Sin[x]]+x]+x,x]

Out[1]= (1 + (-1 * (1 + Cot[x]) * Sin[(x + Log[Sin[x]])]))

In[2]:= Integrate[5*E^(3*x),{x,2,a}] // Expand

Out[2]= ((-5/3 * E^6) + (5/3 * E^(3 * a)))

The CAS functionality uses a collection of rewrite rules. For example, the product rule for derivatives is implemented using only one line:

D[a_*b_,x_] := D[a,x]*b + a*D[b,x]

The implementation is currently lacking in visualizations and the functionality of Solve among other things. Right now it is just a terminal, but perhaps there will be a Jupyter notebook interface for it in the future. It has virtually no dependencies. Since it does not call out to another open source CAS, there are many operations that it cannot do. Fortunately, the rule paradigm allows for fast development of new features. It could also benefit by getting the Risch algorithm for integration. Right now the integrations are mostly solved using heuristics.

mmaclone

There is also an interesting Haskell implementation of the pattern matching engine by Yonghao Jin at https://github.com/jyh1/mmaclone.