Vale is a fast, safe, and easy programming language.
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!");
}
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:
- 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
- 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 Memory Safety with Vale Regions (Preview)
- Hash Codes, Non-Determinism, and Other Eldritch Horrors
- Perfect Replayability
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.