MATLAB and GNU Octave: one language, two tools

A twelve-line script that solves for the three currents of a resistor network prints 2.64, 0.60 and −0.56 amperes in MATLAB, and the same three numbers in GNU Octave. One language runs in two programs: MATLAB, a product of MathWorks that needs a licence for full use, and Octave, free software that anyone may install, change and share.

Below you see that script run in Octave, what the two programs share and where their licences, releases and add-ons part ways; you choose one for a course, a lab or a research task, make a script report which program is running it, and learn the labels this track puts on code that works in only one of them.

One script runs unchanged in both programs

Here is the script. R holds the resistances of three loops of a circuit in ohms and V the source voltages in volts. The backslash in R \ V solves the linear systemlinear system: A set of linear equations solved together, written in matrix form as A*x = b. In MATLAB and Octave, x = A \ b solves it without forming an inverse. R*I = V for the currents. A for loop prints each current with fprintf, and max with two outputs returns the largest value and its position:

% same_code_both.m: the three loop currents of a resistor network.
% Resistances in ohms, sources in volts. Runs unchanged in MATLAB and Octave.
R = [ 10  -4   0
      -4  12  -6
       0  -6  15 ];
V = [24; 0; -12];
I = R \ V;                     % solve R*I = V for the currents
for k = 1:numel(I)
  fprintf('Loop %d: %6.2f A\n', k, I(k));
end
[largest, loop] = max(abs(I));
fprintf('Largest current: %.2f A, in loop %d\n', largest, loop);

Octave 11.3 ran it from a terminal. The first line of the output names the Octave that ran it, and each line after $ is a command you would type yourself:

from session import run, version

version()
run("""
octave-cli same_code_both.m
""")

# GNU Octave (aarch64-apple-darwin25.4.0) version 11.3.0
$ octave-cli same_code_both.m
Loop 1:   2.64 A
Loop 2:   0.60 A
Loop 3:  -0.56 A
Largest current: 2.64 A, in loop 1

MATLAB runs the same file without a change, because every line of it belongs to the language the two programs share. The Octave project describes its language as “mostly compatible with Matlab”, and the shared part is large:

• matrices written in brackets, indexing with parentheses, and the colon, as in 1:numel(I);
• the arithmetic and comparison operators, among them \ for linear systems and ~= for “not equal”;
• if, for, while and switch blocks, each closed with end;
• scripts and function files ending in .m, and comments that start with %;
• text in single quotes, cell arrays and structs;
• most built-in functions, from sum and max to inv and fprintf.

A course written for MATLAB that keeps to this part can be followed in Octave from the first day, and this track teaches this part first.

Licences, releases and add-ons set the two apart

The two programs part ways outside the language. Four differences decide most choices:

Octave reports its own licence and version, and lists the packages installed, none in this Homebrew installation:

from session import prompt, version

version()
prompt("about_octave.m")

# GNU Octave (aarch64-apple-darwin25.4.0) version 11.3.0
$ octave-cli --quiet
octave:1> license()
ans = GNU General Public License v3+
octave:2> OCTAVE_VERSION
ans = 11.3.0
octave:3> pkg list
no packages installed.

Licence. license() answers GNU General Public License v3+. The GNU GPLGNU GPL: The GNU General Public License, the free-software licence of GNU Octave (version 3 or later): anyone may run, study, change and share the program, and copies passed on keep those freedoms. lets anyone run, study, change and share Octave, and every copy passed on carries the same freedoms. MATLAB is a MathWorks product: MATLAB Online (basic) costs nothing, and everything beyond it opens with a licence from a school, an employer or a purchase.

Releases. MathWorks names its releases by year and letter, two a year, such as R2025a, R2025b, R2026a and R2026b. Octave numbers them: 11.1.0 began version 11, and 11.2.0 and 11.3.0 brought fixes. 11.3.0 came four days after 11.2.0 to repair a library version number, and Octave’s news for version 11 tells users of 11.2.0 to update to 11.3.0. Every example in this track ran on Octave 11.3.0.

Add-ons. A MATLAB toolboxtoolbox: A MathWorks product that adds functions to MATLAB for one field, such as signal processing or control systems. Code that calls its functions runs only where it is installed., such as the Signal Processing Toolbox, adds functions for one field, and MathWorks lists each toolbox as a product of its own, as it does Simulink, its environment for block-diagram models. Code that calls a toolbox function runs only where that toolbox is installed. Octave’s add-ons are packagesOctave package: An add-on for GNU Octave, such as control or signal, listed in the Octave Packages index. pkg list shows the installed packages, and a new installation has none., such as control and signal, listed in the Octave Packages index: pkg list shows what is installed, and pkg load makes an installed package’s functions available. The Homebrew installation above has none; the Windows installers from octave.org come with several packages already installed.

Choosing Octave, licensed MATLAB or MATLAB Online

Three ways of running the language fit three kinds of work:

• GNU Octave on your computer costs nothing and has no limits of time or network. It runs the shared language, so it suits most courses, assignments and research scripts that do not need Simulink or a toolbox.
• MATLAB with a licence is the full product, on the desktop and online. It is the one to use when your school, lab or employer provides a licence, or when the work needs Simulink or a toolbox.
• MATLAB Online (basic) is MATLAB in a web browser, at no cost, with Simulink and nine toolboxes. MathWorks limits it to 20 hours a month and 15 minutes of continuous compute, with 5 GB of storage in MATLAB Drive.

Answer the three questions below for a course, a lab or a project of yours. The table marks the options that fit, with the reason in every cell:

In short: Octave for most coursework and scripts, a licensed MATLAB when Simulink, a toolbox or a lab’s licence is part of the work, and the basic plan for short sessions in MATLAB itself, such as checking that your Octave script also runs there.

A script can tell which program is running it

Sometimes code must behave differently in the two programs, for example to call a function that only one of them has. The Octave manual’s test asks whether a built-in function called OCTAVE_VERSION exists. Octave has one and MATLAB does not:

% which_am_i.m: which program is running this code?
code = exist('OCTAVE_VERSION', 'builtin');
isOctave = code ~= 0;
if isOctave
  tool = 'GNU Octave';
else
  tool = 'MATLAB';
end
fprintf('exist(''OCTAVE_VERSION'', ''builtin'') returned %d\n', code);
fprintf('Running in %s, version %s\n', tool, version());
fprintf('Built for %s\n', computer());

from session import run, version

version()
run("""
octave-cli which_am_i.m
""")

# GNU Octave (aarch64-apple-darwin25.4.0) version 11.3.0
$ octave-cli which_am_i.m
exist('OCTAVE_VERSION', 'builtin') returned 5
Running in GNU Octave, version 11.3.0
Built for aarch64-apple-darwin25.4.0

In Octave, exist('OCTAVE_VERSION', 'builtin') returned 5, the code exist uses for a built-in function, so the script took its Octave branch. Step through both branches, with MATLAB’s values taken from MathWorks’ documentation:

MathWorks documents 0 as the answer for a name that is not found, so in MATLAB isOctave is false and the script reports MATLAB with its own version text. The second argument, 'builtin', makes the test safe: without it, exist also counts variables and files, so a variable or a file called OCTAVE_VERSION could make MATLAB look like Octave.

Labels mark code that runs in only one program

Octave accepts some code that MATLAB rejects. This script computes the same currents with five Octave-only shortcuts: a # comment, printf, +=, endfor and endif, and != for “not equal”. It runs in Octave, and Octave can warn about some of its own extensions:

# octave_only.m: the same currents, written with Octave-only shortcuts.
R = [10 -4 0; -4 12 -6; 0 -6 15];
V = [24; 0; -12];
I = R \ V;
total = 0;
for k = 1:numel(I)
  printf("Loop %d: %6.2f A\n", k, I(k));
  total += I(k);
endfor
if total != 0
  printf("Sum of the loop currents: %.2f A\n", total);
endif

% check_extensions.m: runs octave_only.m with Octave's warning about its own
% language extensions switched on, then switches the warning off again.
warning('on', 'Octave:language-extension');
octave_only
warning('off', 'Octave:language-extension');

from session import prompt, run, version

version()
run("""
octave-cli octave_only.m
octave-cli check_extensions.m
""")
prompt("name_value.m")
prompt("quotes.m")

# GNU Octave (aarch64-apple-darwin25.4.0) version 11.3.0
$ octave-cli octave_only.m
Loop 1:   2.64 A
Loop 2:   0.60 A
Loop 3:  -0.56 A
Sum of the loop currents: 2.68 A
$ octave-cli check_extensions.m
warning: Octave language extension used: += used as operator near line 8 of file octave_only.m
warning: called from
    check_extensions at line 4 column 1

warning: Octave language extension used: != used as operator near line 10 of file octave_only.m
warning: called from
    check_extensions at line 4 column 1

Loop 1:   2.64 A
Loop 2:   0.60 A
Loop 3:  -0.56 A
Sum of the loop currents: 2.68 A
$ octave-cli --quiet
octave:1> parts = strsplit('a,,b', ',', CollapseDelimiters=false);
octave:2> numel(parts)
ans = 3
octave:3> who
Variables visible from the current scope:

CollapseDelimiters  ans                 parts

$ octave-cli --quiet
octave:1> numel("a\tb")
ans = 3
octave:2> numel('a\tb')
ans = 4

The first run printed the currents. In the second, the warning Octave:language-extension flagged += and != but said nothing about the # comment, printf, endfor or endif, so the warning finds some extensions, not all of them. The third part goes the other way: CollapseDelimiters=false is MATLAB’s way to pass a name-value argument, but Octave 11.3 read it as an assignment, so who lists a new variable called CollapseDelimiters. The last part counts characters: inside double quotes Octave turned \t into one tab, so "a\tb" has 3, while 'a\tb' keeps all 4.

This track labels such code in the text and in the titles of examples: Octave-only, MATLAB-only, or Differs when both programs run it with different results:

Code without a label is portable, and examples run on Octave unless their title says otherwise. MATLAB behaviour that these pages describe comes from MathWorks’ documentation.

Practise: which program, which label?

Two tasks wait for the next lesson’s installation. Save which_am_i.m and same_code_both.m, run both, and set your output beside the recorded runs: only the “Built for” line should name a different platform, and the three currents must not change. With access to MATLAB or MATLAB Online (basic), run which_am_i.m there as well and see the else branch report MATLAB.

Five ideas carry this lesson: the shared language, what sets the two programs apart, choosing one, the run-time test and the labels. The practice session below starts with whichever of them your answers show to be weakest, asks one question at a time and explains each answer the moment you give it:

Interview questions

Warm-up: what is the difference between MATLAB and GNU Octave?

Both run the same core language: matrices, indexing, operators, control flow, scripts and functions, so a script that keeps to it, such as one that solves a resistor network with R \ V, runs unchanged in either. MATLAB is a MathWorks product: full use needs a licence, its add-ons are toolboxes and Simulink, and its releases are named R2026a, R2026b and so on. Octave is free software under the GNU GPL version 3 or later, its add-ons are packages from the Octave Packages index, and its releases are numbered, such as 11.3.0. Newer MATLAB features, such as string arrays, tables and Name=value calls, are missing or behave differently in Octave, and Octave accepts extensions, such as # comments, += and endif, that MATLAB rejects. Code can test which one runs it with exist('OCTAVE_VERSION', 'builtin').

Key takeaways

• MATLAB and GNU Octave run one shared language, so a script of matrices, \, loops, % comments and fprintf, such as the three-loop circuit solver, prints the same results in both.
• MATLAB is a MathWorks product whose full use needs a licence, named by year and letter (R2026b); Octave is free software under the GNU GPL version 3 or later, numbered by version (11.3.0), with packages instead of toolboxes.
• Octave suits most coursework and scripts, a licensed MATLAB suits work that needs Simulink, a toolbox or a lab’s licence, and MATLAB Online (basic) suits short sessions within its 20 hours a month and 15-minute runs.
• exist('OCTAVE_VERSION', 'builtin') returns 5 in Octave and 0 in MATLAB, so a script can branch on it; the 'builtin' argument keeps a variable or a file of that name from fooling the test.
• This track marks code as Octave-only or MATLAB-only, and Octave’s Octave:language-extension warning finds some of its own extensions, such as += and !=, but not # comments, printf or endif.