title	OpenSolvers — RISC-V scientific software benchmarks
description	Benchmark notes for open-source scientific libraries, applications, and AI inference engines on consumer RISC-V boards — HPL, BLAS, Quantum ESPRESSO, llama.cpp, GROMACS, LAMMPS, EESSI, and FlexiBLAS.
permalink	/

OpenSolvers explores how open-source scientific software runs on real hardware — starting with RISC-V boards and the tools that make that practical (EESSI, OpenBLAS, and friends). Alongside classical HPC apps, we also work on AI inference engines — llama.cpp, ONNX Runtime — tuning the same core kernels (RVV, IME) that scientific codes use. This site documents what we learn along the way. If the work is useful, you can sponsor OpenSolvers on GitHub.

Why single-board computers?

We work on desk-sized RISC-V SBCs rather than huge supercomputers because the improvements we chase live at the core of the software stack — BLAS kernels, vector backends, ISA-specific bugs, and correctness that only shows up on real silicon. That work needs cores, not a full machine room. An SBC gives us the same microarchitecture we care about, with a feedback loop measured in hours instead of queue days.

Those core-level fixes and tunings are what HPC already runs at scale: the same OpenBLAS, FlexiBLAS, EESSI modules, and app binaries. Get them right on a board, and the improvement scales to a cluster or supercomputer — without needing one to do the engineering.

Videos

Walkthroughs on our YouTube channel — see the full list on the Videos page.

• 3.31× GROMACS on RISC-V (Orange Pi RV2) — hand-written RVV Force backend; FFT micro wins dilute until Force owns the wall clock (0.380 → 1.256 ns/day)
• NaN Linpack on RISC-V (Orange Pi RV2) — stock RVV OpenBLAS fails HPL with residual nan; gemv_n fix via EESSI + FlexiBLAS (10.53 GFLOP/s PASSED)
• 1.69× HPL on VisionFive 2 — U74-tuned OpenBLAS via EESSI and FlexiBLAS (3.13 → 5.28 GFLOP/s)

What we're working on

We benchmark scientific libraries, applications, and AI inference engines on consumer RISC-V boards through the EESSI stack — from BLAS kernels up to full app runs and LLM decode — swapping fixed OpenBLAS builds via FlexiBLAS without rebuilding downstream code, and staging X60 IME/RVV kernels in our llama.cpp fork.

What we optimise on the board

Each RISC-V board exposes several compute paths. We benchmark and tune them independently — often swapping backends at runtime via FlexiBLAS rather than rebuilding every app.

Path	What it is	Examples on our boards
Scalar	Scalar ISA and portable C kernels — the correctness baseline	rv64gc on VisionFive 2; OPENBLAS_CORETYPE=RISCV64_GENERIC; U74 4×4 DGEMM tuning
Vector	ISA vector extensions (RVV) in shared libs	OpenBLAS RISCV64_ZVL256B (rv64gcv + Zvl256b) on X60; FFTW r5v 1.06–1.60× vs scalar; the gemv_n bug we fixed
Custom	Custom ISA extensions beyond standard RVV	X60 IME / XsmtVdot (smt.vmadot) int8 on RV2 / F3; ONNX Runtime int4 via MLAS
GPU	Integrated Imagination GPUs (OpenCL / Vulkan)	IMG BXE-4-32 MC1 on VisionFive 2 (JH7110); IMG BXE-2-32 on RV2 / F3 (K1) — silicon is compute-capable, but vendor DDK is BXM-only (GPGPU closed; open Mesa pvr deferred)

Recent highlights on the Orange Pi RV2 (SpaceMiT X60, RVV): fixing an OpenBLAS gemv_n bug restores correctness across BLAS, LAPACK, ELPA, ScaLAPACK, HPL, and Quantum ESPRESSO. BLIS RVV assembly beats patched OpenBLAS ~1.29× on single-thread DGEMM (N=4096), but HPL linked to BLIS is correct yet only 0.35–0.53× OpenBLAS-RVV. FFTW r5v wins 1.06–1.60× in isolation but ~0% inside a real QE SCF; GROMACS sees 1.23× on isolated PME 3D-FFT and 3.31× whole-app with a hand-written RVV Force backend. LAMMPS RVV-Kokkos whole-app MD scales to 7.21× (eam, Kokkos/OpenMP) / 5.94× (rhodo, MPI) across 8 cores. ONNX accuracy_level=4 unlocks 9–10× int4 decode — ONNX Runtime / MLAS. llama.cpp: 10/10 Q4_0 models validated; IME wins prefill (up to ~2.5×), RVV wins token-gen; IME1 scale-build +4.3% pp512.

Scientific libs

Library-level probes — performance and numerical correctness:

• BLAS — OpenBLAS improvements (U74 kernel, X60 gemv_n / TRSM fixes) and OpenBLAS/ verification (bench_dgemm, difftest, verify_ctrsm)
• BLIS — FLAME BLIS rv64iv RVV vs patched OpenBLAS; 1.29× DGEMM at N=4096 (1 thread); HPL end-to-end 0.35–0.53× OpenBLAS-RVV
• NumPy — bench_blas.py DGEMM and eigvalsh through the SciPy stack
• LAPACK — LAPACK path via NumPy eigvalsh
• ELPA — dense eigensolver (CP2K / VASP class workloads)
• MLAS — ONNX Runtime QNBit int4 GEMM; isolated IME kernel rates on X60
• FFTW — RVV r5v backend A/B; QE FFT-axis shows ~0% end-to-end despite micro wins
• ScaLAPACK — distributed PDSYEV; stock RVV hangs, patched 1.09×

Apps

End-to-end application benchmarks on the same boards and EESSI toolchain:

• HPL — High Performance Linpack; OpenBLAS A/B + BLIS-linked validation from opensolvers/benchmarks
• Quantum ESPRESSO — plane-wave DFT SCF (pw.x); whole-application BLAS backend A/B with per-routine timers
• ONNX Runtime — int4 MatMulNBits LLM decode; accuracy_level=4 unlocks X60 IME (9–10×)
• llama.cpp — Q4_0 IME vs RVV; Q4_K_M study (m1gemv regresses); fork x60-ime-rvv (scale-build, softmax, M1 GEMV)
• GROMACS — PME MD; FFT-axis 1.23× on PME 3D-FFT; RVV Force backend 3.31× whole-app
• LAMMPS — RVV-Kokkos whole-app MD; five upstream benches; Kokkos 7.21× (eam) / MPI 5.94× (rhodo) on 8 cores

Boards

• StarFive VisionFive 2 — JH7110 SoC, 4× SiFive U74 (rv64gc). U74 OpenBLAS tuning: HPL 3.13 → 5.28 GFLOP/s.
• Orange Pi RV2 — SpaceMiT K1, 8× X60 (RVV). Fixed OpenBLAS: HPL FAILED (nan) → 10.53 GFLOP/s; BLIS DGEMM 1.29× / HPL 0.35–0.53×; llama.cpp IME vs RVV (10 models); IME1 scale-build +4.3%; GROMACS Force 3.31×; LAMMPS Kokkos 7.21×; ELPA 34.81 s (vs 54.92 s scalar); BXE-2-32 GPGPU closed (vendor BXM-only DDK).
• Banana Pi F3 — same K1 / X60 SoC, 3.7 GB RAM. HPL FAILED (nan) → 11.52 GFLOP/s; NumPy DGEMM up to 17.51 GFLOP/s on patched RVV; same GPU closure as RV2.

Use the menu above to jump to a board, app, or scientific lib page.

Contact

• Public: open an issue on opensolvers/benchmarks — questions, bugs, and board/benchmark requests are welcome there.
• More private: sponsor OpenSolvers and use GitHub Sponsors Contact (after sponsoring). Details and tiers are on the Sponsors page.