Go 1.27 adds an experimental, platform-independent interface for single instruction, multiple data operations, extending the language’s effort to make CPU vector hardware available without forcing most developers to write assembly or maintain a separate implementation for every architecture.
SIMD instructions perform the same operation across multiple values at once. They can accelerate workloads such as cryptography, data processing and artificial intelligence, and Go already uses vector operations in its Green Tea garbage collector to scan memory. Until the recent experiments, Go programs generally reached this hardware through assembly, a cost that restricted the technique to especially performance-sensitive code.
Go 1.26 introduced an experimental SIMD API for amd64. Go 1.27 expands the architecture-specific `archsimd` approach to Arm64 NEON and WebAssembly, while also introducing the higher-level `simd` package. The portable layer currently targets AVX, AVX2 and AVX-512 on amd64, NEON on Arm64, and WebAssembly SIMD instructions. Where supported instructions are unavailable, operations are emulated so the same program can still run.
The abstraction addresses differences that go well beyond instruction names. Processor families use different vector widths, ranging from fixed 128-bit formats to several fixed sizes or hardware whose vector length is established at runtime. RISC-V can expose vectors whose supported size varies, while Arm’s SVE also uses variable lengths. They also differ in masking, rearrangement and cryptographic operations. Even basic capabilities are uneven: WebAssembly, for example, lacks comparisons for vectors of 64-bit integers.
Go’s portable package removes fixed vector size from its type system and exposes operations shared across platforms, filling some gaps with other SIMD instructions. Types use plural primitive names such as `simd.Uint8s` and `simd.Float32s`; programs load vectors from slices and store results back into them. Comparisons create mask values matched to element width, which programs can use to select or filter lanes. Developers enable the experiment at build time with `GOEXPERIMENT=simd`.
The initial interface is deliberately incomplete. A cross-vector sum is not included in Go 1.27, though the Go team says `ReduceSum` is planned for the next release. Code that needs an operation missing from the portable layer can convert to an architecture-specific representation, implement the special case for each target and then convert back. That escape hatch preserves access to platform features without requiring an entire algorithm to be duplicated.
The API remains experimental, so its shape can change before any stable adoption. Its goal is nonetheless significant: near-assembly vector performance from one Go implementation, combined with functional emulation on machines that lack matching SIMD support.
