Roadmap

Vale is currently version 0.2, and we're currently working on version 0.3.

Vale's medium-term goal is to prototype the more advanced performance features, and finally benchmark.

0.1, done 2021: Foundational features (see below) and Generational References
0.2, done May 2022: FFI, Higher RAII, Modules, Faster Compiles
0.2.1, done Summer 2022: Templates -> Generics
0.2.2, done Early 2023: Linear style, zero-cost programs
0.3, Summer 2023: Basic region borrow checking, Pure calls, immutable regions
0.4, Late 2023: Inline data, proper stdlib
0.4.1, Early 2024: Seamless Structured Concurrency, Fearless FFI, Perfect Replayability
0.5, Summer 2024: Incremental + parallel compilation
0.6, Late 2024: Isolates and Cells
0.6.1, Early 2025: Optimization, Benchmarking

We'll also be publishing articles biweekly during all this. There will be some main themes:

The Next Decade in Languages series will talk about things that we think will make great strides in the next decade, and unknown gems with a lot of potential.

The Language Simplicity Manifesto series will talk about how to reduce or rearrange a language's inherent complexity. We hope that this will open the door to simpler languages.

The Perfect Replayability series will talk about how languages can help solve the problem of reproducing bugs.

The Memory Safety Grimoire series will talk about various memory safety building blocks that languages might incorporate.

The Thoughts on an Automatic Rust series will talk about Rust's innovations, and how other languages might incorporate them seamlessly.

Status Map

Done
Planned for v0.3/v0.4
Planned for Later

Advanced Features

(See further below for more basic features)

Externs

Primitives
Copying structs
Copying interfaces
Struct handles
Interface handles
Generate headers
Module prefixing
Extern interfaces
Fearless FFI
Perfect Replayability

Inlines

Final structs
Vary structs
Final interfaces
Vary interfaces

Regions

Basics
Read-only Regions
Seceding
Seamless Concurrency

Structs

Derive drop
Explicit auto-drop
constructor<T>
Destructor Parameters
Shortcalling

Interfaces

Open Shortcalling
Sealed Constructors
Sealed Shortcalling
Variants
Variant Indexing

Generics

Concepts
Static Eaching
Metaprogramming

Misc

Must-use
Private, public

Patterns

Equating
Extractors
Mutating

Operators

Bail
Map, FlatMap

Allocators

Arena
Single Pool
Shared Pool
Multi Pool

LLVM Codegen

Continue on panic
Threading
Replayability

Concurrency

Coroutines
Structured Concurrency
Threads
Mutexes

Optimization

Generational Memory
Gen-check Elimination
Hybrid-Generational Memory

Possibilities

Self-Hosting
JVM/CLR Backend
VS/IDEA Plugins

Foundational Features

Functions

UFCS
Infix Calling
Lambdas
Magic Params
Abstract Functions
Virtual Functions
Extern Calls
Overloads
Pure Functions

Structs

Mutability
Auto-drop
Constructors

Interfaces

Mutability
Open Constructors

References

Shared Refs
Owning Refs
Moving
Constraint Refs
Weak Refs
Varying/Final

Modules

Modules
Import statements
Test-only Modules
Standard Library

Arrays

Mutability
Statically-sized
Runtime-sized
Make via Lambda

Constructs

Set
If
While
Each
Match
EachI
If Let
If Let Else
Break, Continue

Patterns

Locals
Destructuring

ADTs

Tuples
Opt
Result

LLVM Codegen

Native Executables
Resilient Mod
Constraint Mode
Unsafe Mode

Operators

Short-circuiting
Owning methods
Expect

Ergonomics

Compile Errors
Syntax Highlighting

Generics

Functions
Structs/Interfaces
Const Generics

Recent Additions

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.