load — Load variables from MAT-files in MATLAB and RunMat.

load reads variables from MAT-files (Level-5 layout). It can populate workspace variables directly or return a struct of loaded values, consistent with MATLAB semantics.

Syntax

S = load()
S = load(filename)
S = load(filename, varName1, varName2, ...)
S = load(filename, "-regexp", pattern1, ...)
S = load(option, value, ...)

Inputs

Returns

Returned values from load depend on how many outputs the caller requests.

Errors

How load works

• load filename reads every variable stored in filename.mat and assigns them into the caller's workspace. When no extension is supplied, .mat is appended automatically. Set RUNMAT_LOAD_DEFAULT_PATH to override the default matlab.mat target when no filename argument is provided.
• S = load(filename) loads the file but returns a struct instead of modifying the workspace. The struct fields mirror the variables stored in the MAT-file.
• load(filename, 'A', 'B') restricts the operation to the listed variable names. String scalars, char vectors, string arrays, or cell arrays of character vectors are accepted.
• load(filename, '-regexp', '^foo', 'bar$') selects variables whose names match any of the supplied regular expressions.
• Repeated names are deduplicated so that the last occurrence wins, mirroring MATLAB's behavior.
• Unsupported data classes trigger descriptive errors. RunMat supports Level-5 double and complex numeric arrays, supported scalar integer classes, single/uint8/uint16 tensors, logical arrays, character arrays, string arrays (stored as cell-of-char data), scalar structs, real sparse matrices, and cells whose elements are composed of the supported types.
• Little-endian, big-endian, and compressed (miCOMPRESSED) Level-5 MAT-files are supported. MATLAB v7.3 MAT-files are HDF5-backed and currently report an explicit unsupported-version error.

Does RunMat run load on the GPU?

load always reads data on the host. The resulting values start on the CPU. When RunMat Accelerate is active, auto-offload heuristics may later decide to promote tensors to the GPU if they participate in accelerated expressions, but no provider hooks are required during the load operation itself. GPU-resident variables that were saved earlier are gathered back to host memory as part of file serialisation, so loading them produces standard host values.

GPU memory and residency

No manual action is required. load always creates host values. When the auto-offload planner decides that downstream computations benefit from GPU execution, it will promote tensors automatically. You can still call gpuArray on loaded variables explicitly if you want to pin them to the device immediately.

Examples

Load the entire file into the workspace

weights = [0.5, 1.0, 1.5];
save('results.mat', 'weights');
load('results.mat');
disp(norm(weights))

Load a subset of variables by name

time = 0:0.25:1;
state = [0, 0.5, 0.8, 0.6, 0.3];
save('sim_state.mat', 'time', 'state');
load('sim_state.mat', 'state', 'time');
plot(time, state)

Load variables using regular expressions

layer_1 = ones(4, 4);
layer_2 = ones(8, 8);
save('checkpoint.mat', 'layer_1', 'layer_2');
load('checkpoint.mat', '-regexp', '^layer_\d+$')

Capture loaded variables in a struct without altering the workspace

x = 3.14;
y = 2.72;
save('snapshot.mat', 'x', 'y');
S = load('snapshot.mat');
disp(fieldnames(S))

Combine explicit names and regex filters

config = struct('lr', 0.01);
weights_conv = randn(3, 3);
weights_fc = randn(4, 2);
save('model.mat', 'config', 'weights_conv', 'weights_fc');
model = load('model.mat', 'config', '-regexp', '^weights_(conv|fc)')

Honour a custom default filename

x = 0;
save(fullfile(tempdir, 'autosave.mat'), 'x');
setenv('RUNMAT_LOAD_DEFAULT_PATH', fullfile(tempdir, 'autosave.mat'));
load()

Load character and string data

labels = 'hello';
save('strings.mat', 'labels');
values = load('strings.mat', 'labels');
disp(values.labels)

Using load with coding agents

Open a RunMat example with live inputs, then ask the agent to explain how load changes the result.

FAQ

Related Io functions

Open-source implementation

Unlike proprietary runtimes, every RunMat function is open-source. Read exactly how load is executed, line by line, in Rust.

• View the source for load in Rust on GitHub
• Learn how the RunMat runtime works
• Found a bug? Open an issue with a minimal reproduction.

About RunMat

RunMat is an open-source runtime that executes MATLAB-syntax code blazing on any GPU. It is licensed under the Apache 2.0 license.

• RunMat automatically optimizes your math for GPU execution on Apple, Nvidia, and AMD hardware. No code changes needed. Simulations that took hours now take minutes.
• Start running code in seconds. RunMat runs in the browser, on the desktop, or from the CLI. No license server, no IT ticket.

Getting started · Benchmarks · Pricing