Welcome to XCODX Online Compiler
Quick Start:
Ctrl+Enter Run code
Ctrl+S Save / Download
Ctrl+L Clear output
Select a language and start coding.
GNU Octave is a free, open-source language for numerical computing, created by John W. Eaton. It began in the late 1980s as companion software for a chemical-reactor engineering textbook and grew into a general scientific-computing environment, with version 1.0 released in 1994 under the GPL. What sets it apart from general-purpose languages is that the matrix is its native data type: vectors, matrices, and linear algebra are built into the syntax, so solving a system with `A\b`, taking a `mean`, or multiplying matrices is a single expression rather than a loop. It is a staple of engineering courses, signal-processing labs, and numerical-methods classes, and it deliberately mirrors MATLAB, running the large majority of MATLAB `.m` scripts with little or no change. XCODX runs your code through the command-line Octave interpreter on a Piston cloud sandbox, so console output streams to a live terminal and `input()` or `fgetl(stdin)` can pause for values you type, with the exact version shown in the badge above the editor.
% GNU Octave: vectors, matrices and linear algebra (base functions only)
v = 1:2:9; % the row vector 1 3 5 7 9
printf("v ="); disp(v);
printf("sum = %d, mean = %g, std = %.4f\n", sum(v), mean(v), std(v));
A = [2 1; 1 3];
b = [3; 5];
x = A \ b; % solve the linear system A*x = b
printf("solution x = [%.2f, %.2f]\n", x(1), x(2));
disp(A * x); % multiply back to recover b = [3; 5]Reach for Octave when the problem is naturally expressed in numbers and matrices: solving linear systems, doing statistics, prototyping a signal-processing or numerical-methods algorithm, or checking the answer to an engineering problem set that expects MATLAB-style code. The base language plus Octave's bundled functions cover a great deal of that — linear algebra, the `sum`/`mean`/`std` family, `polyfit`, FFTs, and element-wise vector operations — without loading anything. It is a poor fit here for work that needs a Forge package or a MATLAB toolbox, since `pkg install` requires a network and writable storage the sandbox does not provide, and for visual work, because this is a text-only terminal: `plot`, `figure`, and `imshow` execute but draw nothing you can see. For learning the language, computation, and quick numerical checks it is genuinely capable; for interactive graphics or toolbox-heavy analysis, prototype here and finish in a local install.
Use `input("prompt")` to read and evaluate a number or expression, or `fgetl(stdin)` / `fgets(stdin)` to read a raw line of text that you parse with `str2num` or `sscanf`. The script pauses at that call until you type into the terminal or supply the Stdin Box, and output from `printf` and `disp` appears the moment it runs. Reading input is optional, and plenty of Octave scripts simply compute and print.
No. `pkg install` and Octave Forge packages need network access and a writable library, and the sandbox has neither, so a call like `pkg load signal` will fail. You have base Octave and its built-in functions only, and MATLAB's commercial toolboxes are not present either. A lot of what a toolbox does can be written directly in base Octave, so much coursework still runs unchanged.
They are close but not identical. Octave is an independent GPL project that intentionally tracks MATLAB syntax, so most `.m` scripts run unchanged, but some functions, graphics behavior, and toolboxes differ. Here you are running the real Octave interpreter, not MATLAB, and only the base language is available.
Not visually. This is a text-only terminal with no graphics device, so `plot`, `figure`, `hist`, and `imshow` run without error but produce nothing on screen. Express results as printed numbers instead — a `disp`, a `printf`, or a summary vector often conveys the same thing — and generate the figure locally once the math checks out.
The exact Octave version is shown in the badge above the editor, and it is the genuine interpreter, not a clone. Every run starts fresh with no persistent filesystem, so variables, a saved workspace, and files written with `save` or `dlmwrite` all vanish when the script ends. Keep everything the script needs in the editor, which also makes each run reproducible.
Runs have a short time limit, a source cap of roughly 50 KB, and limited memory, so very large matrices or long loops can be cut off. Vectorize where you can — Octave is far faster operating on whole arrays than looping element by element — and keep problem sizes modest, since this environment targets learning and quick experiments rather than heavy simulation.
main.mtext/x-octaveinput()% GNU Octave (MATLAB-compatible)
printf("Hello from Octave!\n");
printf("Welcome to XCODX Compiler!\n");
% Matrix operations
A = [1 2 3; 4 5 6; 7 8 9];
printf("Matrix A:\n");
disp(A);
printf("Determinant: %f\n", det(A));
printf("Sum of all elements: %d\n", sum(A(:)));
% Vector math
x = linspace(0, pi, 5);
printf("sin values: ");
disp(sin(x));