Back to Blog

RunMat 0.7: Bringing Together Math, Simulation, CAD and PCB Design

Published11/13/2026
7 min read

On August 31, 2025, three weeks after we launched RunMat as a command-line runtime for MATLAB-language code, we wrote down where we wanted to go in the long run. The document was called Northstar.

The Northstar README, committed on August 31, 2025: an engineering design platform for MCAD, ECAD, FEA and analysis, built so a single engineer and their agents can design complex hardware such as a smartphone, rocket or drone end to end

The original roadmap started with geometry: a modeling kernel, assemblies and drawings, with analysis and simulation later. We ended up building it the other way around.

We started with analysis, because every engineering tool, from a geometry kernel to a stress solver to a circuit simulator, is resolved by math underneath, and we believed readability of that representation would matter a great deal in the future as designs got larger and more complicated.

A fast, correct runtime for that math was the foundation everything else would need, and building it first gave us a high-performance compiler pipeline that the rest of RunMat now builds on.

Today we're releasing RunMat 0.7, which deepens the math part considerably and adds the rest of what Northstar described: simulation, mechanical design (MCAD) and electronic design (ECAD).

RunMat running the multi-drone SLAM example with its figures filling the window: the user clicks Run, four drones map mountain terrain while the position-error plot grows, and the finished map turns in 3D.
0:00 / 0:00

Execute and debug highly readable matrix math fast across GPUs and CPUs

Starting with the math

Engineering teams already have decades of MATLAB-language code, written by people who think in matrices. It is a language already taught to every engineer in school, LLMs know it well, and it cuts a lot of syntax for easier readability.

In the last year, we went from a simple interpreter for MATLAB syntax math to a compiler pipeline modeled on Rust's, which lowers a program step by step: from text to a syntax tree, then to a semantic form that records what every name means, then to a control-flow graph. Each step lets the compiler resolve more of the code statically (i.e. before it's run), resulting in red underlines where math operations would fail before expensive runs, and allowing the planner to route large computation branches to the GPU when justified by operation size.

RunMat's editor underlines y = A * x in red and explains that the matrix inner dimensions 4 and 5 do not agree, before the script runs.

We also implemented the runtime semantics we were still missing, the built-in functions grew from 87 at the first release to more than 2,100, and the runtime's systematic test set grew from 966 to more than 30,000 today.

In this release, with RunMat you can now:

  • Call Python, Java and C, allowing you to use existing packages in all three languages.
  • Train and run neural networks
  • Distribute and scale your code, including parfor loops, across clusters of machines
  • Build and run your existing MEX extensions in C, C++ and Fortran

The changelog lists everything in this release.

Much of this release came from engineers who sent us their code and showed us where it didn't run yet. More than 10,000 people have used RunMat this year. Thank you to everyone who told us what your existing code needed to run, and what your work needed RunMat to support. That feedback decided what went into this release.

From arrays to geometry

Since March, we have been working on typed geometry and unit representations within RunMat, and connecting them through to the shared sparse solver and distributed computation infrastructure we were building into the runtime.

RunMat now lets you compile strongly typed geometry into STEP AP242 files, strongly typed net lists straight into Gerbers, and so much more.

In the drone arm's landing study, a load typed as [0, 0, -10] mm is underlined in red, and hovering it shows "force needs a unit of force such as N; mm measures length".

For geometry, circuits and physics, we chose the syntax the same way we did on the math side: it should be easy to read, be strongly typed with units, statically checkable, and highly extensible. Studies, parts and boards are text files that go through the same compiler as your code, so a load in the wrong units is underlined in red as you type.

RunMat reads and writes open exchange standards, so you can keep the CAD and PCB tools you already use: STEP AP242 with part names and manufacturing information, IGES, STL, DWG, DXF and PDF, KiCad and Eagle schematics and boards, and Gerber, ODB++ and IPC-2581 for the board house.

Four stills that fade into each other: NIST's CTC-03 test part opened from an AP242 STEP file; Offset face raising its top face 2 mm; the Export panel set to STEP AP242 with PMI; and the written file, ctc_03.step, with 99 named faces.
0:00 / 0:00
Test part: NIST CTC-03, from NIST's PMI STEP test cases.

Every dimension in a design carries its unit, whether you type it in the source or set it in the model.

In hinge_mount.part's Source view, the upper lug's depth is retyped from 3.4 mm to 0.25 in and the Model view shows the thicker lug; the depth is then set to 8 in the lug's Properties, and Source shows the line rewritten as 8 mm.
0:00 / 0:00

RunMat and AI

We wanted to see how far we could push the new RunMat. In RunMat almost everything is code: math, studies, parts and boards are text with units and static checks, so a model can write a load case or a bracket the same way it writes a function, and RunMat checks the result before anything runs. We had AI coding agents build a product: the camera drone in our examples, with its flight software, airframe, folding arms, gimbal, flight-controller and motor-controller boards, and the simulations that check its arm. It took about 8 hours of model time and roughly $300 in model usage, with minimal human supervision. You can open it in your browser.

RunMat MCAD on the camera drone: RunMat Agent is asked for a landing-gear skid, asks which way the skids run, then builds two carbon-fiber tubes on four aluminum clamp-legs and reports 27.2 mm ground clearance and a 36.2° tip-over angle. The view then turns to show the gear from below.
0:00 / 0:00

Inside the app, the RunMat Agent works in your project, asks before deciding anything you haven't specified, and makes every change as a diff you review.

Designing the two-story house below took about 3 hours of model time and about $100 in model usage, from the foundation and framing to the plumbing, the HVAC ducts and the electrical service drawings. This would normally take a civil engineer about 200 hours, or roughly $20,000 to $30,000 in design fees.

A two-story house model in RunMat MCAD turns while layers are hidden down to the services over the slab. Section view then cuts the house horizontally through the ground-floor walls, keeping the floor plan below. The view turns to the plan and zooms onto one stud of the south wall, showing the gypsum, the stud and cavity, the sheathing and the stucco. The solved temperature field fades in over that half stud bay, red at the room face (Room 21 °C) and blue at the stucco (Outside −10 °C), with a °C color bar and the result 8.8 W/m² · U = 0.28 W/m²K. The clip ends on the plain elevation drawings and exterior wall section A-A.
0:00 / 0:00

Finally, we wanted to make RunMat a great experience for your existing agent apps too — Claude Code and Codex connect to your RunMat project on your machine, Claude and ChatGPT connect through RunMat's remote server, and any other client that supports the Model Context Protocol (MCP) can connect the same way.

Where 0.7 leaves you

If you run MATLAB-language code, the runtime is ready for your production workloads. More than 10,000 people have now used it, more than 30,000 tests cover it, including the documented examples of each built-in function, and 0.7 has gone through extensive testing. You can use RunMat on your laptop, on a cluster using your own scheduler, or fully offline. If your team runs MATLAB-language code in production, now is the time to evaluate RunMat for it.

Simulation, MCAD and ECAD are in beta and already highly functional. Features that aren't in this release say so, and studies that don't fit in memory or meshes that fail stop with a reason. We're still finishing some commands, and we'll keep shipping releases over the coming days and weeks as we close those gaps.

We're licensing RunMat 0.7 onwards under the Business Source License. It is free for individuals, academia, open-source contributors and smaller organizations. You can read more about the license in this blog post.

The road from here

For the runtime, 1.0 means covering the rest of the language and built-in surface that existing codebases use. Alongside the tests we run today, we will run every open-source MATLAB-language repository we can find and make sure each one passes evaluation, as one more layer of validation. Simulation is working toward larger studies on a laptop, studies that read RunMat parts directly, and more physics. MCAD and ECAD are working toward every command being available to agents and the command line, and drawing standards.

Thank you

We set out towards our North Star 14 months ago. It is incredibly exciting to see a drone and a house come together in RunMat, from the math to the parts, boards and simulation. We are thrilled to see what you build with RunMat. Thank you to everyone who brought their code, their parts and their aspirations to RunMat and told us what you needed.

Things to try next: