ILNumerics.ONAL 0.9.4

ILNumerics.ONAL

Open Numerical Algorithm Language (ONAL) for .NET

Write serious numerical algorithms in .NET: NumPy/MATLAB semantic, proven industrial reliability, and no vendor lock-in.

Open-sourced from the proven, mature core of ILNumerics Computing.
→ Your algorithms. Your IP. Your language. ←

Learn ILNumerics.ONAL in Y minutes !

Why ILNumerics.ONAL ?

Because serious numerical software needs more than wrapping NumPy:

ILNumerics.ONAL is the open-sourced language core of ILNumerics, providing multidimensional array programming and the fundamental tools for building maintainable numerical algorithm IP in .NET. Write serious numerical algorithms in .NET — with Matlab/NumPy semantics, industrial robustness, and no vendor lock-in.

Prototype like MATLAB. Deploy like HPC software.

ILNumerics.ONAL combines:

• N-dimensional arrays
• Mathematical array programming
• Numerical algorithms and transforms
• Developer tooling and visual debugging
• Drop-in migration path to ILNumerics Computing Engine

Inspired by:

• MATLAB
• NumPy
• Julia

but built for .NET.

Features

N-Dimensional Arrays

using ILNumerics;
using static ILNumerics.ILMath;

var A = rand(4,4);
var B = sin(A) + 2*A;

Console.WriteLine(B);

Supports:

• Scalars
• Vectors
• Matrices
• Tensors
• Logical arrays
• Cell arrays

MATLAB / NumPy-like semantics included.

Array Expressions

Write mathematics naturally, use all common functions expected from an array language:

var x = linspace(0,10,1000);

var y =
    exp(-x/5) *
    sin(4*x)
    + cos(x);

Broadcasting, indexing, slicing and vectorized expressions included.

Linear Algebra

var A = rand(500,500);

Array<double> U = 0.0, V = 0.0; 
var S = svd(A, U, V);
// work with S, U, V...

Includes:

• LU
• QR
• SVD
• Eigendecomposition
• Solvers
• Matrix products

Fast Fourier Transform

var signal = sin(20*t) + .4*sin(90*t);

var spectrum = fft(signal);

Built-in signal processing foundations.

Debugging Visualizers

Numerical code should be inspectable.

Features include:

• Visual Studio tooltips
• Graphical array watch window (Visual Studio Marketplace)
• Interactive debug session support

Performance Philosophy

This project focuses strictly on semantics and functionality.
It represents the core language layer of ONAL and serves as its reference implementation.

Recent breakthroughs in the automatic parallelization of array-based algorithms make it possible to fully separate:

• what an algorithm does
• how it is executed efficiently

All performance-related concerns — previously deeply embedded in APIs and implementation — are delegated to external compilers.

What This Means in Practice

ILNumerics.ONAL provides:

• a complete, production-ready implementation of numerical array semantics
• robust and reliable execution with solid baseline performance
• no dependency on proprietary execution engines

Advanced performance features such as:

• Auto-parallelization
• Auto-vectorization
• kernel fusion and graph optimization
• Array pipelining and autonomous scheduling

are handled by ONAL-compatible compilers, such as the ILNumerics Accelerator Compiler, and can be dropped-in optionally when needed.

Result

The language core remains stable, open, and vendor-neutral, while performance can scale independently.

Write algorithms once.
Run them with reliable baseline performance.
Run them optimized later — without changing the code.

Installation

dotnet add package ILNumerics.ONAL

NuGet:

https://www.nuget.org/packages/ILNumerics.ONAL

Quick Start

⇒ Learn ILNumerics in Y minutes guide.

Matrix Example

using ILNumerics;

var A = rand(3,3);

var B = multiply(A.T, A); // matrix multiply
var C = A.T * A;          // elementwise

Solve Linear System

var A = rand(100,100);
var b = rand(100,1);

var x = linsolve(A,b);

All linear algebra uses machine-translations of the original netlib LAPACK, being more robust than manual re-implementations.

Signal Processing Example

var fs = 1000;

var t =
    linspace(
      0,
      1,
      fs);

var signal =
      sin(2*pi*50*t)
    + .5*sin(2*pi*120*t);

var spectrum = fft(signal);

Array variables are easily inspected and changes followed while debugging:

Signal Plot	Spectr.

Learn more in Y minutes: 'LearnILNumericsInYMinutes' guide.
Full documentation: ilnumerics online documentation (but make sure to ignore their 'function rules' 😉)

Contributing

Docu missing ? Feature missing ? Odd behavior ? Contributions welcome!

git clone https://github.com/ILNumerics/ILNumerics.ONAL

Open an issue or PR.

License

MIT

Citation

If you use ONAL in research:

@software{ilnumerics_onal,
 title={ILNumerics.ONAL},
 author={ILNumerics GmbH},
 year={2026},
 url={https://github.com/ILNumerics/ILNumerics.ONAL}
}