GNU Octave facts for kids

Kids Encyclopedia Facts

Quick facts for kids
GNU Octave

GNU Octave 4.3.0+ running on Linux
Developer(s)	John W. Eaton and many others
Initial release	4 January 1993; 32 years ago (4 January 1993) (first alpha release) 17 February 1994; 31 years ago (17 February 1994) (version 1.0)

Stable release	10.2.0 / 29 May 2025; 2 months ago (29 May 2025)

Written in	C++ (main), Octave itself (scripts), C (wrapper code), Fortran (linear algebra wrapper code)
Operating system	Windows, macOS, Linux, BSD
Available in	18 languages
Type	Scientific computing
License	2007: GPL-3.0-or-later 1992: GPL-2.0-or-later

GNU Octave is a special computer program and programming language that helps people solve math problems, especially those involving numbers and science. It's like a powerful calculator that can do very complex calculations. Octave is great for working with numbers, solving equations, and doing experiments using a language that is very similar to another popular program called MATLAB. It's also free software, which means anyone can use it, change it, and share it without paying.

History of Octave

The idea for Octave started around 1988. It was first planned to be a helpful tool for a class about designing chemical reactors. John W. Eaton began working on it fully in 1992. The very first test version came out on January 4, 1993. Then, on February 17, 1994, the first official version, 1.0, was released. The program is named after Octave Levenspiel, who was a professor of the main creator. He was known for being very good at doing quick calculations in his head.

Key Moments in Octave's Development

Octave has grown a lot over the years.

In February 1992, the actual development of the program began.
By February 1994, the first official version (1.0.0) was released.
A big step happened in December 1996 when version 2.0.x came out, which could also run on Windows computers.
December 2007 saw the release of version 3.0, which was a major milestone.
On May 29, 2015, version 4.0.0 introduced a stable graphical user interface (GUI), making it much easier to use.
More recent versions, like 9.1.0 (March 14, 2024) and 9.2.0 (June 7, 2024), have continued to improve graphics and how well it works with MATLAB. The latest stable version, 10.2.0, was released on May 29, 2025.

How Octave is Used

Besides being used on personal computers for science, Octave is also used in universities and businesses. For example, it has been used on very large supercomputers to solve big problems. It can also use special computer parts called GPUs to speed up calculations, using technologies like OpenCL or CUDA.

Inside Octave: Technical Details

Octave is mostly written in a programming language called C++.
It uses an interpreter to understand and run the commands you type in its own scripting language.
You can add new features to Octave using special add-on parts called "dynamically loadable modules."
Octave has a built-in graphics engine that uses OpenGL to create cool plots, graphs, and charts. You can also use another program called gnuplot for this.
Octave offers both a graphical user interface (GUI), which has buttons and menus, and a traditional command-line interface (CLI), where you type commands.

Octave: The Programming Language

The Octave language is a type of programming language that runs commands directly, without needing to be fully compiled first. It's a structured programming language, similar to C, and can do many common tasks.

Octave programs are usually a list of commands or a script. It's designed to work well with matrices (grids of numbers) and has many functions for doing math with them. It can also handle different ways of organizing information, called data structures, and supports object-oriented programming, which is a way to organize code using "objects."

The way you write code in Octave is very similar to MATLAB. This means that if you write a program carefully, it can often run on both Octave and MATLAB. Because Octave is free and open-source, anyone can freely change, copy, and use it. It works on many different computer systems, including Microsoft Windows, Linux, Android, and macOS.

Cool Features of Octave

Smart Typing: Command and Variable Completion

When you're typing commands in Octave, if you press the TAB key, Octave tries to guess what you're trying to type. It can complete names of variables, functions, and files. This is super helpful and saves you time!

Remembering Your Commands: Command History

When you use Octave, it remembers all the commands you've typed. This means you can easily go back and find old commands, edit them, and run them again without having to type everything from scratch.

Organizing Information: Data Structures

Octave lets you organize your data in special ways called "structures." Imagine you have different pieces of information, like a number, a list of numbers, and some text. A structure lets you group all these related pieces together under one name. For example:

octave:1> x.a = 1; x.b = [1, 2; 3, 4]; x.c = "string";
octave:2> x.a
ans =  1
octave:3> x.b
ans =

   1   2
   3   4

octave:4> x.c
ans = string
octave:5> x
x =

  scalar structure containing the fields:

    a = 1
    b =

       1   2
       3   4

    c = string

Here, `x` is a structure that holds a number (`x.a`), a grid of numbers (`x.b`), and some text (`x.c`).

Quick Math Shortcuts: Increment and Decrement Operators

Octave has quick ways to add or subtract one from a number, like `++` (add one) and `--` (subtract one). It also has shortcuts for doing math and saving the result, like `x += 5` which means `x = x + 5`.

Handling Errors: Unwind-protect and Try-Catch

Sometimes, programs run into errors. Octave has ways to handle these errors so your program doesn't just crash. One way is `unwind_protect`. It makes sure that a certain part of your code (the "cleanup" part) always runs, even if an error happens in the main part of the code.

unwind_protect
   body % This is the main code that might have an error
unwind_protect_cleanup
   cleanup % This code always runs, even if 'body' has an error
end_unwind_protect

Another way is `try-catch`. With `try-catch`, if an error happens in the "try" part, the program jumps to the "catch" part to handle the error. If no error happens, the "catch" part is skipped.

try
   body % Try to run this code
catch
   exception_handling % If an error happens above, run this code
end

Flexible Functions: Variable-Length Arguments

Octave functions can be designed to accept a different number of inputs each time you use them. This is done using `varargin`. It's like saying, "I don't know how many things you'll give me, but I'll take them all!"

Flexible Functions: Variable-Length Returns

Just like taking different numbers of inputs, Octave functions can also give back a different number of results using `varargout`. This is useful when a function might need to return one thing sometimes, and many things other times.

Working with C++

You can even use Octave code directly inside programs written in C++. This allows developers to combine the power of Octave's math tools with other C++ applications.

Octave and MATLAB: How They Compare

Octave was made to be very similar to MATLAB. They share many important features:

They both use matrices (grids of numbers) as a basic way to store data.
They both understand complex numbers (numbers that include a real part and an imaginary part).
They have many powerful math functions built-in.
You can add your own custom functions to both programs.

Octave tries to be as compatible with MATLAB as possible. If something doesn't work the same way in Octave as it does in MATLAB, it's usually considered a problem that needs to be fixed.

Small Differences in How You Write Code

While very similar, Octave has a few extra ways to write code:

You can use `#` or `%` to start a comment line (text that the computer ignores).
It supports quick math operators like `++` (add one) and `+=` (add and save).
You can use double quotes (`"`) or single quotes (`'`) for text.
You can end code blocks with more specific words like `endif` or `endfor`, not just `end`.
You can define functions right inside your scripts or when you're typing commands.

Function Compatibility

Many of the functions available in MATLAB are also in GNU Octave. Some are part of the main Octave program, and others are available through special add-on "packages" found on a website called Octave Forge. If you try to use a function that Octave doesn't have yet, it will tell you.

How You Use Octave: User Interfaces

Octave comes with an official graphical user interface (GUI), which is a visual way to use the program with menus, buttons, and windows. This GUI has been the main way to use Octave since version 4.0. People generally like it because it makes Octave much easier to use.

There are also other programs made by different groups that provide a graphical way to use Octave, like ToolboX, which is used for teaching coding.

Making Your Own Apps with Octave

You can even use Octave code to create your own simple GUI applications! This means you can make programs with buttons, text boxes, and checkboxes that other people can use. Here are some examples of what you can create:

Buttons, text boxes, and checkboxes:

# create figure and panel on it
f = figure;
# create a button (default style)
b1 = uicontrol (f, "string", "A Button", "position",[10 10 150 40]);
# create an edit control
e1 = uicontrol (f, "style", "edit", "string", "editable text", "position",[10 60 300 40]);
# create a checkbox
c1 = uicontrol (f, "style", "checkbox", "string", "a checkbox", "position",[10 120 150 40]);

A text box that asks for input:

prompt = {"Width", "Height", "Depth"};
defaults = {"1.10", "2.20", "3.30"};
rowscols = [1,10; 2,20; 3,30];
dims = inputdlg (prompt, "Enter Box Dimensions", rowscols, defaults);

A list of options with message boxes:

my_options = {"An item", "another", "yet another"};
[sel, ok] = listdlg ("ListString", my_options, "SelectionMode", "Multiple");
if (ok == 1)
  msgbox ("You selected:");
  for i = 1:numel (sel)
    msgbox (sprintf ("\t%s", my_options{sel(i)}));
  endfor
else
  msgbox ("You cancelled.");
endif

Radio buttons (where you can only pick one option):

# create figure and panel on it
f = figure;
# create a button group
gp = uibuttongroup (f, "Position", [ 0 0.5 1 1])
# create a buttons in the group
b1 = uicontrol (gp, "style", "radiobutton", "string", "Choice 1", "Position", [ 10 150 100 50 ]);
b2 = uicontrol (gp, "style", "radiobutton", "string", "Choice 2", "Position", [ 10 50 100 30 ]);
# create a button not in the group
b3 = uicontrol (f, "style", "radiobutton","string", "Not in the group","Position", [ 10 50 100 50 ]);

Octave Packages

Octave has many extra "packages" that add more functions and tools. These packages are like add-ons that you can download and install to make Octave do even more things. You can find them on websites like Octave Forge. Anyone can also create and share their own packages.

Other Similar Software

There are other free and open-source programs similar to GNU Octave, like Scilab and FreeMat. Octave is generally considered more similar to MATLAB than Scilab is. FreeMat hasn't been updated in a long time. The Julia programming language also has some similarities to Octave, especially in its ability to create plots and graphs.