Use MathJet alongside (or instead of) the tools you already know.
MathJet® fuses spreadsheet, scripting, and interactive visualization technologies into one C++ process. Depending on what you're coming from, that makes it useful as a replacement, a companion, or a successor. Pick the door below that fits your starting point.
If you've reached the limits of what MATLAB can do for you — whether that's the per-seat cost, the missing platform, the recent shift to subscription-only licensing, or the friction of stitching MATLAB output into a Python or R workflow — MathJet picks up where MATLAB leaves off and adds the things MATLAB never quite delivered.
MathJet.m files run natively.
MathJet's own interpreter is MATLAB-syntax compatible. Open an
existing .m script in MathJet, run it, and the script
behaves the way you expect — same syntax, same semantics for the
language constructs MATLAB ships with the base product.
.mjw) opens identically
across platforms. No license server to phone home to, no per-machine
activation dance, no recurring per-seat fee.
.xlsx natively, and any MATLAB
variable can be exposed as an editable cell range. No more
xlsread / writematrix round-trips.
=numpy.mean(A1:A10) directly in a cell — or call
into your .m functions, R functions, or Python functions —
alongside standard Excel formulas. The formula engine and the
scripting engine are the same engine.
| What's familiar | What's new |
|---|---|
.m script syntax | The same syntax, running in a native C++ interpreter, in the same process as Python and R |
| Plot windows, figure editing, axis manipulation | Plots that respond to spreadsheet edits in real time |
| Workspace browser with variables | Variables that double as editable spreadsheet ranges and plot inputs |
| Command Window for ad-hoc commands | The same command window, plus a polyglot formula bar in the spreadsheet |
save / load for .mat files | .mjw workspace files that capture everything: figures, scripts, variables, layout |
You have a daily script in MATLAB that reads a CSV, runs a model, and produces a plot. In MathJet:
.m script in MathJet's editor.=scipy.signal.welch(my_signal) in a cell to bring in a frequency-domain view alongside the time-domain plot, without leaving MathJet.
No conversion, no rewrite, no xlsread / writematrix glue.
Existing .m files open directly. Existing .mat
files load (read support; check the migration guide for write support
and edge cases). Existing plotting calls produce native MathJet figures.
The full guide walks through .m syntax compatibility,
common gotchas, and equivalent-workflow examples for the situations
that don't translate one-to-one.
MathJet does not replace MATLAB Toolboxes (Statistics, Signal Processing, Image Processing, Optimization, etc.) or Simulink. For users whose work depends on those, MathJet is a complement, not a replacement.
In practice, many MATLAB workflows that look toolbox-bound are fine
to migrate — scipy, statsmodels, and similar
Python packages cover a substantial portion of the Stats / Signal /
Optimization toolboxes, and MathJet's polyglot environment makes those
calls accessible from .m code, Python cells, or the
formula bar. The migration guide goes through this case by case.
If you've felt the rough edges of working in Jupyter — the kernel
restart that wipes thirty minutes of loaded data, the cell you ran
three hours ago that you can't un-think, the static
matplotlib plots you can't share interactively, the
cross-tool dance between Jupyter and Excel — MathJet keeps the parts
of Jupyter that work and replaces the parts that don't.
.ipynb files open directly.
Connect to a standard Jupyter or IPython kernel and your notebook
runs exactly as it does today.
print(), an editable spreadsheet view of any DataFrame,
and conversion of static matplotlib plots to native
interactive MathJet graphics — all without changing a line of code.
pandas.DataFrame into the spreadsheet view, edit
a cell, and the underlying DataFrame updates. No
df.to_excel() round-trip.
| What's familiar | What's new |
|---|---|
.ipynb file format | Same file, opens directly in MathJet |
| Standard Jupyter / IPython kernel | Optional MathJet kernel that adds live variable inspection and interactive plots |
pandas, numpy, scipy, matplotlib | All work as-is — MathJet embeds CPython, your pip packages stay where they are |
| Cell execution model | Same — but with live state visible without print() |
matplotlib plots | The same plotting calls produce interactive native graphics that respond to data changes |
You have an existing notebook that does a data wrangling pass on a CSV:
.ipynb directly in MathJet.matplotlib calls produce an interactive native plot. Click a point; the corresponding row in the spreadsheet highlights..ipynb. Other people on your team using vanilla Jupyter open it and see exactly what they'd expect.
Open existing .ipynb files directly. The standard Jupyter
execution path works as a drop-in. The MathJet kernel is opt-in per
session — pick it when you want the upgrades.
Read the full Jupyter migration guide → (forthcoming)
MathJet is not a replacement for the Python ecosystem — it embeds
Python and adds capability around it. Your existing pip
packages, your existing notebooks, your existing workflow continue
to work.
If your workflow is happily Jupyter-native, never crashes a kernel, never needs plots that live outside the notebook, and never crosses into spreadsheet territory, you may not need MathJet. The pitch is for the friction points; if you don't feel them, keep doing what works.