By: Ludovic Räss

Re-posted from: https://juliagpu.org/post/2026-07-06-amdgpu-2.7/index.html

The 2.6 and 2.7 releases of AMDGPU.jl broaden the package's linear-algebra coverage — GPU Cholesky, LU and now a singular value decomposition via rocSOLVER, mixed-precision matmul, and a sparse-array interface — add WMMA matrix-core support for RDNA4 GPUs, and trim time-to-first-kernel. The documentation has also been substantially expanded.

These features span the recent 2.6 and 2.7 releases. AMDGPU.jl runs on 64-bit Linux and Windows with ROCm 6.0 or later, on Julia 1.10 through 1.13; MI300-series GPUs require Julia 1.12 or later. As always, AMDGPU.versioninfo() reports what was detected on your system.

Dense linear algebra

The dense LinearAlgebra surface on ROCArray has grown considerably. Version 2.6 added GPU Cholesky and LU factorizations (with mixed-precision support and, on Julia 1.12, the allowsingular option), and 2.7 adds Hermitian support and mixed-precision matrix multiplication.

The most recent addition is a singular value decomposition: svd, svd!, svdvals and cond now work directly on ROCMatrix (#960), backed by rocSOLVER. Previously these fell through to LinearAlgebra's default divide-and-conquer path, which rocSOLVER does not implement. Two algorithms are available through an alg keyword — a QR iteration (QRAlgorithm, gesvd!) and a one-sided Jacobi method (JacobiAlgorithm, gesvdj!) — with Jacobi the default, as it is consistently faster on AMD hardware.

julia> using AMDGPU, LinearAlgebrajulia> A = AMDGPU.rand(Float32, 1000, 1000);julia> F = svd(A);          # Jacobi by default; also svdvals, condjulia> L = cholesky(A'A);   # and lu, qr, \, mul!

The two algorithms differ noticeably in practice. The table below shows the time for a full SVD of an n×n Float32 matrix on an MI300X, measured by Evelyne Ringoot (@evelyne-ringoot) (times in milliseconds; see #837 for the full data):

Sparse arrays

Sparse arrays gained a linear-algebra interface on top of rocSPARSE. The ROCSparseMatrixCSR, ROCSparseMatrixCSC and ROCSparseMatrixCOO types convert to and from a host SparseMatrixCSC, and sparse matrix–vector and matrix–matrix products work through the standard * operator, alongside format conversions and preconditioner building blocks.

FFTs

The rocFFT plan and execution path was redesigned for more predictable handling of real and complex transforms and of in-place versus out-of-place plans, all through the standard AbstractFFTs.jl interface (fft, plan_fft, rfft, and friends).

Matrix cores on RDNA4

Version 2.6 adds WMMA (Wave Matrix Multiply-Accumulate) support for RDNA4 / gfx1201+ GPUs (#929, by @ffrancesco94), alongside the existing RDNA3 support. The intrinsics live in the AMDGPU.Device.WMMA_RDNA3 and AMDGPU.Device.WMMA_RDNA4 submodules; for the 2.x cycle, WMMA aliases the RDNA3 module (#955).

A leaner load and broader toolchain support

A precompilation workload was added to cut time-to-first-kernel, and SpecialFunctions was moved into a package extension so it is only loaded when actually used. On the toolchain side, recent releases track the Julia 1.13 device libraries and LLVM up to 21.1, and make device discovery more robust on different Linux distributions. Much of this compiler and runtime work builds on the shared GPU infrastructure maintained by Valentin Churavy (@vchuravy), Gabriel Baraldi (@gbaraldi) and others.

Documentation

The documentation has been substantially expanded (#959): new usage guides for array programming, tasks and streams, and KernelAbstractions; a Libraries section covering rocBLAS/rocSOLVER, rocSPARSE, rocFFT, rocRAND and MIOpen; an FAQ with guidance on depending on AMDGPU.jl conditionally; and a feature overview on the documentation home page.

As always, update to the latest version to pick these up, and see the changelog for the full list. AMDGPU.jl is largely a community effort, and contributions, issue reports and feedback are all welcome. Thanks to Evelyne Ringoot, @ffrancesco94, Valentin Churavy, Gabriel Baraldi, and everyone else who contributed to these releases.