Math and Scientific Computing Tools in 2026 — Mathematica / MATLAB / Maple / SageMath / Julia 1.11 / R + Posit / JAX / GeoGebra / Desmos / GAP / Macaulay2 Deep Dive

Prologue — "Doing math on a computer" means something different now

The math software of the late 20th century was simple. One tool — Mathematica, MATLAB, or Maple — was supposed to do everything. Students paid a thousand dollars per license, universities paid a hundred thousand. Code lived inside that tool's language forever.

The 2026 landscape is different.

• Open source has genuinely caught up. SageMath started in 2005 and after two decades has become a complete CAS. Julia froze its first stable ABI in 1.11. R plus tidyverse is the statistical standard, and the Python NumPy/SciPy/SymPy/Pandas/Polars combination is the de facto scientific stack.
• Commercial software is still alive. Mathematica owns LLM integration and natural-language functions, MATLAB owns Simulink and industrial certification, Maple owns precise textbook integration. They simply lost the "first tool a student meets" position.
• The cloud arrived. CoCalc, Wolfram Cloud, Google Colab, Posit Cloud, Hex, and Deepnote moved notebooks into the browser. SaaS is overtaking the license model faster than expected.
• AI entered the room. Wolfram added LLMFunction to Mathematica, MathWorks added MATLAB Copilot, Posit ships an AI assistant in Positron. SymPy and SageMath accept natural-language input through Jupyter AI.

This post walks the entire terrain. The four commercial giants (Mathematica/MATLAB/Maple/Magma), the open generalists (SageMath/Julia/R/Python), the education tools (GeoGebra/Desmos), the specialized algebra systems (GAP/Macaulay2/Singular), cloud platforms (CoCalc/Wolfram Cloud), and the CAS camp (SymPy/Symbolics.jl/Maxima/Reduce/Pari-GP). At the end, recommendations for students, researchers, engineers, and educators.

1. The 2026 math / scientific computing map — four categories

Too many tools. Let me carve them up first.

┌────────────────────────────────────────────────────────────────┐
│              2026 math/sci-compute four categories              │
│                                                                │
│  ┌─────────────────┐    ┌─────────────────────┐               │
│  │ Commercial      │    │ Open-source         │               │
│  │ generalists     │    │ generalists         │               │
│  │                 │    │                     │               │
│  │ - Mathematica   │    │ - SageMath          │               │
│  │ - MATLAB/Simulink│   │ - Julia 1.11        │               │
│  │ - Maple         │    │ - R + tidyverse     │               │
│  │ - Magma         │    │ - Python sci-stack  │               │
│  └─────────────────┘    └─────────────────────┘               │
│                                                                │
│  ┌─────────────────┐    ┌─────────────────────┐               │
│  │ Education       │    │ Specialized / CAS   │               │
│  │                 │    │                     │               │
│  │ - GeoGebra      │    │ - GAP (groups)      │               │
│  │ - Desmos        │    │ - Macaulay2 (AG)    │               │
│  │ - Wolfram Alpha │    │ - Singular          │               │
│  │ - Khan / Mathway│    │ - PARI/GP (numbers) │               │
│  │                 │    │ - Maxima / Reduce   │               │
│  │                 │    │ - SymPy / Symbolics │               │
│  └─────────────────┘    └─────────────────────┘               │
└────────────────────────────────────────────────────────────────┘

Different categories carry different mental models.

Real research labs usually mix two or three tools. MATLAB for simulation, Mathematica for symbolic solves, Python for data crunching. Or Julia for PDEs, R for statistical validation, SageMath for algebra checks. The era of one tool doing everything well is over.

2. Wolfram Mathematica — the premium symbolic standard

Mathematica, released by Stephen Wolfram in 1988, has been the symbolic computation standard ever since. The 2026 line is version 14.x. It runs on Wolfram Language (WL), a functional pattern-matching language where every value is an expression.

Core strengths

• Symbolic depth. Integrate, Solve, DSolve, Series, Reduce — almost every closed-form solve is one line.
• Wolfram Alpha integration. Natural-language input =Seoul temperature yesterday evaluates inside an expression.
• Massive built-in data. ChemicalData, CountryData, FinancialData, GenomeData — hundreds of academic datasets exposed as functions.
• Notebook UI. Expressions, plots, text, and interactive widgets (Manipulate) live in the same cell. Interactive demos are a strength.
• LLM integration. Since 13.3, LLMFunction and ChatEvaluator are official. You can call GPT-4 or Claude from inside Mathematica and treat the result as a WL expression.

A code fragment

(* Solve a differential equation *)
DSolve[{y'[x] + y[x] == Sin[x], y[0] == 1}, y[x], x]

(* Interactive widget *)
Manipulate[
  Plot[Sin[a x + b], {x, 0, 2 Pi}],
  {a, 1, 5}, {b, 0, 2 Pi}
]

(* LLM call in one line *)
LLMFunction["Prove this theorem in English: {1}"][myTheorem]

Weaknesses and criticisms

• Price. Student license about $169 per year, individual$440 per year, business licenses run into the thousands. University site licenses are private but range from tens to hundreds of thousands.
• Vendor lock-in. WL code does not port. There is no open-source backend.
• Speed. Numerical computation is generally slower than MATLAB or NumPy (symbolic is dominant).
• Modern ML absent. No standard PyTorch or JAX equivalent. NetTrain is its own world.

2026 position

• Best fits: symbolic solves, notebook demos, data visualization, university math classes that licensed it.
• Worst fits: deep learning, big-data processing, open-source collaboration.
• One-liner: "If symbolic computation is core and your school pays for the license, still number one."

3. MATLAB + Simulink (MathWorks) — engineering industry standard

MATLAB (MATrix LABoratory), released in 1984, is the de facto standard for electrical, mechanical, automotive, and aerospace engineering. The 2026 release is R2026a. Simulink, the block-diagram simulation tool, comes paired.

Why industry cannot leave

• Certification. DO-178C (aerospace), ISO 26262 (automotive), IEC 61508 (industrial) certified model-based design toolchains. Simulink Coder generates C code from models, and that code passes certification.
• Toolboxes. Control System, Signal Processing, Aerospace, Powertrain Blockset — over a hundred industry-domain toolboxes with validated algorithms.
• HDL / Embedded Coder. Models to C/C++/Verilog/HDL/PLC. The standard embedded and FPGA workflow.
• Numerical stability. LAPACK plus decades of tuning. Matrix operation trust is unmatched.

A code fragment

% State-space simulation
A = [-0.5 1; 0 -1];
B = [0; 1];
C = [1 0];
sys = ss(A, B, C, 0);
t = 0:0.01:10;
u = ones(size(t));
[y, t] = lsim(sys, u, t);
plot(t, y)

% Signal processing — FFT
Fs = 1000;
t = 0:1/Fs:1-1/Fs;
x = sin(2*pi*50*t) + sin(2*pi*120*t) + randn(size(t));
Y = fft(x);
P2 = abs(Y/length(x));
plot(Fs*(0:(length(x)/2))/length(x), P2(1:length(x)/2+1))

2026 changes

• MATLAB Online and MATLAB Mobile — with a license, run it in the browser or on a phone.
• AI Chat in MATLAB — assistant inside the IDE. Code explanation, debugging, function suggestions.
• Stronger Python integration — the py.* namespace calls NumPy and PyTorch from MATLAB. The reverse works through matlab.engine.
• Apple Silicon native — R2024a onward ships native ARM64 macOS. Big performance gains.

Weaknesses

• Price. Student $99, individual$149, business $940 per year for core. Toolboxes cost extra. One lab with 20 toolboxes runs into tens of thousands.
• Language limits. Object-orientation is awkward and the package manager (MATLAB File Exchange) does not match npm or PyPI.
• GIL-like constraints. parfor is powerful, but distributed work requires the Parallel Computing Toolbox.
• Open-source absence. GitHub Actions cannot run it (license). Collaboration friction.

Position

• Best fits: engineering education (EE/ME/AE), automotive, aerospace, defense R and D, signal processing, control.
• Worst fits: data science and statistics (R), machine learning (Python), first-year undergrad math (GeoGebra).
• One-liner: "Industry still cannot leave. Academia slowly drifts away."

4. Maple (Maplesoft) — Mathematica's perpetual rival

Maple is a CAS started at the University of Waterloo in 1980. Maple 2025 was released in late 2025. People compare it to Mathematica constantly, but the mental models differ.

Differences from Mathematica

Where Maple genuinely wins

• MapleSim — a Simulink competitor. Physics-based modelling is strong.
• Maple Calculator + Maple Learn — textbook-attached workflow. Students see step-by-step solutions.
• MapleFlow — engineering calculation document tool. The MathCAD successor of choice for many teams.
• Grid Computing Toolbox — straightforward node distribution.

A code fragment

# ODE solve
ode := diff(y(x), x, x) + y(x) = sin(x);
sol := dsolve({ode, y(0) = 1, D(y)(0) = 0}, y(x));

# Number theory
isprime(2^127 - 1);   # Mersenne prime
ifactor(2^256 - 1);

# Step-by-step solution
Student[Calculus1]:-ShowSolution(int(x^2 * exp(x), x));

Position

• Best fits: engineering courses (ODE/PDE especially), undergrad math classrooms, automotive simulation that uses MapleSim.
• Worst fits: absolute symbolic depth (Mathematica wins), machine learning, data analysis.
• One-liner: "If your school can afford one of the two, the textbook-integration crowd picks Maple."

5. SageMath — open-source unified CAS

SageMath is an open-source math system started by William Stein in 2005. The goal was explicit — "an open-source alternative to Mathematica, Maple, and Magma." The 2026 line is in the late 9.x series.

Architecture — a composite system

Sage was designed from day one as an interface to other tools. It uses Python as the interface language and internally calls more than a hundred packages: GAP, PARI, Singular, Maxima, FLINT, GMP, NumPy, SciPy, NetworkX, and more.

┌──────────────────────────────────────────────────┐
│            SageMath = "assemblage"                │
│                                                  │
│  User interface (Python + Sage extensions)        │
│              │                                   │
│  ┌───────────▼───────────────────────────────┐   │
│  │ Symbolic: Maxima, SymPy, Pynac            │   │
│  │ Numeric: NumPy, SciPy, R                  │   │
│  │ Number theory: PARI, FLINT, ECL           │   │
│  │ Groups: GAP                               │   │
│  │ Algebraic geometry: Singular, Macaulay2   │   │
│  │ Graphs: NetworkX                          │   │
│  │ LP/MIP: GLPK, PPL, Coin-OR                │   │
│  └───────────────────────────────────────────┘   │
└──────────────────────────────────────────────────┘

A code fragment

# Sage is a Python superset
# Number theory
E = EllipticCurve([0, 0, 1, -1, 0])
print(E.rank())               # 0
print(E.j_invariant())

# Differential equations
x = var('x')
y = function('y')(x)
de = diff(y, x, 2) + y == sin(x)
desolve(de, y, ics=[0, 1, 0])

# Polynomial ring
R.<x, y> = QQ[]
I = R.ideal(x^2 + y^2 - 1, x - y)
print(I.groebner_basis())

2026 status

• Development pace — fewer core maintainers than peak. William Stein moved to CoCalc, others to industry. Patches keep flowing though.
• Jupyter integration — Sage notebooks are now Jupyter-based by default.
• CoCalc as backend — CoCalc is effectively the cloud host for Sage.
• AI integration — natural-language to Sage code via jupyter-ai. Accuracy not guaranteed yet.

Position

• Best fits: math PhDs, number theory and algebraic geometry research, undergrad math (especially as a free alternative to expensive licenses), free education.
• Worst fits: certified engineering workflows (MATLAB), Mathematica's natural-language input, closed-form integration precision.
• One-liner: "The terminus of the open-source CAS line. If a student cannot afford Mathematica, SageMath."

6. Julia 1.11 — science-first by design

Julia is a language released by MIT in 2012. The slogan was crisp — "Walks like Python, runs like C." The 1.10 LTS in 2024 and stable 1.11 in 2025 set the modern baseline; in 2026 the project is heading to 1.12.

The problem Julia solves — the two-language problem

Python scientific computing has an intrinsic flaw — hot loops drop to C or Fortran. NumPy is fast because NumPy is C. Julia does both in one language — JIT compilation, multiple dispatch, and a strong type system.

A code fragment

using DifferentialEquations, Plots

function lorenz!(du, u, p, t)
    σ, ρ, β = p
    du[1] = σ * (u[2] - u[1])
    du[2] = u[1] * (ρ - u[3]) - u[2]
    du[3] = u[1] * u[2] - β * u[3]
end

u0 = [1.0, 0.0, 0.0]
tspan = (0.0, 100.0)
p = (10.0, 28.0, 8/3)

prob = ODEProblem(lorenz!, u0, tspan, p)
sol = solve(prob, Tsit5(), reltol=1e-8, abstol=1e-8)
plot(sol, idxs=(1, 2, 3))

The same code in Python plus NumPy is usually 5 to 50 times slower. And the SciML ecosystem covers PDEs, SDEs, DAEs, and neural ODEs under one interface.

Julia ecosystem in 2026

• SciML — DifferentialEquations.jl, ModelingToolkit.jl, Symbolics.jl — the standard scientific machine learning stack.
• Flux.jl / Lux.jl — Julia-native ML.
• Pluto.jl — reactive notebooks. A different mental model from Jupyter (cells form a dependency graph).
• Julia for HPC — increasingly adopted on DOE supercomputers. CliMA (climate modelling), Celeste (astronomical classification), and more.
• Symbolics.jl — Julia-native CAS. Often reported as faster than SymPy.

Weaknesses

• Compile latency. The "time to first plot" problem. 1.9+ improved a lot with package precompilation, but it still grates.
• Ecosystem size. Smaller than Python. Library discovery is harder.
• Job market. Far fewer Julia listings than Python, R, or MATLAB. The academia versus industry asymmetry is real.
• Version-stability perception. Even on 1.x, package compatibility breaks sometimes.

Position

• Best fits: scientific ML, differential equation solving, HPC, quantum/plasma/climate simulation, financial modelling.
• Worst fits: web services, short scripts, corporate data teams (Python is standard there).
• One-liner: "If you want numerical, symbolic, and differential equations in one language, Julia 1.11 is the answer."

7. R + tidyverse + Posit (formerly RStudio) — the statistical standard

R is a statistics-focused language released in 1993. The 2026 line is 4.x. More important than R itself is the tidyverse ecosystem and the company that drives it, Posit (rebranded from RStudio in 2022).

Why R never died

For a decade people predicted "Python will replace R." In 2026 R is still alive. Reasons:

• A language made by statisticians. lm, glm, summary, anova are first-class functions. Python's statsmodels does similar things but the output quality is not the same.
• tidyverse. dplyr, tidyr, ggplot2, purrr, readr — Hadley Wickham's unified interface. The mental model of data analysis becomes code.
• CRAN. Package quality control is stricter than PyPI. Almost every statistical method published in academia is on CRAN.
• Quarto — successor to R Markdown, released by Posit in 2022. A multi-language document system that supports Python, R, Julia, and Observable.

A code fragment

library(tidyverse)
library(lme4)

# tidyverse data pipeline
mtcars |>
  as_tibble(rownames = "model") |>
  group_by(cyl) |>
  summarise(
    mean_mpg = mean(mpg),
    n = n(),
    .groups = "drop"
  ) |>
  ggplot(aes(x = factor(cyl), y = mean_mpg)) +
  geom_col(fill = "steelblue") +
  labs(x = "Cylinders", y = "Mean MPG")

# Mixed-effects model
model <- lmer(mpg ~ wt + (1 | cyl), data = mtcars)
summary(model)

Posit (formerly RStudio)

RStudio rebranded to Posit in 2022 because — "We are not an R company, we are a data science company." Since then:

• Positron — successor IDE to RStudio. VS Code based, equal support for Python, R, and Julia. Beta in 2024, stable in 2025. RStudio is maintained but new development goes to Positron.
• Quarto — multi-language document system.
• Posit Cloud — browser-based R/Python environment.
• Shiny — web app framework supporting both R and Python.

Weaknesses

• Speed. R core is not fast. data.table, Rcpp, and arrow plug the gap.
• ML ecosystem. Falls short of Python (PyTorch / scikit-learn). tidymodels is chasing.
• Editor dependence. Outside RStudio or Positron the R experience suffers.
• Language consistency. Four object systems coexist — S3, S4, R5, R6. The learning curve is uneven.

Position

• Best fits: statistics, epidemiology, clinical research, social science, data journalism.
• Worst fits: deep learning, large-scale ETL, general backend work, real-time systems.
• One-liner: "If your data analysis lives closer to statistics, R plus tidyverse. Closer to computer science, Python."

8. Python scientific stack — NumPy / SciPy / SymPy / Pandas / Polars

Python remains the de facto language for data, science, and ML in 2026. It is not one tool — it is a stack.

Stack layout

┌──────────────────────────────────────────────────────┐
│              Python scientific stack (2026)           │
│                                                      │
│  Application      ┌────────────────────────────┐    │
│                   │ Jupyter, Streamlit, Dash    │    │
│                   └────────────────────────────┘    │
│  Stats / ML       ┌────────────────────────────┐    │
│                   │ statsmodels, scikit-learn,  │    │
│                   │ PyTorch, JAX                │    │
│                   └────────────────────────────┘    │
│  Dataframes       ┌────────────────────────────┐    │
│                   │ Pandas 2.x, Polars, DuckDB  │    │
│                   └────────────────────────────┘    │
│  Symbolic / CAS   ┌────────────────────────────┐    │
│                   │ SymPy                       │    │
│                   └────────────────────────────┘    │
│  Numeric / sci    ┌────────────────────────────┐    │
│                   │ NumPy 2.x, SciPy 1.14+,     │    │
│                   │ Matplotlib                  │    │
│                   └────────────────────────────┘    │
│  Low-level / fast ┌────────────────────────────┐    │
│                   │ Numba, Cython, mypyc        │    │
│                   └────────────────────────────┘    │
└──────────────────────────────────────────────────────┘

What to watch in 2026

• NumPy 2.x — NumPy 2.0 shipped in June 2024. There was an ABI break and the ecosystem caught up within a year. A more consistent dtype system.
• Pandas 2.x with PyArrow backend — Arrow backend is moving from option to default.
• Polars — Rust-written dataframe library. Faster than Pandas on large data. Powerful lazy API.
• SymPy 1.13+ — symbolic computation. Slower than Mathematica but free and Python-native.
• DuckDB + Ibis — OLAP queries inside notebooks. SQL directly over CSV and Parquet.

A code fragment

import numpy as np
import polars as pl
import sympy as sp

# Numeric
A = np.random.randn(1000, 1000)
e = np.linalg.eigvals(A)

# Polars — faster dataframe than Pandas
df = (
    pl.scan_csv("sales.csv")
    .filter(pl.col("amount") > 100)
    .group_by("region")
    .agg(pl.col("amount").sum().alias("total"))
    .collect()
)

# SymPy symbolic solve
x = sp.Symbol("x")
integral = sp.integrate(sp.sin(x) * sp.exp(-x), x)
print(sp.latex(integral))

Weaknesses of the Python stack

• Speed. Hot loops must drop to NumPy, Numba, or Cython. The two-language problem returns.
• Dependency hell. conda, pip, uv, poetry, pixi — five tools coexist. In 2026 uv is rapidly becoming the de facto standard.
• Symbolic depth. SymPy does not match Mathematica or Maple in precision or speed.

Position

• Best fits: almost every data, science, and ML workflow, from first-year undergrad to PhD.
• Worst fits: certified engineering (MATLAB rules), advanced symbolic solves (Mathematica), PDE work where Julia dominates.
• One-liner: "When in doubt, Python is the safe starting point."

9. GeoGebra + Desmos — the two education giants

The most-used tools in math education are not Mathematica or MATLAB. They are GeoGebra and Desmos.

GeoGebra

• Origin. Started as a PhD project by Markus Hohenwarter at the University of Salzburg in 2001.
• Positioning. Unified dynamic mathematics — geometry plus algebra plus calculus plus statistics.
• Users. Over a hundred million globally. School licenses are essentially free.
• Modules. Graphing, Geometry, 3D Calculator, CAS, Classic, Notes, Suite — consolidated into Suite in 2024.

GeoGebra Suite (2026)
├── Graphing Calculator (Desmos-class function plots)
├── Geometry (Euclidean constructions)
├── 3D Calculator (spatial visualization)
├── CAS Calculator (symbolic, Maxima-backed)
├── Notes (digital whiteboard)
└── Classic 6 (full desktop bundle)

Desmos

• Origin. Founded in 2011 by Eli Luberoff. The classroom side was acquired by Amplify in 2022; the graphing calculator runs as a separate non-profit.
• Positioning. "The best function-graphing calculator" plus K-12 classroom integration.
• Users. De facto standard in US K-12. SAT and ACT certified.
• Geometry Tool released in 2024 — competing with GeoGebra Geometry.

Comparison

Position

• GeoGebra fits schools and lower-division college that need geometry plus visualization plus CAS.
• Desmos fits K-12 where function graphs plus activity-based learning are core.
• As students climb into calculus, linear algebra, and ODEs, they graduate to SageMath or Mathematica.

10. GAP / Macaulay2 / Magma / Singular — specialized algebra

At the PhD level and above, generalists hit walls. Four specialized CAS systems fill the gap.

GAP — computational group theory

GAP (Groups, Algorithms, Programming) started at RWTH Aachen in 1986. The 2026 line is 4.13+. Finite groups, representation theory, subgroup lattices, and group cohomology are core.

gap> G := SymmetricGroup(5);
Sym( [ 1 .. 5 ] )
gap> Order(G);
120
gap> ConjugacyClasses(G);
[ ()^G, (1,2)^G, (1,2)(3,4)^G, (1,2,3)^G, ...]
gap> IsSimple(G);
false

Macaulay2 — computational algebraic geometry

Macaulay2 is a commutative algebra plus algebraic geometry system started by Daniel Grayson and Michael Stillman in 1992. Rings, ideals, Groebner bases, free resolutions, and homological algebra are core.

i1 : R = QQ[x, y, z]
o1 = R
i2 : I = ideal(x^2 - y, y^2 - z, x*y - z)
o2 = ideal (x^2 - y, y^2 - z, x*y - z)
i3 : gens gb I
o3 = | yz-x z2-y2 xz-y2 y2-z xy-z x2-y |

Magma — commercial commutative algebra

Magma is the system developed by the Computational Algebra Group at the University of Sydney (1993 onward). It is paid. Number theory, algebraic geometry, coding theory, and representation theory are reputed strengths. People often use it alongside GAP or M2. Licensing is negotiated. Student licenses exist separately. SageMath can call Magma as a backend, but you still need a license.

Singular — polynomial algebra

Singular started at TU Kaiserslautern in 1984. A polynomial computation system. Groebner bases, free resolutions, and singularity analysis are core. Also serves as SageMath's polynomial-ring backend.

Comparison of the four

Position

• Rarely used in undergrad. Often essential for PhDs depending on the area.
• SageMath bundles GAP and Singular — natural to call from inside Sage.
• Macaulay2 is invoked separately from Sage (macaulay2.eval()).
• Magma's license is a hurdle, so availability depends on the institutional site license.

11. CoCalc — cloud SageMath plus Jupyter

CoCalc is the cloud collaborative notebook platform started by William Stein in 2013. Effectively the cloud host for SageMath.

What it offers

• SageMath, Jupyter, R, Julia, and Octave notebooks in the browser.
• Full Linux terminal — LaTeX compilation, gnuplot, git included.
• Real-time collaboration — Google Docs-style simultaneous editing.
• Assignment / grading system — teachers receive student notebooks and auto-grade.
• Time-travel slider — replay every edit through history.

Pricing (2026)

• Free — no internet access, 1 GB memory, 1 CPU.
• Student — around $5 per month (internet plus more resources).
• Teacher / lab — from $14 per month (site license priced separately).

CoCalc's core value

In a class, everyone has the same environment. Students who cannot install SageMath, packages that break on M1 Macs, LaTeX that misbehaves on Windows — all of those problems vanish. Huge value in undergrad courses.

Position

• The default infrastructure for undergrad math and statistics courses.
• Limits show in PhD research — large memory or GPUs need other platforms.
• A self-hosted open-source version exists (KuCalc).

12. Wolfram Cloud + Wolfram Alpha API

Wolfram Cloud is the cloud version of Mathematica. Wolfram Alpha API lets external apps call natural-language math solving.

Wolfram Cloud

• Wolfram Language notebooks in the browser.
• Cloud Notebook plus Deployable APIs — notebooks deploy directly as web APIs.
• Free Tier exists, with computation caps.
• Pricing — $5 per month for individuals, separate plans for business.

Wolfram Alpha API

import wolframalpha

client = wolframalpha.Client(app_id="XXXX")
res = client.query("integral of sin(x)^2 from 0 to pi")
print(next(res.results).text)
# -> "pi/2"

• Natural-language input that returns the evaluated Wolfram expression.
• Frequently embedded in chatbots, education apps, and graphing calculators.
• Free tier — 2,000 calls per month. Paid above that.

Common scenarios

• A chatbot routes math questions to the Alpha API.
• A study app uses it to show step-by-step solutions.
• People without a Mathematica license solve one-off problems.

13. JAX (Google) — science plus ML fusion

JAX is a library released by Google in 2018. It is "NumPy plus autograd plus XLA." In 2026 it is the hottest tool at the intersection of scientific computing and ML.

Mental model

• The API is essentially NumPy — gentle learning curve.
• Every function is automatically differentiable — jax.grad.
• Every function is JIT compilable — jax.jit compiles to XLA on CPU, GPU, or TPU.
• Pure functional only — code with side effects is rejected.

import jax
import jax.numpy as jnp

def rosenbrock(x):
    return jnp.sum(100.0 * (x[1:] - x[:-1]**2)**2 + (1 - x[:-1])**2)

# Gradient
grad_rb = jax.grad(rosenbrock)

# JIT compile
jit_rb = jax.jit(rosenbrock)

# Vectorize — batched processing
batched = jax.vmap(rosenbrock)
xs = jnp.array([[1.0, 1.0], [2.0, 2.0]])
print(batched(xs))

JAX versus PyTorch

JAX in scientific computing

• Physics simulation — DeepMind molecular dynamics, NASA fluid solvers.
• Bayesian inference — NumPyro, BlackJAX.
• Neural ODE / PDE — Diffrax, JAX-CFD.
• Quantum simulation — JaxQuTip and friends.

Weaknesses

• Forces functional thinking — learning curve. Free-form for loops are not allowed (use jax.lax.scan etc).
• Ecosystem fragmentation — Flax, Haiku, Equinox, and others. No standard neural-net library.
• JIT debugging — error messages on compiled code are rough.

Position

• Becoming the standard at the science plus ML intersection.
• For pure ML, PyTorch still dominates.
• For pure numerics, NumPy or Julia is enough. JAX shines when differentiation plus acceleration are both needed.

14. The CAS camp — Symbolics.jl / Reduce / Maxima / Pari-GP / SymPy

Set commercial aside and the open CAS world is rich.

SymPy

• Python-native.
• The first CAS most students or engineers meet, before considering Mathematica.
• Weakness — speed. Slow on large expressions.

import sympy as sp
x = sp.Symbol("x")
sp.integrate(sp.sin(x) * sp.exp(-x), x)

Symbolics.jl

• Julia-native CAS. Tied to ModelingToolkit as the PDE/ODE system builder.
• Multiple dispatch makes it faster than SymPy on large expressions.

using Symbolics

@variables x y
expr = x^2 + 2x*y + y^2
simplify(expr)

Maxima

• Direct descendant of Macsyma. Started at MIT in the 1960s, now GPL.
• Lisp-based, old UX. One of SageMath's symbolic backends.
• Deep number theory and integration — surprisingly strong.

Reduce

• Started by Hearn in 1968. Open sourced in 2008.
• Historically strong in physics — Feynman diagram calculations and similar.
• Rare on modern teams but still alive.

PARI/GP

• Started at Bordeaux in 1985. A number-theory specialist CAS.
• Fast number-theoretic algorithms — primality, factoring, elliptic curves.
• A C library (libpari) plus an interactive shell (GP).
• Number-theory backend of SageMath.

? factor(2^256 - 1)
? isprime(2^127 - 1)
? E = ellinit([0, 0, 1, -1, 0])
? ellanalyticrank(E)

Comparison

15. Korea — KAIST / Seoul National / Posit Korea

The Korean university math and engineering landscape.

KAIST

• Engineering — MATLAB is embedded deep from the freshman year. EE, ME, AE site licenses run institutionally.
• Department of Mathematics — Mathematica plus SageMath. Calculus and linear algebra often use Mathematica; research groups frequently use SageMath.
• AI graduate school — Python / JAX / PyTorch. R appears in some stats courses.
• Known cases — the KAIST math department has SageMath lab classes; the industrial engineering department teaches R statistics.

Seoul National University (SNU)

• Department of Mathematical Sciences — Mathematica license plus some SageMath.
• Engineering — MATLAB plus Python.
• Statistics — R + tidyverse is dominant.
• AI labs — Python + PyTorch / JAX.

POSTECH

• Smaller scale but holds site licenses for MATLAB and Mathematica.
• Math department uses open CAS (SageMath, GAP, Macaulay2) heavily.

Industry — Korea

• Automotive (Hyundai, Kia) — MATLAB and Simulink are deeply embedded due to certification workflows.
• Semiconductor (Samsung, SK Hynix) — MATLAB plus Python. MATLAB for signal processing and metrology, Python for data analytics.
• Finance — R and Python. R for analysis, Python for model deployment.
• Startups — Python near-monopoly. R appears among some data analysts.

Korean-language resources

• Korean SageMath group — small but academically active.
• KAIST OCW — open course materials with some SageMath lab content.
• EBS / educational broadcasting — GeoGebra-based math lessons.

16. Japan — University of Tokyo / Kyoto University / RIKEN / Mathematica licenses

Japanese university landscape.

University of Tokyo (Todai)

• Graduate School of Mathematical Sciences — Mathematica site license. Undergrads can access it.
• Faculty of Engineering — MATLAB is embedded in every undergraduate year.
• Department of Physics — Mathematica + Python + Julia mix.
• Information Science and Technology / AI — Python + PyTorch / JAX dominant.

Kyoto University

• Faculty of Science, Mathematics Section — Mathematica plus SageMath. Some PhD students use SageMath, GAP, and Macaulay2.
• RIMS (Research Institute for Mathematical Sciences) — pure mathematics focused. Tools vary by researcher preference.
• Faculty of Engineering — MATLAB and Simulink are heavily used given automotive and electronics industry ties.

RIKEN

• R-CCS (Center for Computational Science) — operates the Fugaku supercomputer. Mixes Julia, Python, C++, and Fortran.
• AIP (Advanced Intelligence Project) — Python + PyTorch + JAX.

Osaka and Nagoya Universities

• Strong engineering — MATLAB and Simulink dominant.
• Math departments mix SageMath and Mathematica.

Industry — Japan

• Automotive (Toyota, Honda, Nissan) — MATLAB and Simulink standard. MathWorks Japan is unusually strong.
• Electronics (Sony, Panasonic, Renesas) — MATLAB plus Python plus C/C++.
• Finance — R plus Python. Conservative statistical work runs in R, new workflows in Python.
• AI startups (Preferred Networks, Sakana AI, others) — Python plus JAX / PyTorch.

Japanese-language resources

• Kyoto University math literacy materials — partial SageMath resources are public.
• MathWorks Japan — extensive MATLAB documentation in Japanese.
• Wolfram Japan — regular Mathematica seminars in Japanese.

17. Who should pick what — student, research, industry, education

Final recommendations by scenario.

First and second-year undergrad (math, science, or engineering intro)

• Base on Python + NumPy + SymPy + Matplotlib. Free, and once learned, useful for life.
• Visualization and geometry — GeoGebra or Desmos.
• If the school has a Mathematica or MATLAB site license, learn that too.

Third and fourth-year undergrad / after picking a major

• Math / statistics — R + tidyverse, SageMath, SymPy.
• Engineering (EE/ME/AE) — MATLAB + Simulink (industry-standard reality).
• CS / AI — Python + PyTorch / JAX.

PhD (pure mathematics)

• Number theory / algebraic geometry — SageMath + GAP + Macaulay2 + Singular. Add Magma if licensed.
• Analysis / PDE — Julia (DifferentialEquations.jl) or MATLAB + PDE Toolbox.
• Applied math — Python + JAX + Julia mix.

PhD (engineering or physics)

• Industry-adjacent — MATLAB / Simulink essential.
• Academia-adjacent — Python + Julia + domain-specific tooling.
• Quantum — Qiskit / Cirq + JAX.

Corporate R and D

• Automotive, aerospace, defense — MATLAB / Simulink (certification demands).
• Semiconductor, telecom — MATLAB + Python.
• Finance — R + Python + Julia.
• AI / startups — Python + PyTorch / JAX near-monopoly.

Education (teachers)

• K-12 — Desmos or GeoGebra. Students can use them on mobile.
• High school — GeoGebra + Python (introduction).
• University classrooms — CoCalc or Posit Cloud — environment uniformity matters.

References

• Wolfram Mathematica — https://www.wolfram.com/mathematica/
• Wolfram Language — https://www.wolfram.com/language/
• Wolfram Alpha — https://www.wolframalpha.com/
• Wolfram Cloud — https://www.wolframcloud.com/
• MATLAB — https://www.mathworks.com/products/matlab.html
• Simulink — https://www.mathworks.com/products/simulink.html
• Maple — https://www.maplesoft.com/products/maple/
• MapleSim — https://www.maplesoft.com/products/maplesim/
• SageMath — https://www.sagemath.org/
• Julia — https://julialang.org/
• SciML — https://sciml.ai/
• Symbolics.jl — https://docs.sciml.ai/Symbolics/stable/
• R Project — https://www.r-project.org/
• tidyverse — https://www.tidyverse.org/
• Posit — https://posit.co/
• Positron — https://positron.posit.co/
• Quarto — https://quarto.org/
• NumPy — https://numpy.org/
• SciPy — https://scipy.org/
• SymPy — https://www.sympy.org/
• Pandas — https://pandas.pydata.org/
• Polars — https://pola.rs/
• JAX — https://github.com/google/jax
• Flax — https://github.com/google/flax
• GeoGebra — https://www.geogebra.org/
• Desmos — https://www.desmos.com/
• GAP — https://www.gap-system.org/
• Macaulay2 — https://macaulay2.com/
• Magma — http://magma.maths.usyd.edu.au/magma/
• Singular — https://www.singular.uni-kl.de/
• Maxima — https://maxima.sourceforge.io/
• Reduce — https://reduce-algebra.sourceforge.io/
• PARI/GP — https://pari.math.u-bordeaux.fr/
• CoCalc — https://cocalc.com/
• William Stein on Sage — https://wstein.org/
• KAIST — https://www.kaist.ac.kr/
• Seoul National University Math — https://www.math.snu.ac.kr/
• POSTECH — https://www.postech.ac.kr/
• University of Tokyo Mathematical Sciences — https://www.ms.u-tokyo.ac.jp/
• Kyoto University RIMS — https://www.kurims.kyoto-u.ac.jp/
• RIKEN R-CCS — https://www.r-ccs.riken.jp/
• MathWorks Japan — https://jp.mathworks.com/