Transpiling Go to Rust and Others
Abstract
Goany (https://github.com/pdelewski/goany) is a transpiler that takes a subset of Go and compiles it to C++, C#, Rust, JavaScript, and Java, allowing developers to write portable libraries once
using familiar Go syntax and tooling. In this talk, attendees will learn why Go's simplicity makes it uniquely suited as a transpilation source, how to design a
minimal yet practical language subset for cross-language compatibility, and what trade-offs arise when mapping Go constructs to fundamentally different
languages.
Talk Description
Have you ever implemented the same logic twice because one component was written in Go and another in a different language? This is a common problem in polyglot
systems, and existing solutions — C bindings via FFI, IDL-based code generation, or transpilers like HAXE — each come with significant trade-offs: adoption
barriers, serialization overhead, or the need to learn an entirely new language.
This talk introduces a different approach: using Go itself as the source language for cross-language transpilation. https://github.com/pdelewski/goany is not a
theoretical exercise — it is a working project that already transpiles Go code to five target languages. During this session, I will show practical examples of
transpiled code, including a C64 emulator and a GUI demo running in the browser, and walk through the design decisions behind building such a tool. But building
a transpiler is only half the challenge — the other half is deciding what to transpile.
I will cover:
- The problem: why reusing logic across language boundaries remains painful, and why existing approaches (FFI, Protobuf/gRPC, HAXE, FusionLang) fall short in
certain scenarios
- Why Go is a great fit: its small, well-defined spec, comprehensive standard library, and strong tooling make it an ideal transpilation source — unlike custom
languages, every goany program is a valid Go program
- Designing the subset — what to include and why: the guiding principle behind goany's subset is to include only constructs that produce nearly one-to-one
correspondence between input and output in every target language. I will walk through the reasoning behind what made the cut (primitives, slices, structs,
multiple returns, methods, loops, conditionals) and what was deliberately left out (goroutines, generics) with examples of how each decision affects
the generated code. The subset is intentionally a work in progress — it started minimal and is gradually expanding as new constructs prove they can be mapped
cleanly across all targets
- How goany works: a walkthrough of the transpiler architecture — parsing Go's AST, mapping the chosen subset to target language constructs, and producing
readable output in C++, C#, Rust, JavaScript, and Java
- Live demos: a C64 emulator and a GUI application running in the browser via JavaScript transpilation, demonstrating that this focused subset is already
sufficient to build non-trivial, real-world applications
- Challenges: dealing with memory model differences, producing idiomatic output, and the ongoing tension between expanding the subset and maintaining clean
transpilation
The key insight of this talk is that designing a transpiler subset is not about supporting as many features as possible — it is about finding the largest common
denominator across target languages, and evolving that denominator over time as you learn what works. Attendees will walk away with a concrete framework for
thinking about cross-language compatibility, practical knowledge of building tools on top of Go's AST packages, and a new perspective on how Go's deliberate
simplicity enables use cases that more complex languages cannot.
