Vale

Vale is a programming language created by Evan Ovadia that explores a novel approach to memory safety called generational references. Rather than using garbage collection, reference counting, or borrow checking, Vale uses single ownership with runtime generation checks to prevent use-after-free errors. The language targets systems-level use cases such as servers, games, and simulations.

History & Origins

Development of what would become Vale began in January 2013 under the name “VLang.” The project was later renamed “GelLLVM” (in honor of Gel, an earlier language that pioneered constraint references), and eventually settled on the name “Vale.” The language was publicly released around 2020, with version 0.1 following in 2021 and version 0.2 “Kuma” in May 2022.

Design Goals

Vale was created to explore the space between high-overhead managed languages (Java, C#, Go) and complex systems languages (Rust, Ada). Ovadia’s goal was to demonstrate that memory safety models beyond garbage collection and borrow checking are viable — specifically, that generational references could offer safety with less complexity than Rust’s ownership model while avoiding the overhead of garbage collection.

Generational References

Vale’s defining innovation is its generational references memory safety technique. The approach works as follows:

• Every allocation has a generation number — an integer that increments each time the memory slot is reused
• Every reference stores the generation number of the object it was created to point at
• On dereference, Vale checks that the reference’s stored generation matches the current generation of the allocation
• If they don’t match, the object has been freed and the access is caught as an error

This provides use-after-free detection at runtime, without requiring the programmer to satisfy a borrow checker’s constraints at compile time.

Single Ownership

Like Rust, Vale uses single ownership — each mutable object has exactly one owning reference. When the owning reference goes out of scope, the object is deterministically destroyed. Non-owning references (borrow and constraint references) can exist alongside the owner but are subject to generation checks when accessed.

Performance Considerations

Vale’s own published benchmarks (January 2021) reported that generational references were approximately 2.3x faster than reference counting in their unoptimized implementation. However, these are the project’s own measurements and have not been independently verified by third parties. The planned “Hybrid-Generational Memory” optimization — using static analysis to eliminate redundant liveness checks — aims to further reduce overhead, but this has not yet been implemented.

Key Features

Higher RAII (Linear Types)

Vale extends the RAII pattern found in C++ and Rust by making it an error to implicitly destroy an object. Destructors in Vale can take parameters and return values, enabling patterns like:

• Requiring explicit cleanup with context (e.g., passing a database connection to a transaction’s destructor)
• Returning resources from destructors
• Enforcing that cleanup happens in the correct order

Concept Functions

Similar to C++ concepts, Vale’s concept functions allow specifying that certain functions must exist for given generic parameters, without requiring formal trait implementations.

Const Generics

Generic parameters in Vale can contain not only types but also integers, booleans, and other values.

Fearless FFI

Vale includes mechanisms for safe interoperability with C code, isolating unsafe foreign code from Vale’s memory safety guarantees.

Type System

Vale uses a static type system with full type inference — type annotations are optional. Key characteristics include:

• Structs with named members, mutable by default (can be made immutable with imm)
• Open interfaces that any struct can implement
• Sealed interfaces where only structs in the same file can implement (enabling exhaustive pattern matching)
• Pattern matching with destructuring
• Generics for functions and structs

Compiler Architecture

The Vale compiler (valec) has three main components:

• Frontend — Written in Scala, runs on the JVM
• Backend — Written in C++, targets LLVM
• Coordinator — Written in Vale itself

Compiling Vale source code requires a JDK (for the Scala frontend) and clang (for linking the final executable). The compiler produces native binaries via LLVM.

Current State

As of early 2026, Vale is in alpha status at version 0.2. The last GitHub release was in May 2022, and the most recent visible repository activity was in May 2024. According to the creator’s website, development is currently “on hold” while he explores new ideas such as group borrowing and new memory safety blends. Evan Ovadia worked on the Mojo compiler team at Modular from July 2024 to December 2025, contributing features like linear types and struct extensions.

Vale has not seen production use as far as can be verified. It remains an experimental/research language. The ambitious roadmap (versions 0.3 through 0.6) that was planned through 2025 has not been realized.

Why Vale Matters

Even as an experimental language, Vale’s contribution to programming language research is significant. It demonstrated that generational references are a viable memory safety mechanism — an alternative that sits between the runtime overhead of garbage collection and the compile-time complexity of borrow checking. These ideas may influence future language designs even if Vale itself does not achieve widespread adoption.