# RunMat

> Open-source, GPU-accelerated MATLAB-compatible runtime for fast numerical computing across desktop, browser, and CLI.

RunMat is an open-source runtime built in Rust that executes MATLAB-syntax code with GPU acceleration across macOS, Linux, Windows, and the browser. Developed by Dystr, Inc., it targets engineers and scientists who need fast numerical computing without switching languages or managing GPU kernels manually. The core runtime is released under the Apache 2.0 license, and a desktop application plus collaborative cloud layer sit on top of it.

## What It Is

RunMat is a MATLAB-compatible numerical computing runtime that replaces the need for a MATLAB license while adding modern GPU acceleration. It accepts standard `.m` file syntax — including arrays, control flow, functions, and `classdef` — and executes them through a multi-tiered engine: a fast-startup bytecode VM for general execution and a Cranelift-based JIT for hot code paths. An acceleration engine fuses array operations into GPU kernels and keeps tensors resident on-device between operations, dispatching independent chains to parallel GPU cores. The result is the same MATLAB-style math running on Apple Metal, NVIDIA/AMD Vulkan, DirectX 12, or WebGPU without any manual kernel code.

## Architecture and Execution Model

The runtime is host-neutral and structured as a set of Rust crates covering the language frontend (lexer, parser, HIR, MIR, static analysis), execution (VM, JIT via `runmat-turbine`, builtins), GPU acceleration (`runmat-accelerate` via `wgpu`), plotting (`runmat-plot`), filesystem abstraction, CLI, and browser bindings (WASM + TypeScript). Key architectural properties include:

- **Automatic fusion**: builds an internal operation graph, fuses elementwise math and reductions into optimized GPU kernels
- **Auto-offload decisions**: estimates whether CPU or GPU execution is better for current array shapes; smaller workloads stay on CPU when transfer overhead would dominate
- **Strong static analysis**: type/shape inference and definite-assignment checks run before execution to optimize the execution plan
- **Async runtime**: built on Rust futures for non-blocking execution in web, CLI, and headless pipeline contexts
- **TypeScript/WASM bindings**: the `runmat` npm package embeds the runtime in browser, Electron, and Node hosts with session APIs, workspace snapshots, filesystem providers, and GPU status reporting

## Deployment and Platform Coverage

RunMat ships in three access modes that share the same underlying runtime:

- **Desktop app**: native application for macOS (Apple Silicon and Intel), Linux (x86_64 AppImage), and Windows (x86_64 installer); includes a code/notebook editor, GPU-rendered interactive 2D/3D plots, a workspace inspector showing type/shape/device residency per variable, and an agent harness with direct access to plots and variables
- **Browser sandbox**: runs locally in the browser via WebAssembly with zero setup; no server-side execution
- **CLI**: installable via curl script, Homebrew, or `cargo install`; supports local scripts, named project entrypoints via `runmat.toml`, and remote project execution with filesystem mounting

## Collaboration and Compliance Features

The Pro and Enterprise tiers add a collaborative project layer on top of the open-source runtime. Projects are shared workspaces with real-time file sync, automatic per-save versioning, and one-click project snapshots. Enterprise adds SSO/SAML/SCIM, audit logs, air-gapped and network-isolated deployments, bring-your-own model provider, and dedicated support. The RunMat Agent feature uses LLM credits for model calls and has direct visibility into the user's plots and variables during iteration.

## Update: RunMat v0.5.6

The latest release is v0.5.6, published on June 29, 2026, with active development ongoing (last push the same day). The GitHub repository notes that RunMat is pre-1.0 software: the core runtime, CLI, GPU engine, and TypeScript bindings are usable, but MATLAB compatibility coverage is still expanding. The repository lists 600+ built-in functions and benchmarks comparing RunMat GPU performance against NumPy, PyTorch, Octave, and Julia — the published benchmark harness reports results such as up to 131× faster than NumPy on a Monte Carlo GBM simulation and up to 144× faster than PyTorch at 1B elements on elementwise math, though the README notes results depend on hardware, driver stack, and workload shape.

## Features
- MATLAB-syntax code execution
- GPU acceleration via Metal, Vulkan, DirectX 12, WebGPU
- Automatic operation fusion into GPU kernels
- Cranelift-based JIT compiler for hot code paths
- Bytecode VM for fast startup
- 600+ built-in functions
- Interactive GPU-rendered 2D/3D plotting (30+ plot types)
- Type and shape diagnostics / static analysis
- Browser sandbox via WebAssembly (zero setup)
- Desktop app for macOS, Linux, Windows
- CLI with local and remote project execution
- TypeScript/npm bindings for browser and Node
- Real-time multiplayer project collaboration
- Automatic per-save version history
- Project snapshots
- RunMat Agent with LLM credits
- Finite Element Analysis (FEA) / Math on Geometry
- Audit logs (Enterprise)
- SSO/SAML/SCIM (Enterprise)
- Air-gapped and private deployments (Enterprise)
- Language Server Protocol (LSP) support

## Integrations
Metal (Apple GPU), Vulkan (NVIDIA/AMD GPU), DirectX 12 (Windows GPU), WebGPU, Cranelift JIT, wgpu, WebAssembly, npm / Node.js, Homebrew, Cargo / crates.io, MATLAB .m file format

## Platforms
WINDOWS, MACOS, LINUX, WEB, CLI, API, DEVELOPER_SDK

## Pricing
Open Source, Free tier available

## Version
v0.5.6

## Links
- Website: https://runmat.com
- Documentation: https://runmat.com/docs
- Repository: https://github.com/runmat-org/runmat
- EveryDev.ai: https://www.everydev.ai/tools/runmat