vyre · open source · MIT
Sequential logic on the GPU, bit-exact against your CPU.
GPUs are fast at parallel math and awkward at everything sequential: state machines, parsers, scanners, graph walks. vyre is the compiler substrate that closes that gap. You write the logic once in Rust, and vyre runs it on NVIDIA, AMD, or Apple hardware while producing the same results as the CPU, verified bit for bit.
Use it
cargo add vyregit clone https://github.com/santhreal/vyre && cd vyre && cargo build --releaseFrontends: C11 today, Rust in beta. Backends: CUDA, WGPU, Metal, SPIR-V.
What you can express
Sequential programs need real data structures, not just buffers. vyre gives a kernel workgroup-local stacks, queues, and hashmaps, plus compiler machinery on top: dominator trees and fixed-point dataflow. An Aho-Corasick automaton, a lexer, or a graph walk maps onto these directly instead of being rewritten into a parallel shape it does not have.
Why you can trust the fast path
A GPU result you cannot verify is a guess. Every vyre backend runs against a CPU reference implementation, and the conformance gate rejects any backend that diverges by a single bit. That is what makes GPU dispatch safe as a default rather than an opt-in: if the fast path and the slow path could disagree, you could not trust the fast one.
Who runs on it
keyhog, our secret scanner, is the first production tool on vyre. Its GPU path compiles detectors into an Aho-Corasick automaton and scans a full Linux kernel checkout in a couple of seconds, with findings bit-identical to the SIMD CPU path. Downstream tools that need GPU-accelerated scanning or high-throughput sequential matching can build on the same substrate.
Get it
github.com/santhreal/vyre - source, issues, and the conformance evidence gates. The crate is on crates.io.