A high-performance SIMD (Single Instruction, Multiple Data) library for Go providing vectorized operations on float64, float32, float16, complex128, and complex64 slices.

• Pure Go assembly - Native Go assembler, simple cross-compilation
• Runtime CPU detection - Automatically selects optimal implementation (AVX-512, AVX+FMA, SSE4.1, NEON, NEON+FP16, or pure Go)
• Zero allocations - All operations work on pre-allocated slices
• 80+ operations - Arithmetic, reduction, statistical, vector, signal processing, activation functions, and complex number operations
• Multi-architecture - AMD64 (AVX-512/AVX+FMA/SSE4.1) and ARM64 (NEON/NEON+FP16) with pure Go fallback
• Half-precision support - Native FP16 SIMD on ARM64 with FP16 extension (Apple Silicon, Cortex-A55+)
• Thread-safe - All functions are safe for concurrent use

go get github.com/tphakala/simd

Requires Go 1.25+

package main

import (
    "fmt"
    "github.com/tphakala/simd/cpu"
    "github.com/tphakala/simd/f64"
)

func main() {
    fmt.Println("SIMD:", cpu.Info())

    // Vector operations
    a := []float64{1, 2, 3, 4, 5, 6, 7, 8}
    b := []float64{8, 7, 6, 5, 4, 3, 2, 1}

    // Dot product
    dot := f64.DotProduct(a, b)
    fmt.Println("Dot product:", dot) // 120

    // Element-wise operations
    dst := make([]float64, len(a))
    f64.Add(dst, a, b)
    fmt.Println("Sum:", dst) // [9, 9, 9, 9, 9, 9, 9, 9]

    // Statistical operations
    mean := f64.Mean(a)
    stddev := f64.StdDev(a)
    fmt.Printf("Mean: %.2f, StdDev: %.2f\n", mean, stddev)

    // Vector operations
    f64.Normalize(dst, a)
    fmt.Println("Normalized:", dst)

    // Distance calculation
    dist := f64.EuclideanDistance(a, b)
    fmt.Println("Distance:", dist)
}

import "github.com/tphakala/simd/cpu"

fmt.Println(cpu.Info())      // "AMD64 AVX-512", "AMD64 AVX+FMA", "AMD64 SSE2", or "ARM64 NEON"
fmt.Println(cpu.HasAVX())    // true/false
fmt.Println(cpu.HasAVX512()) // true/false
fmt.Println(cpu.HasNEON())   // true/false
fmt.Println(cpu.HasFP16())   // true/false (ARM64 half-precision SIMD)

Same API as f64 but for float32 with wider SIMD:

Additional split-format complex operations (for FFT pipelines with separate real/imag arrays):

IEEE 754 half-precision floating-point operations, optimized for ML inference, audio DSP, and memory-bandwidth-bound workloads.

import "github.com/tphakala/simd/f16"

// Convert between float32 and float16
h := f16.FromFloat32(3.14)
f := f16.ToFloat32(h)

// Vector operations (same API as f32/f64)
a := make([]f16.Float16, 1024)
b := make([]f16.Float16, 1024)
dst := make([]f16.Float16, 1024)

f16.Add(dst, a, b)           // Element-wise addition
dot := f16.DotProduct(a, b)  // Dot product (returns float32)
f16.ReLU(dst, a)             // Activation functions

Key characteristics:

• Storage: IEEE 754 half-precision (1 sign, 5 exponent, 10 mantissa bits)
• Precision: ~3.3 decimal digits, range ~6×10⁻⁸ to 65504
• Reductions: Accumulate in float32 for numerical stability
• Memory efficiency: 2x bandwidth vs float32 (8 elements per 128-bit NEON vector)

Hardware requirements:

• Native FP16 SIMD: ARM64 with FEAT_FP16 (ARMv8.2-A+)
  • Apple Silicon (M1/M2/M3/M4) ✅
  • Cortex-A55, A75, A76, A77, A78, X1, X2, X3 ✅
  • Raspberry Pi 5 (Cortex-A76) ✅
• Pure Go fallback: All other platforms
  • Raspberry Pi 3/4 (Cortex-A53/A72 - ARMv8.0) - works but no SIMD acceleration
  • AMD64 - works but no SIMD acceleration

SIMD-accelerated complex number operations for FFT-based signal processing:

These operations are designed for FFT-based signal processing pipelines:

import "github.com/tphakala/simd/c128"

// Frequency-domain multiplication (FFT convolution)
signalFFT := make([]complex128, n)
kernelFFT := make([]complex128, n)
result := make([]complex128, n)
magnitude := make([]float64, n)

// Frequency-domain filtering
c128.Mul(result, signalFFT, kernelFFT)          // Complex multiply
c128.MulConj(result, signalFFT, kernelFFT)      // Cross-correlation

// Spectrogram and magnitude analysis
c128.Abs(magnitude, signalFFT)                  // Extract magnitude for display

Use Cases:

• Abs/AbsSq: Spectrograms, power spectral density, frequency analysis
• Conj: Cross-correlation, frequency-domain filtering
• Mul/MulConj: FFT-based convolution, filtering, correlation

Benchmark (1024 elements, Intel i7-1260P AVX+FMA):

SIMD-accelerated single-precision complex number operations:

Same API as c128 but for complex64 with 2x wider SIMD (8 bytes vs 16 bytes per element):

import "github.com/tphakala/simd/c64"

// Single-precision FFT processing
signalFFT := make([]complex64, n)
kernelFFT := make([]complex64, n)
result := make([]complex64, n)
magnitude := make([]float32, n)

c64.Mul(result, signalFFT, kernelFFT)     // Complex multiply
c64.Abs(magnitude, signalFFT)              // Extract magnitude

*Variance/StdDev benchmarked at 4096 elements (SIMD benefits at larger sizes)

float32 (1024 elements):

float64 (1024 elements):

Key Characteristics:

• Tanh: 200x+ speedup for f32 - fast approximation with saturation vs math.Tanh
• ReLU: Highest throughput (211-240 GB/s) - simple max(0, x) operation
• Sigmoid: 43x speedup for f32 - fast approximation with exponential

• AMD64: Explicit SIMD provides 5x speedups for most operations compared to pure Go, with consistent high throughput across all vector sizes.

• ARM64: NEON SIMD provides substantial speedups over pure Go across all operations:

  • float32: 3.7x - 5.2x faster (4 elements per 128-bit vector)
  • float64: 2.2x - 2.6x faster (2 elements per 128-bit vector)

• CumulativeSum is inherently sequential (each element depends on the previous) and uses pure Go on all platforms.

On AMD64, the Min and Max functions fall back to pure Go for small slices:

• float64: slices with fewer than 4 elements
• float32: slices with fewer than 8 elements

This is because AVX assembly loads multiple elements at once (4 float64s or 8 float32s), which would cause out-of-bounds memory access on smaller slices.

The Go fallback for small slices is intentional and likely optimal - SIMD setup overhead (register loading, masking, horizontal reduction) would exceed the cost of a simple 2-3 element comparison loop.

ARM64 FP16 support by device:

1. Pure Go assembly - Native Go assembler for maximum portability and easy cross-compilation
2. Runtime dispatch - CPU features detected once at init time, zero runtime overhead
3. Zero allocations - No heap allocations in hot paths
4. Safe defaults - Gracefully falls back to pure Go on unsupported CPUs
5. Boundary safe - Handles any slice length, not just SIMD-aligned sizes

The library includes comprehensive tests with pure Go reference implementations for validation:

# Run all tests
go test ./...

# Run tests with verbose output
task test

# Run benchmarks
task bench

# Compare SIMD vs pure Go performance
task bench:compare

# Show CPU SIMD capabilities
task cpu

See Taskfile.yml for all available tasks.

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

This project is licensed under the MIT License - see the LICENSE file for details.