Software Ecosystem
2026-09-1210 min read

Rust on RISC-V 2026: Tier 2 with Host Tools + the New riscv64a23 Target

A snapshot of Rust's RISC-V platform support as of September 2026 — which targets are stable, which is new, and why the long-running Tier 1 RFC is still open. Includes practical build instructions and the limits of the current riscv64gc-unknown-linux-gnu tier.

Rust riscv64gc riscv64a23 Tier 2 Tier 1 RFC toolchain CPython follow-up

Overview

The Rust language's tier policy has moved from "experimental" to "stable guarantee to build" on RISC-V over the past year. As of 9 September 2026, the official Rust Platform Support page lists riscv64gc-unknown-linux-gnu as a Tier 2 with Host Tools target, and adds riscv64a23-unknown-linux-gnu as a new Tier 2 entry. The Tier 1 promotion RFC for RISC-V has been open since October 2024 and remains blocked on test-infrastructure headroom.

This article is the Rust companion to our earlier CPython RISC-V Tier 3 piece. Where CPython crossed into Tier 3 on the back of RISE buildbot hardware, Rust is two tiers higher and moving on a different axis: not whether RISC-V compiles, but how much CI time the project can consume without bumping into GitHub's hosted-runner ceiling.

What the Tier System Actually Means

Rust's platform-support tier policy defines four support levels for each <arch>-<vendor>-<os>-<abi> target. The practical consequences for RISC-V are:

TierBuild guaranteeTest guaranteeHost tools includedRISC-V status (Sep 2026)
Tier 1YesYes (full PR-blocking CI)Yes (rustc, cargo, std)Not yet — RFC open since Oct 2024
Tier 2 with Host ToolsYesPartial (build-only)Yes (rustc, cargo, std on the target)riscv64gc-unknown-linux-gnu
Tier 2 (no host tools)YesPartialNoriscv64gc-unknown-linux-musl, riscv64gc-unknown-none-elf, riscv64a23-unknown-linux-gnu
Tier 3Best-effortNoNoriscv32gc-unknown-linux-gnu, riscv64gc-unknown-{freebsd,fuchsia}

"Guaranteed to build" for Tier 2 means the project ships pre-built standard-library binaries for the target on every release channel, and an automated builder proves that every change to rustc still compiles cleanly. Crucially for RISC-V, the with Host Tools promotion of riscv64gc-unknown-linux-gnu means you can run rustc and cargo natively on a RISC-V Linux box — not just produce RISC-V binaries from an x86 host. As of the 1.98 release train, rustup target add riscv64gc-unknown-linux-gnu installs cleanly on a real Star64 (JH7110) board out of the box.

The New riscv64a23-unknown-linux-gnu Target

The most consequential 2026 change is the addition of riscv64a23-unknown-linux-gnu as a Tier 2 target. The a23 in the triple denotes the RVA23 profile — the same 64-bit application-processor profile that the Server Platform Specification 1.0 references. As of September 2026 the target requires kernel 6.8.0+ and glibc 2.39, both of which are satisfied by recent SpacemiT Bianbu, Canonical Ubuntu 25.10, and Fedora 43 images.

AttributeValue
Target tripleriscv64a23-unknown-linux-gnu
Tier2 (no host tools)
Minimum kernel6.8.0
Minimum glibc2.39
ISA profileRVA23 (rv64imafdc + V + B + H + scalar crypto + Zicond + Zihintpause)
Standard libraryFull std with thread, fs, process, net
Reference hardwareSpacemiT K3 (X100 cores), SiFive P870-D reference platforms

For most production code today, the safer target is still riscv64gc-unknown-linux-gnu, because it down-ports to older kernels. But anything targeting the new K3 reference boards — or any future SiFive or SpacemiT application-processor silicon produced in 2026 and later — should opt into riscv64a23 to get vector and bitmanip intrinsics by default.

Why the Tier 1 RFC Is Still Open

The promotion of riscv64gc-unknown-linux-gnu to Tier 1 has been tracked under a Rust RFC since October 2024. The blocker is not design work; it's test-infrastructure cost. Rust's Tier 1 requirement includes a full stage 2 test suite run on every PR, and a Tier 1 RISC-V CI leg must prove that it can run that suite inside the infrastructure team's 3-hour job ceiling, even when spread across multiple machines.

Empirical numbers from the RFC thread and from RISE's production CI show that a full stage 2 run currently takes 3–4 hours even when spread across six Sophgo SG2042 nodes — one node per architecture shard, plus RISC-V shards. That is not 25% over budget, it is over budget the first time someone tries it. RISE and RVI have shipped more hardware since the RFC opened: SG2042 capacity has grown, SpacemiT donated eight K1 nodes to RISE in early 2026, and Fedora's RISC-V Koji build farm added three Scaleway EM-RV1 K3 boards in Q2. But the reference platform is moving target: Rust's test suite grows, and Tier 1 RISC-V keeps slipping just past the next budget milestone.

The honest reporting from infrastructure volunteers in 2026 has been that the headline numbers, not the design, are the gate. Until a RISC-V runner can hold stage 2 inside 3 hours with margin, the with Host Tools Tier 2 state remains the practical ceiling.

Practical Build Instructions

For developers on x86_64 Linux cross-compiling to RISC-V, the workflow is unchanged from the Tier 2 promotion:

$ rustup target add riscv64gc-unknown-linux-gnu
$ cargo build --release --target riscv64gc-unknown-linux-gnu
$ scp target/riscv64gc-unknown-linux-gnu/release/my-binary \
    risc-v-board:/tmp/
$ ssh risc-v-board /tmp/my-binary

For users running natively on a RISC-V Linux board, rustup target add riscv64gc-unknown-linux-gnu registers the host target and the existing cargo / rustc already on the machine can target itself directly:

$ uname -m
riscv64
$ rustc --print target-list | grep riscv64
riscv64gc-unknown-linux-gnu       (host)
riscv64a23-unknown-linux-gnu      (Tier 2)
riscv64gc-unknown-linux-musl      (Tier 2)
riscv64gc-unknown-none-elf        (Tier 2)
riscv32gc-unknown-linux-gnu       (Tier 3)
$ cargo build --release
   Compiling my-crate v0.1.0
    Finished `release` profile [optimized] target(s)

The 1.98.x release train of rustc / cargo on riscv64gc has been observed on StarFive VisionFive 2 (JH7110), Pine64 Star64 (JH7110), and Star64 ProVision builds against the 5.15 vendor BSP without the cross-compile detour.

What to Use — and What to Avoid

Use caseRecommended targetWhy
Cross-compile from x86_64 to a SpacemiT K3 SBCriscv64a23-unknown-linux-gnuVector and H-extension enabled by default; matches the SoC ISA string
Production services on Pine64 Star64 / VisionFive 2riscv64gc-unknown-linux-gnuStable; 5.15 kernel >= RVA23 host build works; matches K1/K3 floor ISA
Bare-metal firmware or RTOSriscv64gc-unknown-none-elfno_std targets; supports custom linkers and embedded HAL crates
Linux CLI tools on Alpine / musl distrosriscv64gc-unknown-linux-muslTier 2 static linking via musl, for slim Docker images
Tier 1 production CINot yet — use Tier 2 + project-level CI matrixPromotion is blocked on infra headroom, not on toolchain maturity

Ecosystem Notes

Rust's RISC-V story is no longer a one-target curiosity. As of September 2026:

Relation to the CPython Story

Our earlier CPython Tier 3 article traced Python's deliberate ascent: from none, to test-only, to Tier 3, with a roadmap to Tier 2 once the buildbot fleet achieves ~80% pass parity. Rust is running a similar ascent, but with three structural differences:

  1. Rust's Tier 2 with Host Tools is higher than CPython's Tier 3: it gives you a native rustc on the board, not just a CI pass result.
  2. Rust's Tier 1 blocker is fundamentally an infrastructure cost, not a conformance question — the toolchain already works.
  3. Rust's tier-1 host-tool eligibility unlocks downstream projects that depend on Rust-on-the-target: cargo-driven firmware update tooling, native rustc in distros, and Rust-targeted HPC rollouts such as the RISE project has begun on K3 nodes.

Until stage 2 fits inside the 3-hour window, Tier 2 with Host Tools is the production-grade line in the sand. Pin to that, and treat the Tier 1 RFC as a pending, but not promised, arrival.

Authoritative References

← All Articles