The compiler proves what it costs
A function declares its footprint (pure, non-throwing, zero allocations, O(n)) and the compiler verifies it or refuses to build.
No magic. No hidden cost.
Everything that can be written in the language is written in the language.
What is Vesta#
Vesta is a systems language designed together with its compiler, its virtual machine and its tooling, so that much of the infrastructure that is normally hidden can be written in the language itself.
In practical terms: statically typed with local inference and C-family syntax. Multi-paradigm (imperative, object-oriented and lightly functional), with no obligation to wrap anything in a class. One source runs three ways: as bytecode on its virtual machine, through a JIT once the code gets hot, or compiled ahead of time into a standalone native executable. Memory is deterministic by default (RAII, smart pointers and a borrow checker); the collector only shows up if you ask for it.
Why it exists#
In almost every language there is a line where the language ends and something else begins: components written in C, special compiler primitives, link scripts with their own syntax. Below that line you can no longer read, understand or change anything.
Vesta tries to move that line. 512-bit integers, atomic types, system calls, section layout and even the link script itself are not compiler magic: they are libraries written in Vesta that you can open.
That has a practical consequence. If you can read how an atomic is implemented, you can also adapt it to your case. The compiler stops being a black box and becomes part of the same ecosystem as the rest of your code.
What it does not try to do#
Vesta is not here to replace C, C++ or Rust. Technologies coexist for decades and each one finds its place, so it is built to interoperate with what already exists rather than ask you to leave it behind.
The principle behind it is to provide mechanisms rather than policies: the language supplies the tool, and the decision belongs to each project.
Hello world#
The same source, without changing a line, runs on the virtual machine, compiles through the JIT, or becomes a standalone native executable.
i32 main() {
println("Hello from Vesta ${1 + 1}!");
return 0;
}
Features#
Comptime, with a JIT behind it
Functions that run during compilation with the full language: native assembly, system API calls and code generation.
CTPE: the program, precomputed
If your entry point is pure, the compiler runs it at build time and folds the result into a constant. On by default.
A library that proves the point
512-bit integers, atomics and syscalls are written in Vesta, not in C and not as compiler primitives.
Its own linker, scripted in Vesta
The link script is a .vx file with a function in it, not a separate language with its own syntax.
Native, no runtime
Standalone executables with deterministic memory. The collector is linked only if you use gc<T>, and it lives inside the binary.
Typed views over memory
Describe a PE header, an MMIO register or a network packet once, then read it by field name instead of by offset.
Built for interop
Call C libraries, system DLLs and raw syscalls without leaving the language or going through libc.
How it compiles and runs#
What it can produce#
From the same source, changing only the build command:
- Bytecode
.velbfor the virtual machine - Native PE executable (Windows)
- Native ELF executable (Linux)
- Shared library
.so - Static library
.a - Relocatable object
.o/.obj - Flat binary, no header, for a boot sector or a ROM
- Portable C99, with its public header
Built from scratch#
- No LLVM. The code generator, the SSA optimizer and the x86-64 emitter are our own.
- No
ld,gccorar. Linker and archiver ship inside the compiler. - Virtual machine, JIT and AOT compiler designed together, sharing the same IR.
- Standard library written in Vesta, down to the atomics and the system calls.
- 451 example programs that compile and run across all three modes.
- Reproducible builds: same source and same compiler, same bytecode byte for byte.
Documentation#
Learn is written to be read in order, from installation to your first real program. Documentation is the language reference, meant to be searched. Compiler Internals documents the compiler itself: SSA, the optimizer, the JIT, native compilation, the linker and the incremental cache.
The Standard Library has its own section, because it is written in Vesta and that is an argument about the language rather than a catalogue of functions.
Download#
Vesta is in alpha: usable and tested, with parts still under active development. Those parts are marked as such wherever they appear.