nalgebra

To build nalgebra-lapack against the system installation of Netlib on Ubuntu (tested on 24.04) without LAPACKE or CBLAS, install the required system dependencies and set the corresponding environment variables before building.

sudo apt-get install gfortran libblas-dev liblapack-dev
export CARGO_FEATURE_SYSTEM_NETLIB=1
export CARGO_FEATURE_EXCLUDE_LAPACKE=1
export CARGO_FEATURE_EXCLUDE_CBLAS=1

export CARGO_FEATURES="--no-default-features --features lapack-netlib"
cargo build ${CARGO_FEATURES}

The nalgebra-lapack crate uses Cargo features to determine which LAPACK implementation to use. To select a specific provider, you must disable default features and enable the desired lapack-* feature.

Common patterns include:

• Using lapack-netlib for system Netlib installations.
• Using lapack-accelerate for Apple's Accelerate framework on macOS.

To use Apple's Accelerate framework on macOS, build the package with the lapack-accelerate feature enabled and default features disabled.

export CARGO_FEATURES="--no-default-features --features lapack-accelerate"
cargo build ${CARGO_FEATURES}

While most functionalities are available in the root module nalgebra::, the recommended way to use the library is to import types and traits explicitly and use the na:: prefix for free-functions.

#[macro_use]
extern crate approx; // For the macro assert_relative_eq!
extern crate nalgebra as na;
use na::{Vector3, Rotation3};

fn main() {
    let axis  = Vector3::x_axis();
    let angle = 1.57;
    let b     = Rotation3::from_axis_angle(&axis, angle);

    assert_relative_eq!(b.axis().unwrap(), axis);
    assert_relative_eq!(b.angle(), angle);
}

The nalgebra-sparse crate provides serial routines for converting between dense matrices (DMatrix) and various sparse formats: CooMatrix (Coordinate), CsrMatrix (Compressed Sparse Row), and CscMatrix (Compressed Sparse Column).

Note that these routines are currently single-threaded.

To use nalgebra in your Rust project, add it to your Cargo.toml file. It is recommended to use the latest version.

[dependencies]
nalgebra = "*"

[dependencies]
// TODO: replace the * by the latest version.
nalgebra = "*"

Add nalgebra_sparse to your Cargo.toml dependencies to use sparse matrix formats and algorithms.

[dependencies]
nalgebra_sparse = "0.1"

To use nalgebra-glm in your Rust project, add it to your Cargo.toml dependencies:

[dependencies]
nalgebra-glm = "0.3"

It is strongly recommended to use a crate alias in your lib.rs or main.rs so you can use the glm:: prefix instead of the more verbose nalgebra_glm:::

extern crate nalgebra_glm as glm;

You can construct algebraic types using several patterns:

• Lower-case functions: Use functions named after the type in lower-case. For example, glm::vec3(x, y, z) creates a 3D vector.
• ::new constructor: Use the standard constructor, e.g., Vec3::new(x, y, z).
• make_ functions: Build types from slices using functions like glm::make_vec3(&[x, y, z]). Note that matrices constructed this way must have components in column-major order.
• Geometric construction: Use functions like glm::rotation(angle, axis) to build a 4x4 homogeneous rotation matrix.
• Swizzling: You can use nalgebra's native swizzling on nalgebra-glm vectors (up to dimension 3) to create new vectors from components (e.g., v.yxz() creates a Vec3 from components y, x, and z).