RunMat vs Octave

RunMat and GNU Octave both run MATLAB-language code without a MATLAB license. RunMat compiles hot code with a JIT, runs array math on whatever GPU the machine has and checks sizes before the script starts. Octave is free software under the GPL. It interprets each line as it runs, has no GPU support built in, and supports only part of newer MATLAB features such as classdef.

  • Array math on NVIDIA, AMD, Intel and Apple GPUs, with no code changes
  • Size mistakes reported before the script runs
  • Simulation and live co-editing in the same tool
Download RunMat

Facts about Octave checked November 6, 2026. Sources

RunMat

rotate_points.m
% Rotate 100 measured points by 30 degrees
theta = pi/6;
R = [cos(theta) -sin(theta); sin(theta) cos(theta)];
P = rand(100, 2); % one point per row
Q = R * P; % should be R * P'
plot(Q(1, :), Q(2, :), 'o')
Terminal
$ runmat check rotate_points.m
error[RM-TYPE-MATMUL]: matrix inner dimensions 2 and 100 do not agree
--> rotate_points.m:5:1
|
5 | Q = R * P; % should be R * P'
| ^^^^^^^^^ static value contract is not satisfied here
checked rotate_points.m: 1 error(s), 0 warning(s)

GNU Octave

rotate_points.m
% Rotate 100 measured points by 30 degrees
theta = pi/6;
R = [cos(theta) -sin(theta); sin(theta) cos(theta)];
P = rand(100, 2); % one point per row
Q = R * P; % should be R * P'
plot(Q(1, :), Q(2, :), 'o')
Terminal
$ octave rotate_points.m
error: operator *: nonconformant arguments (op1 is 2x2, op2 is 100x2)
error: called from
rotate_points at line 5 column 3
The same script in RunMat and in GNU Octave 9.4.0: RunMat reports the size mismatch on line 5 before anything runs; Octave stops at line 5 after running every line above it.

At a glance

Language
RunMatMATLAB language, including classdef, strings, tables and 2,100+ built-in functions with MATLAB names and behavior.
OctaveRuns many MATLAB numerical scripts [1]. In our runs, double-quoted strings, arguments blocks and much of classdef did not run, and Octave documents classdef as partly supported [2].
Execution
RunMatA tiered interpreter and JIT compiler. runmat compile builds a standalone native executable.
OctaveAn interpreter. The prototype JIT compiler was removed in Octave 7 [3].
GPU
RunMatNVIDIA, AMD, Intel and Apple GPUs. Array code moves to the GPU when RunMat estimates it will be faster; gpuArray and gather also work.
OctaveNo GPU support built in. Community packages such as ocl run selected computations with OpenCL [4].
Parallel
RunMatparfor across every core, and the same script on a cluster.
OctaveParallel work comes from the community parallel package, installed separately [5].
Checks before running
RunMatMismatched matrix sizes, operand types, argument counts and unknown functions reported in the editor and by runmat check.
OctaveErrors are reported when the line runs, as in the capture below.
Where it runs
RunMatDesktop app and CLI on macOS, Windows and Linux, and the full runtime in a browser tab with nothing to install.
OctaveDesktop GUI and command line on GNU/Linux, macOS, BSD and Windows [1].
Simulation
RunMatStructural, thermal, electromagnetic, acoustic, fluid and coupled studies on STEP geometry, with loads and boundary conditions written as MATLAB functions.
OctaveNone built in. Finite element work is written by hand in code.
Collaboration and multiplayer
RunMatSeveral people edit one project live and see each other's cursors, in code, plots and 3D results.
OctaveFiles and Git. No live co-editing.
License and price
RunMatFree for individuals, academics, open-source contributors and smaller organizations. Professional license: $99 per person per month in the US, or the local equivalent.
OctaveFree software under the GNU General Public License [1].

We also wrote a longer comparison of MATLAB and Octave, covering their history, compatibility and performance. Read MATLAB vs Octave

Size mistakes found before the script runs

RunMat works out the size and type of each value before the script runs. It reports matrix products, solves, elementwise operations and concatenations whose sizes cannot agree, calls with the wrong number of arguments and functions that are not defined anywhere in the project. The editor shows these as you type, and runmat check runs the same checks in CI.

In the script at the top of this page, 100 measured points are stored one per row, and the rotation on line 5 treats them as columns. RunMat reports line 5 with its error code before anything runs.

Octave has no check before running. It finds the mistake only when it reaches line 5, after every line above it has run. In a long analysis, that can be hours after the run started.

RunMat

rotate_points.m
% Rotate 100 measured points by 30 degrees
theta = pi/6;
R = [cos(theta) -sin(theta); sin(theta) cos(theta)];
P = rand(100, 2); % one point per row
Q = R * P; % should be R * P'
plot(Q(1, :), Q(2, :), 'o')
Terminal
$ runmat check rotate_points.m
error[RM-TYPE-MATMUL]: matrix inner dimensions 2 and 100 do not agree
--> rotate_points.m:5:1
|
5 | Q = R * P; % should be R * P'
| ^^^^^^^^^ static value contract is not satisfied here
checked rotate_points.m: 1 error(s), 0 warning(s)

GNU Octave

rotate_points.m
% Rotate 100 measured points by 30 degrees
theta = pi/6;
R = [cos(theta) -sin(theta); sin(theta) cos(theta)];
P = rand(100, 2); % one point per row
Q = R * P; % should be R * P'
plot(Q(1, :), Q(2, :), 'o')
Terminal
$ octave rotate_points.m
error: operator *: nonconformant arguments (op1 is 2x2, op2 is 100x2)
error: called from
rotate_points at line 5 column 3

Captured November 4, 2026 with the RunMat CLI and GNU Octave 9.4.0.

What you can do in RunMat

RunMat adds the parts engineering teams reach for once MATLAB scripts grow.

Run it fast

  • Tiered interpreter and JIT
  • Automatic GPU placement and fusion
  • parfor across every core
  • Standalone executables

GPU

Catch mistakes early

  • Matrix sizes checked before running
  • Unknown functions and wrong argument counts
  • The same checks in the editor and in CI
  • Units checked in simulation studies

Static analysis

Analyze data

  • Tables, timetables, dates and missing values
  • Statistics, fitting and optimization
  • Signal processing and FFTs
  • CSV, Excel, .mat and binary files

Math in RunMat

Call other code

  • Python packages from MATLAB code
  • Java classes and C libraries
  • MEX files rebuilt without MATLAB
  • Compiled programs shared with anyone

Interop

Simulate

  • Studies written as text with units
  • STEP geometry meshed in the study
  • Coupled thermal and structural analyses
  • Sweeps driven from a script

Simulation

Work together and with AI

  • Live co-editing in one project
  • The built-in agent writes and runs code
  • Claude Code, Codex and MCP clients
  • Run history with inputs and version

AI integrations

When RunMat is the better choice

RunMat is the better choice when MATLAB code has to run faster, on more hardware, or as part of a team's daily work.

  • Scripts that take minutes in an interpreter. RunMat compiles hot loops and runs large array math on the GPU, with the same code.

    GPU

  • Object-oriented MATLAB code built on classdef, handle classes, events and packages.

    Language coverage

  • Code that other people will run. Size mistakes and unknown functions are reported before the script starts, in the editor and in CI.

    Static analysis

  • A class or team that needs the same environment for everyone, in a browser tab, with no install.

    Try in the browser

  • Analysis that feeds a simulation: structural, thermal and electromagnetic studies run in the same project.

    Simulation

  • Programs to hand to colleagues who do not run MATLAB or Octave, as standalone executables.

    Compile

When Octave is the better choice

  • A requirement that every tool be free software under the GPL [1]. RunMat's source code is available under the Business Source License, which is not an open-source license.
  • Code written for Octave's own language extensions or its community packages [2].
  • Scripts that call inputParser, validateattributes, regexp name tokens, onCleanup or str2func on anonymous-function text. These ran in Octave and failed in RunMat in our tests.
  • Organizations above RunMat's free-use threshold that need production use at no cost. Octave is free for everyone [1].
  • A preference for a community project developed under the GNU Project [1].

Your MATLAB code works with the rest of RunMat

  • With simulation

    Write a study's loads and boundary conditions as MATLAB functions, sweep its inputs from a script and read every result back as arrays, in the same project.

    Simulation
  • With MCAD

    Drive a part's dimensions from MATLAB code, such as a cam profile from its motion law, and compare the stress study for each design.

    MCAD
  • With ECAD

    Compute part values in MATLAB code, such as a filter's resistors and capacitors from its cutoff, and run the circuit's sweeps against its spec.

    ECAD

Run your Octave scripts in RunMat

  1. 01

    Open the folder

    Open your folder of .m files in RunMat, in the browser or on the desktop, and run the main script.

    Install

  2. 02

    Check it

    Run runmat check on the folder. It reports size mismatches, wrong argument counts and functions that are not defined anywhere, before anything runs.

    Static analysis

  3. 03

    Compare the numbers

    Run the same script in Octave and in RunMat and compare the printed results. Octave-only syntax is listed in the compatibility guide.

    Compatibility

License

RunMat is source-available under the Business Source License 1.1, and each version converts to the Apache License 2.0 three years after the date it is first published.

The source code is available on GitHub, so you can read, build and modify the code that produces every result. Enterprise adds self-hosted deployment, including fully offline, under contract.

RunMat pricingLicenseSource codeWhy RunMat uses the BSL

Questions

01Is RunMat faster than Octave?

We have not published an Octave timing yet. RunMat compiles hot code with a JIT and runs large array math on the GPU; Octave runs code in an interpreter, and its prototype JIT compiler was removed in Octave 7 [3]. Run your own script in both to see the difference on your work.

Benchmarks

02Does Octave support the GPU?

Through community packages. The ocl package runs selected computations on OpenCL hardware [4]. RunMat uses NVIDIA, AMD, Intel and Apple GPUs for ordinary array code, with no package or code change.

GPU

03Will my Octave scripts run in RunMat?

Scripts written in the MATLAB language run in RunMat. Octave's own extensions to the language are not part of MATLAB [2], so lines that use them need the MATLAB form. runmat check lists what it cannot resolve before anything runs.

Compatibility

04Is RunMat free like Octave?

RunMat is free for individuals, including freelancers; students and faculty at an academic institution, for teaching or research there; contributors to an open-source project, for work on that project; organizations with 250 or fewer people and US$10M or less in annual revenue; and anyone, for non-production use. RunMat is licensed under the Business Source License 1.1, and each version converts to Apache 2.0 three years after it is first published. The source code is available on GitHub. Octave is free software under the GPL, free for everyone [1].

License

05What is a good Octave alternative?

If you want to stay with the MATLAB language, RunMat runs the same code with a JIT, GPU support, checks before running and simulation. If you are ready to change languages, Python with NumPy and Julia are the usual choices; we compare both with RunMat.

RunMat vs PythonRunMat vs Julia

Sources

We checked the facts about Octave on this page against these sources on November 6, 2026.

  1. [1]GNU Octaveoctave.org
  2. [2]Octave wiki, Differences between Octave and Matlabwiki.octave.org
  3. [3]GNU Octave, NEWS for version 7octave.org
  4. [4]Octave Packages, oclgnu-octave.github.io
  5. [5]Octave Packages, parallelgnu-octave.github.io