go-simd

Each package is a drop-in: the same signatures and byte-identical output (and errors) as the stdlib package it accelerates. The hot loop is real SIMD assembly emitted by go-asmgen (v0.5.0) for all six 64-bit Go targets — amd64, arm64, riscv64, loong64, ppc64le (VSX) and s390x (vector facility, big-endian) — and encoded by cmd/asm; the short tail delegates back to the standard library so results match exactly. The numbers are measured and honest — wins, parities, and the cases where SIMD genuinely does not help.

Six architectures, one generator. The amd64/arm64 throughput figures below are native measurements. Most repos are now measured on real IBM z15 (VXE2, native execution, 2026-07-03, -count=6) — the vector-facility kernels post clear wins (e.g. bitpack ~34×, streamvbyte decode ~20×, hex encode ~18×, matchlen ~9.2×, crc64 ~9.1×) and are bit-exact on big-endian (jsonvalidate and ascii85 still await a follow-up z15 run). ppc64le kernels are measured on real POWER9 where a GCC Compile Farm runner is available, otherwise qemu-validated for correctness. Two highlights: base32 gets real SIMD on ppc64le (VSRH) and s390x (VMLHH) precisely where Go's arm64 assembler lacks the register-variable shift and integer vector multiply it needs; and every kernel is byte-for-byte correct on big-endian s390x.

Beyond these six native targets, matchlen-wasm is a proof-of-concept 7th target — wasm-SIMD (v128) — callable from browsers and WASI hosts via //go:wasmimport, since the Go compiler does not emit v128 from Go source. It is a standalone companion repo, not one of the 21 packages below.

highway is a maintained fork of ajroetker/go-highway, not a go-asmgen package: its upstream releases require a tool module at a version that was never published, so no consumer could go mod tidy against them. The fork publishes that module, retracts the inherited broken tags and carries security updates until upstream releases the fix. On amd64 its AVX2/AVX-512 kernels need GOEXPERIMENT=simd; without it, integer kernels take an allocating generic fallback — measure before you rely on it.

Repositories

base64 drop-in

encoding/base64

encode ~17× stdlib; beats emmansun/base64 ~5–6% (cycle-model-guided).

base32 drop-in

encoding/base32

encode ~7.9× stdlib (AVX2), SIMD decode too, and arm64 NEON encode + decode (decode ~25× at 1 MiB). Real SIMD on ppc64le VSRH + s390x VMLHH; ppc64le measured on real POWER9 (decode ~5.5×). No prior pure-Go SIMD base32.

hex drop-in

encoding/hex

beats tmthrgd/go-hex both ways — encode 20.4×, decode 6.24× stdlib.

utf8 drop-in

unicode/utf8

Valid ~19× stdlib, edges stuartcarnie/go-simd ~3.5% (Lemire/Keiser).

adler32 drop-in

hash/adler32

~12–14× stdlib, but ~7% behind mhr3/adler32-simd — near-parity, honest.

strconv drop-in

strconv (base-10 parse + ParseFloat)

ParseInt/Atoi ~2.2–2.7× on long inputs; added SIMD ParseFloat (Eisel-Lemire, ~1.1–1.36×); never regresses (delegates short/uncertain).

matchlen primitive

LZ match-finder primitive

~10× scalar (NEON); real SIMD on all 6 arches; AVX2 ~2.08× SSE2. Measured native: ppc64le POWER9 ~6.3×, riscv64 X60 ~5.8×, loong64 ~11.4× scalar.

matchlen-wasm proof of concept

the 7th target: GOOS=js/wasip1 GOARCH=wasm

Go emits no v128 from source and wasm has no Plan 9 asm dialect, so a naive wasm build of matchlen falls back to scalar. The kernel lives in a companion module compiled from matchlen.wat and is called through //go:wasmimport. Measured on wazero 1.12.0 it is SLOWER below 4 KiB — 0.16x scalar at 64 B, 0.94x at 1 KiB — crosses over at 4 KiB (1.19x) and reaches 1.43x at 64 KiB. The call boundary is the cost, which is why this is a proof of concept and not the default path.

bitpack primitive

FastPFOR / simdcomp bit-packing

~21–32× scalar — byte-exact vs Lemire's simdcomp. ppc64le measured on real POWER9: Pack ~7.0×, Unpack ~11.3× (overturns the earlier ~1.1× llvm-mca estimate).

popcount primitive

Hamming weight over []byte

size-dependent: ~9–12× in-cache, converges to memory-bound out-of-cache. Measured native: loong64 LSX ~6.1×, ppc64le POWER9 ~2.9× scalar (riscv64 stays scalar — no per-element vector popcount in Go's RVV asm).

histogram primitive

byte-value histogram

multi-table scalar — measured, SIMD does NOT help (no scatter on AVX2/NEON).

crc64 drop-in

hash/crc64

first pure-Go SIMD crc64 (stdlib + all Go libs are scalar); CLMUL folding, arm64 ~4.2× stdlib; all 6 arches (riscv64/loong64 scalar).

crc32 drop-in

hash/crc32

arm64-only, deliberately: stdlib IEEE path is already hardware-assisted on amd64/ppc64le/s390x, so only arm64's serial CRC32X fallback is worth beating; PMULL/PMULL2 fold-by-eight does that, every other arch and non-IEEE polynomial just calls hash/crc32.

ascii85 drop-in

encoding/ascii85

first SIMD ascii85, SIMD encode AND decode; real SIMD on all 6 arches incl. an arm64 NEON kernel on Go 1.27. Measured native: ppc64le POWER9 ~2.9× encode, riscv64 X60 ~4.0×, loong64 ~4.3×; arm64 NEON ~3.0× / fused-scalar ~1.9× on stable Go.

floats primitive

Dot/Sum/Min/Max/Distance/CosineSimilarity (float32 + float64); Axpy/Xpby/AxpyDot/Scale (float64)

only pure-Go lib with the full vector-search API on all 6 arches (gonum/vek/kelindar are amd64-centric or partial); arm64 ~2× scalar. Since v0.4.0 the BLAS-1 updates Axpy/Xpby/AxpyDot/Scale, bit-identical to math.FMA on every arch: AVX2 3.0–7.7×, M4 NEON 1.6–5.3× over the scalar loop at n=1e3–1e6. ppc64le measured on real POWER9: f32 VSX kernel ~1.55–1.61× over naive, f64 routes to the gc-autovectorized scalar loop (it beats VSX there — honest).

xxhash primitive

XXH3-64

first Go XXH3 on all 6 SIMD arches, bit-exact vs official vectors. Honest: zeebo faster on arm64 (~22 vs ~15 GB/s), amd64 block-at-a-time kernel reaches ~0.94× zeebo. Where zeebo has no kernel we win big: riscv64 RVV ~2.5–3.5× zeebo on real X60 silicon; ppc64le near-parity (~0.91×) on real POWER9.

streamvbyte primitive

Stream VByte uint32 codec

first Go port on all 6 arches (others amd64-only); full codec — SIMD encode and decode, byte-identical to lemire/streamvbyte; decode arm64 ~10× scalar. Measured native: ppc64le POWER9 decode ~11.6×, riscv64 X60 ~4.5×, loong64 ~11.8× scalar.

ascii drop-in

ASCII case (ToUpper/ToLower/EqualFold)

branchless vector case-fold, byte-identical to bytes/strings; real SIMD on all 6 arches incl. arm64 (multiply-free sign-bit predicate); arm64 ~4.9× stdlib (ToUpper).

levenshtein primitive

edit distance (Distance)

Myers bit-parallel edit distance, 62–142× vs agnivade/levenshtein on long inputs. Honest: pure-Go bit-parallel, not vector-SIMD (word-serial column, no lane parallelism); endian-clean on all 6 arches.

bitset primitive

bulk []uint64 set ops

SIMD And/Or/AndNot/Xor + fused Count/IntersectionCount; amd64 Count ~3–3.9×. Honest: logical ops are bandwidth-bound (converge to scalar out-of-cache), popcount wins across the board.

int8dot primitive

int8 quantized dot (Dot/DotUint8/DotU8S8)

INT8 multiply-accumulate for ML embeddings, bit-exact vs scalar; amd64 AVX2 ~4×; arm64 NEON kernel on Go 1.27 (~2.4×; scalar on stable Go ≤ 1.26). Measured native: riscv64 X60 ~9.1× (biggest RVV win in the suite), loong64 ~8.9× (DotUint8 ~13.8×), ppc64le POWER9 ~4.1×.

jsonvalidate drop-in

encoding/json.Valid

byte-identical verdict to encoding/json.Valid; only SIMD JSON validator on all 6 arches (simdjson-go is amd64-only); SIMD string/space scans, ~1.4× on string-heavy JSON (number-/structure-heavy stays scalar). Measured native on string-heavy: ppc64le POWER9 ~8.5× stdlib, riscv64 X60 ~5.2×.

Every kernel is generated by go-asmgen (v0.5.0) over a shared ABI0 layout (amd64 SSE2/AVX2, arm64 NEON, loong64 LSX/LASX, riscv64 RVV, ppc64le VSX, s390x vector facility), cycle-modelled with llvm-mca, validated on real AVX2 / native arm64 / QEMU riscv64+loong64+ppc64le+s390x, and held at 100% statement coverage as a CI gate. The headline benchmarks come from native CI; s390x is measured on real IBM z15 (VXE2, 2026-07-03) and ppc64le on real POWER9 where a GCC Compile Farm runner is available.