Welcome! I'm Evan Ovadia, a software architect, hobbyist game developer, and lead for the Vale Programming Language.
I use this site to blog about my endeavors. Enjoy!
Recent posts:
- The Golden Spike, and Resurrecting the Vale(n) Programming Language
- Ante: A New Way to Blend Borrow Checking and Reference Counting
- The Impossible Optimization, and the Metaprogramming To Achieve It
- Group Borrowing: Zero-Cost Memory Safety with Fewer Restrictions
- On Joining the Mojo Compiler Team
- Crossing the Impossible FFI Boundary, and My Gradual Descent Into Madness
- Exploring Seamless Rust Interop for Newer Languages, Part 1
- Higher RAII, and the Seven Arcane Uses of Linear Types
- Layer-wise inferencing + batching: Small VRAM doesn't limit LLM throughput anymore
- Borrow checking, RC, GC, and the Eleven (!) Other Memory Safety Approaches
- Vale's First Prototype for Immutable Region Borrowing
- Generational References (Updated)
- Making C++ Memory-Safe Without Borrow Checking, RC, or Tracing GC
- Chasing the Myth of Zero-Overhead Memory Safety
- Single Ownership and Memory Safety without Borrow Checking, RC, or GC
- The Link Between Generics, Compile Times, Type-Erasure, Cloud Building, and Hot-Code Reloading
- What Vale Taught Me About Linear Types, Borrowing, and Memory Safety
- Implementing Vale's Region Borrowing, and its Unexpected Quest
- How To Survive Your Project's First 100,000 Lines
- Memory Safety Approaches and Development Velocity
- Implementing a New Memory Safety Approach, Part 1
- Zero-Cost Borrowing with Vale Regions (Preview)
- Hash Codes, Non-Determinism, and Other Eldritch Horrors
- Safety in Non-Memory-Safe Languages
- Perfect Replayability
- Vale's Fearless FFI, for Safer Dependencies and Supply-Chain Attack Mitigation
- Vale 0.2 Released
- Added to Vale 0.2 Beta: Concept Functions
- Const Generics and the Compile Time Spread Operator
- On Removing Let and Let Mut
- A Tale of Yak Shaving: Accidentally Making a Language, for an Engine, for a Game
- Surprising Weak-Ref Implementations: Swift, Obj-C, C++, Rust, and Vale
- Vale's Higher RAII, the pattern that saved me a vital 5 hours in the 7DRL Challenge
- Seamless, Fearless, Structured Concurrency
- Generational References
- Hybrid-Generational Memory
- Zero Cost References with Regions
- Next Steps for Single Ownership and RAII
- Announcing Vale!
Game Dev
I also do game development on the side, primarily for the 7DRL challenges!
Shattered Forest (2021)
Shattered Forest was a grand experiment in how insane we could make terrain. Its levels had paths that criss-crossed over each other, as the player could hop a few tiles away, as long as the source and destination had the same elevation.
Ember Deep (2020)
Ember Deep was the first game to use Geomancer, the pentagonal tiling editor.
It also improved a lot on Incendian Falls' time-traveling mechanic.
Incendian Falls (2019)
Incendian Falls was the first prototype of the Chronobase time-travel system. It used a DSL to define an entire database and API that allows reverting to arbitrary revisions, with built-in pauseless compaction.
I gave a talk at the 2019 Roguelike Celebration conference about Domino, the unique art style.
It was also the first game to ever use pentagonal tiling. Pretty trippy, right?
Valen
My biggest endeavor is Valen, a statically-typed ahead-of-time-compiled language that aims to be fast, safe, and flexible, with seamless Rust interop.
My plans for Valen:
- Ecosystem: Valen is able to call into existing Rust libraries, see The Golden Spike, and Resurrecting the Vale(n) Programming Language
- Speed: Valen is AOT compiled to LLVM, statically-typed, and aims to be the fastest native language, by giving more fine-grained aliasing information to LLVM.
- Safety: For memory safety and data-race safety, it is the uses the new group borrowing technique, which is like a more flexible borrow checking, with mutable aliasing.
- Flexibility: We'll be adding generational references and reference counting, which should be usable without Cell, RefCell, etc.
Vale
My biggest accomplishment is Vale, a statically-typed ahead-of-time-compiled language that aims to be fast, safe, and flexible.
It combined the best parts of C++, Rust, and Scala (and even a tiny bit of Javascript!) with some novel innovations:
- Generational References, an alternative to RC, GC, or borrow checking.
- Region Borrow Checking, which allows us to temporarily treat all pre-existing memory as immutable, enabling optimizations and seamless structured concurrency.
- Linear types which enable "Higher RAII", a way to ensure that we don't forget to do a certain operation or make a certain decision in the future.
Learn more at https://vale.dev/!
exported func main() {
planets = [#]("Venus", "Earth", "Mars");
foreach planet in planets {
println("Hello " + planet + "!");
}
}Hello Venus!
Hello Earth!
Hello Mars!Software Engineering
In the past, I've worked on the Modular's Mojo programming language, Google Earth, Google Chat, and Google MyMaps.
Mojo
From July 2024 to December 2025, I worked on the Mojo programming language, adding things like linear types, associated aliases, struct extensions, CPU/GPU boundary type-checking, and various frontend features.
My favorite part was geeking out with the team about memory safety and metaprogramming, exploring things like group borrowing and futamura projections. Also check out my LLVM conference talk on linear types!
Google Earth
I worked on Earth from 2016 to 2019. I was all up and down the stack, but spent most of my time in the C++ core, making the program correctly handle state transitions and synchronizing state with the server.
Earth was a fascinating program. It had so many moving parts with asynchronous operations, and we had to bring all of our architectural jujitsu to keep it all stable. I'm particularly proud of the unidirectional data-flow, built-in self-testing, and state management systems.
Google Chat
From 2019 to 2021, I was on the Google Chat team, diving deep into their server and client-side codebases to diagnose architectural problems and identify the sources of common bugs, and redesigning their core Message object to be more reliable in the face of a rapidly evolving feature set.
Chat was one helluva challenge. My favorite memory was when the director told me "We have a lot of problems with our message object. I need you to figure out what's causing them and fix them," which led to a months-long odyssey of archaeology and traveling to distant locales to talk to mystics present and past to figure out what the heck caused the codebase to get in its current state. That quest spawned 5 massive re-architecting projects.
Google MyMaps
I was on the MyMaps team from 2014 to 2016, on the web client team, mostly revamping the site to use Material design. Along the way, I redesigned their panel state system, which would later inform the designs for Earth's state system.
Make maps!