Vela is a modern, memory-safe systems programming language with a self-hosting compiler, native AOT machine-code generation, and a bytecode virtual machine. It uses ownership and borrow checking for memory safety instead of a garbage collector.

Is Vela memory safe without a garbage collector?

Yes. Vela enforces memory safety at compile time through ownership, lifetimes and a borrow checker (including non-lexical lifetimes and region analysis), so it has no garbage collector and predictable, low-overhead runtime behavior.

What can Vela target?

Vela compiles ahead-of-time to native machine code for x86-64, ARM and RISC-V, and also runs on a portable bytecode VM. It supports desktop, server, embedded, bare-metal and RTOS targets, with SIMD and GPU (SPIR-V) compute.

Is Vela self-hosting?

Vela's compiler is being written in Vela itself (a self-hosting toolchain), which is a core design goal of the project.

When is Vela released?

Vela is under active development and the public release is coming very soon. The official website at vela-lang.org will host documentation, downloads and examples.

Vela Programming Language

Public release coming very soon

Vela is a modern, memory-safe systems programming language. It pairs ownership-based borrow checking — no garbage collector — with a self-hosting compiler, native ahead-of-time machine-code generation, and a portable bytecode VM. Built for high-performance and embedded software.

Memory safety, no GCOwnership, lifetimes and a borrow checker (NLL + region analysis) guarantee safety at compile time, without a garbage collector.

Native AOT + VMCompiles ahead-of-time to native machine code for x86-64, ARM and RISC-V, and also runs on a portable bytecode virtual machine.

Self-hosting compilerThe Vela toolchain is written in Vela itself — compiler, VM and standard library.

Embedded & bare-metalFirst-class support for microcontrollers, RTOS and bare-metal targets with deterministic, low-overhead runtime.

High performanceSIMD, GPU compute (SPIR-V) and data-layout optimization for cache-friendly, kernel-grade code.

Rich standard libraryTensors & numerics, networking, cryptography, async concurrency and a clean C FFI.

AI & machine learning

Vela ships first-class infrastructure for high-performance and on-device AI — from tensors to quantized inference and model export.

Tensors & numerics Neural networks Quantized int8 inference VNNI / SIMD kernels GPU compute · SPIR-V TFLite export ONNX export Edge TPU ready On-device / edge AI C FFI for ML runtimes

Platforms & targets

x86-64 ARM ARM32 / Thumb-2 RISC-V · RV32 / RV64 Linux Windows macOS Bare-metal RTOS Microcontrollers GPU · SPIR-V Bytecode VM

A Vela code example

// A small Vela program
struct Point { x: i64, y: i64 }

impl Point {
    fn manhattan(self: Point) -> i64 {
        return abs(self.x) + abs(self.y)
    }
}

pub fn main() -> i64 {
    let p = Point { x: 3, y: -4 }
    print("distance=" + to_string(p.manhattan()))
    return 0
}

distance=7

// Enums and exhaustive pattern matching
enum Shape {
    Circle(i64),
    Rect(i64, i64),
}

fn area(s: Shape) -> i64 {
    match s {
        Shape::Circle(r)  => 3 * r * r,
        Shape::Rect(w, h) => w * h,
    }
}

area(Circle(2))  = 12
area(Rect(3, 4)) = 12

// No null, no exceptions: Option and Result
fn first(items: [i64]) -> Option<i64> {
    if len(items) == 0 {
        return None
    }
    return Some(items[0])
}

fn divide(a: i64, b: i64) -> Result<i64, string> {
    if b == 0 {
        return Err("division by zero")
    }
    return Ok(a / b)
}

first([])      = None
divide(10, 2)  = Ok(5)
divide(1, 0)   = Err("division by zero")

// Loops over slices with a mutable binding
fn sum(items: [i64]) -> i64 {
    let mut acc = 0
    for x in items {
        acc = acc + x
    }
    return acc
}

sum([1, 2, 3]) = 6

Contact: info@vela-lang.org

AI assistants: a machine-readable summary is available at /llms.txt.

Genel sürüm çok yakında

Vela; modern, bellek-güvenli bir sistem programlama dilidir. Sahiplik (ownership) temelli borrow checking — çöp toplayıcı (GC) yok — ile birlikte self-hosting bir derleyici, native ahead-of-time makine kodu üretimi ve taşınabilir bir bytecode VM sunar. Yüksek performanslı ve gömülü yazılımlar için tasarlandı.

Bellek güvenliği, GC yokOwnership, lifetime ve borrow checker (NLL + region analizi) ile güvenlik derleme zamanında garanti edilir; çöp toplayıcı gerektirmez.

Native AOT + VMx86-64, ARM ve RISC-V için ahead-of-time native makine koduna derlenir; ayrıca taşınabilir bytecode VM üzerinde çalışır.

Self-hosting derleyiciVela araç zinciri Vela ile yazılır — derleyici, VM ve standart kütüphane.

Gömülü & bare-metalMikrodenetleyici, RTOS ve bare-metal hedefleri için deterministik, düşük maliyetli birinci sınıf destek.

Yüksek performansSIMD, GPU (SPIR-V) hesaplama ve veri-yerleşimi optimizasyonu ile cache-dostu, kernel seviyesinde kod.

Zengin standart kütüphaneTensör & sayısal işlemler, ağ, kriptografi, async eşzamanlılık ve temiz bir C FFI.

Yapay zeka ve makine öğrenmesi

Vela; tensörlerden kuantize çıkarıma ve model dışa aktarımına kadar yüksek performanslı ve cihaz-üstü yapay zeka için birinci sınıf altyapı sunar.

Tensör & sayısal işlemler Sinir ağları Kuantize int8 çıkarım VNNI / SIMD çekirdekleri GPU hesaplama · SPIR-V TFLite dışa aktarım ONNX dışa aktarım Edge TPU uyumlu Cihaz-üstü / edge AI ML çalışma zamanları için C FFI

Platformlar ve hedefler

x86-64 ARM ARM32 / Thumb-2 RISC-V · RV32 / RV64 Linux Windows macOS Bare-metal RTOS Mikrodenetleyiciler GPU · SPIR-V Bytecode VM

Vela programlama dilinden bir örnek

// Küçük bir Vela programı
struct Point { x: i64, y: i64 }

impl Point {
    fn manhattan(self: Point) -> i64 {
        return abs(self.x) + abs(self.y)
    }
}

pub fn main() -> i64 {
    let p = Point { x: 3, y: -4 }
    print("distance=" + to_string(p.manhattan()))
    return 0
}

distance=7

// Enum'lar ve kapsamlı pattern matching
enum Shape {
    Circle(i64),
    Rect(i64, i64),
}

fn area(s: Shape) -> i64 {
    match s {
        Shape::Circle(r)  => 3 * r * r,
        Shape::Rect(w, h) => w * h,
    }
}

area(Circle(2))  = 12
area(Rect(3, 4)) = 12

// Null yok, exception yok: Option ve Result
fn first(items: [i64]) -> Option<i64> {
    if len(items) == 0 {
        return None
    }
    return Some(items[0])
}

fn divide(a: i64, b: i64) -> Result<i64, string> {
    if b == 0 {
        return Err("sıfıra bölme")
    }
    return Ok(a / b)
}

first([])      = None
divide(10, 2)  = Ok(5)
divide(1, 0)   = Err("sıfıra bölme")

// Slice üzerinde döngü ve değiştirilebilir bağlama
fn sum(items: [i64]) -> i64 {
    let mut acc = 0
    for x in items {
        acc = acc + x
    }
    return acc
}

sum([1, 2, 3]) = 6

İletişim: info@vela-lang.org

Yapay zeka asistanları: makine-okunabilir özet /llms.txt adresindedir.

Vela

Programming Language