Glonce

Rust gets a 'Golden Spike' to share generics with Evan Ovadia's Valen

researchThe Glonce editorsThe Register🔥66Glonce rating66Impact65Novelty75Relevance70Surprise55Players40Credibility80
Rust gets a 'Golden Spike' to share generics with Evan Ovadia's Valen

Evan Ovadia, a Mojo core contributor and former Google engineer, has built an experimental technique he calls the 'Golden Spike' that lets generic data types and functions move between Rust and another language without going through the C ABI. Ovadia is working on his own language, Valen, an offshoot of an earlier project called Vale, meant to be a faster, more developer-friendly alternative to Rust. He wanted Valen to be able to reuse existing Rust libraries, notably Rust's wgpu graphics library, but the usual route for cross-language interoperability, the C ABI, cannot express generics because C itself has no concept of generics, while both Rust and Valen use them heavily. Ovadia's fix runs the Rust compiler as a library (using Rust's existing rustc_driver capability) so Valen can embed rustc directly, and then patches Rust so that when it hits a non-Rust Valen type, it hands control to the Valen compiler and waits for the compiled result. He calls patching the Rust compiler the 'nuclear option' and says it was the riskiest part of the effort. The patch itself is about 100 lines of code, but it is hacky, assumes Rust is generating machine code through LLVM (not always true), and by Ovadia's own admission 'is definitely not upstreamable.' The work drew attention outside Rust circles too: the host of the Let's Get Rusty YouTube channel called it 'the most fascinating thing I've read in months' and dubbed it 'Rust++.' On Reddit and Lobste.rs, commenters praised the ambition of replacing C as the default FFI language while questioning some of the technical choices, with one suggesting bindings could instead be built on top of Ada. Ovadia says the technique points toward a future where new languages could bootstrap themselves from Rust libraries directly, potentially reducing reliance on the C ABI, though he is currently focused on finishing Valen rather than pursuing that further.

Key facts

  • Evan Ovadia, a Mojo core contributor and former Google engineer building his own language Valen (an offshoot of Vale), created a 'Golden Spike' technique to pass generic types and functions between Rust and Valen.
  • The C ABI, the usual cross-language interoperability layer, cannot handle generics because C has no concept of them, while both Rust and Valen rely on generics heavily.
  • Ovadia's solution runs the Rust compiler as a library via rustc_driver and patches Rust so it hands control to the Valen compiler when it encounters non-Rust types.
  • The Rust compiler patch is about 100 lines of code but is 'hacky', assumes LLVM code generation, and by Ovadia's own words is 'definitely not upstreamable.'
  • The work drew praise online, including from the Let's Get Rusty YouTube host, who called it 'Rust++', and sparked debate on Reddit and Lobste.rs about replacing C as the universal FFI language.

Why it matters

Cross-language interoperability today almost always flows through the C ABI, which strips away richer language features like generics. Ovadia's 'Golden Spike' shows a working, if rough, path for two compilers to cooperate directly and preserve generics across a language boundary, something the article frames as a genuine step forward for programming language interoperability rather than a finished product.

Who it affects

It matters most to programming-language builders and Rust library authors, since Ovadia's stated goal is to let his new language Valen reuse existing Rust libraries such as wgpu without giving up generics. More broadly, the article notes the technique opens the possibility of using Rust as a base that other new languages could bootstrap from.

How to use it

There is no packaged tool or release to install: this is an experimental compiler patch tied to Ovadia's own Valen project, described in his blog post rather than shipped as a product. Ovadia himself says the patch, at roughly 100 lines of code, is hacky, depends on Rust using LLVM for code generation, and is not upstreamable into the official Rust compiler.

How solid is it

The account comes from Ovadia's own explanatory blog post about a working technique he built and tested for his Valen project, plus reactions from a YouTube host and programmer forums, giving independent, if informal, corroboration that the demo works and is technically interesting.

Risks and caveats

Ovadia calls patching the Rust compiler the 'nuclear option' and 'the riskiest part of the whole endeavor'; the patch is hacky, assumes LLVM-based code generation which is not always how Rust compiles, and is explicitly not something that could be merged upstream. Forum commenters also questioned whether Rust's own type system limitations make it the ideal foundation for this kind of universal interoperability, with one suggesting Ada as an alternative base.

“It works, but it's definitely not upstreamable”

— Evan Ovadia