RunMat vs Julia

Julia is a well-designed language for numerical computing, and moving to it means rewriting existing code in it. RunMat gives MATLAB code compiler and GPU speed in place, so the code engineers already write keeps running.

  • Existing .m files run without a rewrite
  • Automatic GPU use on NVIDIA, AMD, Intel and Apple
  • Simulation and live co-editing in the same tool
Download RunMat

Facts about Julia checked November 6, 2026. Sources

gbm_option_price.m
% Price a European call by Monte Carlo: 1,000,000 geometric
% Brownian motion paths over 256 daily steps.
rng(0);
M = 1000000; T = 256;
S0 = single(100); mu = single(0.05); sigma = single(0.20);
dt = single(1/252); K = single(100);
S = ones(M, 1, 'single') * S0;
drift = (mu - 0.5 * sigma^2) * dt;
scale = sigma * sqrt(dt);
for t = 1:T
Z = randn(M, 1, 'single');
S = S .* exp(drift + scale .* Z);
end
payoff = max(S - K, 0);
price = mean(payoff, 'all') * exp(-mu * T * dt);
fprintf('Call price: %.4f\n', price);
fprintf('Paths in the money: %.1f%%\n', 100 * mean(S > K));
The same Monte Carlo option price in both languages. Julia reads close to MATLAB: elementwise calls take a dot, in-place updates use .=, packages load by name and vectors are 1-D. Each difference is a line to change and check in every ported function.

At a glance

Language
RunMatMATLAB language, with a compiler and JIT behind it.
JuliaJulia, designed for numerical computing, with multiple dispatch and just-in-time compilation [1].
Code you already have
RunMatMATLAB scripts, functions and classes run as they are.
JuliaRewritten in Julia. The syntax is close to MATLAB's, but indexing uses brackets, assignment shares arrays instead of copying, and column vectors are 1-D [2].
GPU
RunMatNVIDIA, AMD, Intel and Apple GPUs, with the same code that runs on the CPU.
JuliaEach GPU vendor needs its own package and array type: CUDA.jl is the most complete; AMDGPU.jl, oneAPI.jl and Metal.jl are less complete [3].
Parallel and cluster
RunMatparfor, parfeval and spmd across every core, and the same script on a cluster of your own machines.
JuliaThreads and the Distributed standard library run work across processes and machines [4].
Shipping a program
RunMatrunmat compile builds a standalone native executable from a MATLAB program.
JuliaPackageCompiler.jl builds apps and system images that bundle the Julia runtime [5].
Functions and packages
RunMat2,100+ built-in functions in one runtime, plus Python packages called from MATLAB code.
JuliaMore than 12,000 registered packages [1], loaded per project.
Simulation
RunMatStructural, thermal, electromagnetic, acoustic, fluid and coupled studies on STEP geometry, as text files with units.
JuliaNo CAD-based simulation built in. System modeling comes through ModelingToolkit and JuliaHub's Dyad [6]; finite element packages such as Gridap and Ferrite have you write the equations in code.
Collaboration and multiplayer
RunMatLive co-editing with cursors in code, plots and 3D results.
JuliaGit and notebooks. A hosted platform comes from JuliaHub, priced on request [7].
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.
JuliaThe Julia runtime is free and open source under the MIT license [1]. JuliaHub sells commercial products on top of it [7].

Run the same work on the GPU

The published Monte Carlo benchmark runs this computation at five sizes. RunMat moves the arrays to the GPU, fuses the elementwise update in the loop and keeps the prices on the device for all 256 steps, from the MATLAB code as written.

In Julia, the GPU comes from a vendor package and its array type, such as CUDA.jl's CuArray, and the code then runs on that vendor's GPUs. The benchmark has a Julia script but no published Julia run, so no Julia time is shown.

Monte Carlo option pricing, 256 steps · median wall time

PathsRunMat (GPU)PyTorch (GPU)NumPy (CPU)
250,000109 ms824 ms4,066 ms
500,000136 ms900 ms8,207 ms
1,000,000188 ms894 ms16,092 ms
2,000,000298 ms1,109 ms32,305 ms
5,000,000607 ms1,698 ms79,895 ms

Apple M2 Max, run 2025-11-21. Source and harness in the RunMat repository.

What you can do in RunMat

RunMat is built for the numerical work Julia targets, in the language most engineering teams already use.

Fast MATLAB code

  • Tiered interpreter and JIT
  • Errors on size and type before you run
  • Loops that run at compiled speed
  • Standalone executables

Runtime

GPU without a rewrite

  • Automatic placement on the GPU or CPU
  • Elementwise operations fused into fewer kernels
  • Data kept on the device between statements
  • gpuArray and gather where you want control

GPU

Parallel

  • parfor across every core
  • Same results at any worker count
  • The same script on a cluster
  • Simulation sweeps in parallel

Parallel

Differential equations and more

  • ode45, ode15s and the rest of the ODE suite
  • Optimization and curve fitting
  • Signal processing and statistics
  • Control systems

Differential equations

Simulate

  • Studies written as text with units
  • STEP geometry meshed in the study
  • Coupled thermal and structural analyses
  • Results read back into scripts

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 the code already exists in MATLAB, or the people who will maintain it think in MATLAB.

  • A team with years of .m files and engineers trained on them. The code runs today, with no port to write and re-verify.

    MATLAB compatibility

  • GPU speed on whatever GPU the machine has, NVIDIA, AMD, Intel or Apple, without choosing a GPU package or array type.

    GPU

  • Code checked before it runs: mismatched matrix sizes, wrong argument counts and unknown functions are reported in the editor and in CI.

    Static analysis

  • Analysis next to structural, thermal and electromagnetic simulation of CAD parts, in one project.

    Simulation

  • Engineers who share and co-edit work live, in a browser tab or on the desktop, with nothing to install.

    Download

  • Programs handed to colleagues as standalone executables.

    Compile

When Julia is the better choice

  • New scientific software or libraries meant to be fast, composable and open source from the first line.
  • Packages like DifferentialEquations.jl, ModelingToolkit and the SciML ecosystem, which have no direct MATLAB equivalent [8].
  • Code that relies on multiple dispatch and custom number types to specialize generic algorithms.
  • Research groups that already write Julia and have little MATLAB code to keep.
  • A policy that every tool be under an OSI-approved open-source license. RunMat's source is public under the Business Source License, which is not OSI-approved.

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

Try your own code

  1. 01

    Run your MATLAB code

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

    Install

  2. 02

    Find the hot paths

    Run the slow parts again. RunMat compiles loops and moves array math to the GPU, so many hot paths need no rewrite in another language.

    GPU

  3. 03

    Port the rest if you choose

    Our guide to moving MATLAB code to Julia covers syntax, indexing and packages, with RunMat's output as the reference to check against.

    Switching from MATLAB to Julia

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 Julia faster than MATLAB?

Julia compiles functions to machine code the first time they run, so tight loops run fast once compiled [1]. RunMat brings compilation and automatic GPU use to MATLAB code, so loop-heavy and array-heavy MATLAB programs speed up without a rewrite. Measure your own hot paths in both before you port.

Benchmarks

02How hard is it to move MATLAB code to Julia?

The syntax is close, but semantics differ: indexing uses brackets, assignment shares arrays rather than copying them, arrays do not grow on assignment, and column vectors are 1-D [2]. Each ported function has to be checked against the original's output.

Switching from MATLAB to Julia

03Does RunMat use the GPU like CUDA.jl?

RunMat places array operations on the GPU automatically, on NVIDIA, AMD, Intel and Apple hardware, and keeps data there between statements. In Julia you choose a vendor package such as CUDA.jl and use its array type [3].

GPU

04Julia vs Python vs MATLAB: which should an engineering team pick?

Pick Python for machine learning and general software, Julia for new high-performance numerical libraries, and the MATLAB language when the team's code and skills are already in it. RunMat runs MATLAB code with GPU, simulation and live co-editing, and calls Python packages from it.

RunMat vs Python

05Is RunMat open source like Julia?

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. Julia is open source under the MIT license.

LicenseSource code

Sources

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

  1. [1]The Julia Programming Languagejulialang.org
  2. [2]Julia documentation, Noteworthy differences from MATLABdocs.julialang.org
  3. [3]JuliaGPUjuliagpu.org
  4. [4]Julia documentation, Multi-processing and Distributed Computingdocs.julialang.org
  5. [5]PackageCompiler.jl documentationjulialang.github.io
  6. [6]JuliaHub, Dyadjuliahub.com
  7. [7]JuliaHub, Pricingjuliahub.com
  8. [8]SciMLsciml.ai
  9. [9]I Programmer, Julia Computing Raises $24 Million (July 2021)i-programmer.info
  10. [10]SiliconANGLE, JuliaHub lands $65M (April 30, 2026)siliconangle.com