Native compilation
LLVM 19.1.7 powers both ORC JIT execution and ahead-of-time object output through one shared lowering pipeline.
Explore native compilationPOWERFUL BY DESIGN
A thoughtful foundation.
Real native execution.
Readable source, useful types and native execution form VOID’s foundation. Explore what each feature means for your code and where development is heading.
Managed memory
A precise, non-moving tracing collector supports managed structs, nullable graphs and deep readonly access paths.
Explore managed memoryExpressive types
Exact-width numbers, value structs, structural interfaces and concrete generics bring structure to everyday code.
Explore expressive typesUseful collections
Fixed and growable arrays, slicing and ordered dictionaries are implemented in the native source pipeline.
Explore useful collectionsExplicit control flow
Results, pattern matching, closures and deterministic cleanup make intent visible in your source.
Explore explicit control flowBounded concurrency
Cooperative async tasks and structured groups are implemented. Native workers currently accept a restricted value-only subset.
Explore bounded concurrencyNative code, two ways to work.
VOID compiles source through LLVM. Just-in-time execution runs compiled code during development; ahead-of-time compilation emits an object file that can be linked into a native executable.
Both paths use the same language rules and lowering pipeline. The compiler is built with C++20 and uses LLVM 19.1.7. VOID is still in development, with no public builds available yet.
See the shape of a VOID program →Write the idea once.
Generic functions and structs express an operation or data shape in terms of a type parameter. A function such as identity<t>(value: t) -> t can return its input while keeping its concrete type.
The current compiler supports concrete generic instantiations. Exact-width numbers and structural interfaces provide other ways to describe the data and behavior your code needs.
Explore generics →Express work that can wait.
An async func can suspend at await while other cooperative tasks proceed. Structured task groups give related work a lifecycle, and bounded native workers support parallel execution of a restricted value-only subset.
These mechanisms have different roles. Cooperative async work is not automatically parallel, and worker tasks do not support arbitrary shared mutable objects. General native-library loading and automatic hot-reload watching remain future work.
Explore async and await →