Vale is a fast, safe, and easy programming language.

Vale is archived and no longer being worked on, but its spirit lives on in the new Valen programming language, which is Vale with a new memory safety approach plus Rust interop. See The Golden Spike, and Resurrecting the Vale(n) Programming Language. This site will always remain up for posterity. Cheers!

Vale is:

Fast: Vale is AOT compiled to LLVM, statically-typed, and uses the new generational references technique for memory safety with speed and flexibility, and will soon have region borrow checking to make it even faster.
Safe: It is the safest native language, thanks to generational references and Fearless FFI.
Easy: Vale has memory-safe single ownership without garbage collection or a borrow checker, which makes it easy to write safe, fast code.

Vale is currently in alpha! Download version 0.2 here.

Read comparisons with C++, Javascript, and Rust!

Upcoming Features:

We'll soon bring even more new features and designs into the programming world:

A region borrow checker to eliminate memory-safety overhead.
Seamless Concurrency for parallelism without added complexity!
Perfect Replayability to completely eliminate heisenbugs, even in the presence of multithreading!
Dependency Sandboxing to keep external code from corrupting Vale memory, and mitigate supply chain attacks.
Hybrid-Generational Memory, which could reduce the overhead of generational references.

See the Roadmap for more!

Featuring:

Single Ownership and move semantics without needing a borrow checker.
Higher RAII, which helps us remember to call any function at some point in the future.
Statically Typed with type inference.
Memory Safe with generational references
Generics and const generics
Universal Function Call Syntax
Mutable and Immutable Objects
Patterns with destructuring
Regions for different allocation strategies. (planned!)
Interface Constructors (planned!)

import stdlib.*;

exported func main() {
  println("Hello world!");
}

Hello world!

import stdlib.*;

exported func main() {
  planets = [#]("Venus", "Earth", "Mars");
  foreach planet in planets {
    println("Hello " + planet + "!");
  }
}

Hello Venus!
Hello Earth!
Hello Mars!

Our goal is to make Vale the best language for high-performance low-overhead use cases, such as servers, games, simulations, and systems programming.

Recent posts:

Follow along via our RSS feed, twitter, or the r/Vale subreddit!

What's been happening recently:

July 11: 2023: More regions stages merged (Instantiator, Simplifer), only one left!
July 2: 2023: More regions stages merged (Lexer, Parser, PostParser, HigherTyping).
June 9: 2023: Regions backend portion merged!
May 1: 2023: Regions prototyped!
Mar 18: 2023: First program with zero-cost region borrowing done!
Mar 9: 2023: Region borrowing proof-of-concept finished!
Nov 16, 2022: Full regions design preview published!
Sep 29, 2022: Templates to generics transition complete!
Aug 22, 2022: Parsing and Typing passes now work with generics!
Jul 5, 2022: Templates to generics transition started!
Jun 11, 2022: Perfect replayability now supports structs!
May 25, 2022: First successful run of perfect replayability!
May 10, 2022: Vale 0.2 Released
Apr 26, 2022: Stack switching for Fearless FFI successfully prototyped! Usable with --enable_side_calling true.
Apr 4, 2022: Sped up compile times by 4.2%.
Mar 21, 2022: Version 0.2 beta released!
Mar 3, 2022: Higher RAII added to the standard library, and used in 7DRL!
Feb 11, 2022: Concept functions added.
Feb 11, 2022: 0.1.4 released, improving syntax.
Jan 20, 2022: Sped up compiler up by 10-11x, by caching hash calculations.
Dec 9, 2021: Revamped arrays to enable partially filled arrays.
Nov 26, 2021: Major compiler refactoring, including variadic members.

Vale is open for contributions, thank you to our team of contributors!

Thank you to our sponsors! Your support is making all this possible.