Search for a command to run...
46 releases, 216 tests, 22x faster compilation — two months of building a language that transpiles to Go
No comments yet. Be the first to comment.
A ten-part technical blog series exploring GALA — a modern programming language that brings sealed types, pattern matching, monadic error handling, and immutable-by-default semantics to the Go ecosystem. Each post takes a single concept, shows the problem it solves with real code, compares it to idiomatic Go, and is honest about trade-offs. Written for Go developers who want more expressiveness and functional programmers who want Go's runtime.
What breaks when you map functional programming onto Go's type system, and how testing infrastructure keeps it fixed
Go's race detector samples a schedule and hopes. GALA makes a value that isn't safe to share across goroutines a build failure.
June's 0.56 -> 0.62 releases: bind/also monadic do-notation, applicative validation with Validated, and concurrent binds over Future.
Importing a third-party Go module through Bazel and rules_gala - with concrete types across the seam, verified hands-on.
From rules welded inside the language repo to a standalone, registry-published rules_gala with a real toolchain and Gazelle BUILD generation.
Eleven weeks, ~55 releases, and a new tagline: GALA hits 0.50.0 with cross-package generics, an LSP, and four new stdlib packages.
GALA (Go Alternative Language) is a programming language that transpiles to Go. It takes Go's runtime performance, static typing, and deployment simplicity, and adds the features that Go developers reach for repeatedly but never get: sealed types with exhaustive pattern matching, immutability by default, monadic error handling, functional collections, and type inference that actually works across generic boundaries.
GALA is not a new runtime or a managed language. Every .gala file becomes a .go file. Your existing Go libraries, tools, and deployment pipelines work unchanged. The goal is simple: write safer, more expressive code that compiles to the same fast binaries you already rely on.
Two months ago, GALA shipped version 0.0.1 -- a transpiler that could handle basic structs, val/var declarations, and simple pattern matching. Today, version 0.25.2 delivers a language with a rich standard library, a zero-reflection JSON codec, async primitives, and a compilation pipeline that processes multi-file packages in under 3 seconds.
Since the first release on January 23, 2026:
This pace was only possible because GALA's transpilation architecture allows rapid iteration: change the transformer, run the examples, see real Go output. No bootstrapping a VM, no managing a garbage collector.
Sealed types are GALA's answer to Go's lack of sum types. They define algebraic data types concisely, with the transpiler generating all the boilerplate -- parent structs, companion objects, Apply/Unapply methods, and discriminator checks.
sealed type Shape {
case Circle(Radius float64)
case Rectangle(Width float64, Height float64)
case Point()
}
val area = shape match {
case Circle(r) => 3.14159 * r * r
case Rectangle(w, h) => w * h
case Point() => 0.0
// No default needed -- compiler verifies exhaustiveness
}
The standard library's Option[T], Either[A, B], and Try[T] are all sealed types. They use the same resolution mechanisms as user-defined types -- no special-casing in the transpiler.
GALA's JSON codec is built on StructMeta[T], a compiler intrinsic that provides type-safe struct introspection without any reflection at runtime. The codec uses a builder pattern with naming strategies:
import . "martianoff/gala/json"
struct Person(FirstName string, LastName string, Age int)
val codec = Codec[Person](SnakeCase())
.Omit("Password")
.Rename("Email", "email_address")
val jsonStr = codec.Encode(person).Get()
// => {"first_name":"Alice","last_name":"Smith","age":30}
// Pattern matching on JSON strings
val result = jsonStr match {
case codec(p) => s"Found: ${p.FirstName}, age ${p.Age}"
case _ => "invalid JSON"
}
No struct tags. No encoding/json at runtime. The transpiler generates specialized, typed serialization code.
GALA ships immutable Array, List, HashMap, TreeMap, HashSet, and TreeSet with full functional APIs:
import . "martianoff/gala/collection_immutable"
val nums = ArrayOf(1, 2, 3, 4, 5)
val doubled = nums.Map((x) => x * 2)
val sum = nums.FoldLeft(0, (acc, x) => acc + x)
val evens = nums.Filter((x) => x % 2 == 0)
// Collect: filter + transform in one pass
val evenDoubled = nums.Collect({ case n if n % 2 == 0 => n * 2 })
Sequence pattern matching works on any collection implementing the Seq interface:
val result = list match {
case List(head, tail...) => s"First: $head, rest: ${tail.Size()}"
case _ => "empty"
}
Try[T] catches panics and wraps them as Failure, enabling railway-oriented programming without if err != nil chains:
val result = Try(() => riskyOperation())
.Map((v) => v * 2)
.Recover((e) => 0)
val msg = result match {
case Success(v) => s"Got: $v"
case Failure(e) => s"Error: ${e.Error()}"
}
Future[T] provides async computation with familiar monadic operations:
import . "martianoff/gala/concurrent"
val async = FutureApply[int](() => expensiveComputation())
val doubled = async.Map((v) => v * 2)
val value = doubled.Await().GetOrElse(0)
Functions support default values and named arguments -- the compiler reorders and injects them at the call site:
func connect(host string, port int = 8080, tls bool = true) Connection {
// ...
}
connect("localhost") // port=8080, tls=true
connect("localhost", tls = false) // port=8080, tls=false
Named arguments also work with struct construction and Copy() method overrides.
Two forms: s"..." for standard interpolation and f"..." for explicit format control:
val name = "world"
val pi = 3.14159
Println(s"Hello $name") // Hello world
Println(f"$pi%.2f") // 3.14
Auto-detected format verbs: %s for strings, %d for ints, %g for floats, %t for bools. No import needed for Println or Print.
Version 0.24.0 introduced batch transpilation, bringing multi-file package compilation from 44.7 seconds down to 2.7 seconds. The key insight: each file in a package was re-analyzing the entire dependency graph from scratch. Sharing analysis state across files in the same package eliminated the redundancy. See the companion blog post for the full story.
Version 0.25.0 added a retry combinator with pluggable backoff strategies:
import . "martianoff/gala/concurrent"
val result = Retry(
maxRetries = 3,
backoff = ExponentialBackoff(100),
fn = () => fetchFromAPI(),
)
Three strategies ship out of the box: ConstantBackoff, ExponentialBackoff, and NoBackoff.
| Package | Purpose |
std | Option, Either, Try, Tuple, StructMeta, Immutable |
collection_immutable | Array, List, HashMap, TreeMap, HashSet, TreeSet |
concurrent | Future, Promise, ExecutionContext, Retry |
json | Zero-reflection codec with builder pattern |
regex | Pattern matching extractors for regular expressions |
io | Lazy IO effect type with composition |
go_interop | SliceOf, MapOf, nil-safe helpers for Go interop |
Every standard library module follows the same rules as user code. There are no special cases in the transpiler for std types -- if you can build Option[T], you can build your own monads the same way.
Several non-trivial projects have been built with GALA during development:
Try, regex pattern matching, and collection operationsGALA is still young. The transpiler handles a broad set of Go interop scenarios, but there are rough edges -- particularly around complex generic type inference across package boundaries. The near-term focus is:
If you write Go and have wished for pattern matching, immutability, or proper sum types, give GALA a try. The playground is at https://gala-playground.fly.dev, and the full language specification is in the repository.
The transpiler is honest about what it is: a source-to-source compiler that generates readable Go. When something goes wrong, you can always read the output. That transparency is a feature, not a limitation.