v1.0.0 — Production Ready

Write fewer tokens,
get native performance

Vais (Vibe AI Language for Systems) is a systems programming language optimized for AI code generation. Single-character keywords, expression-oriented syntax, and LLVM-powered native speed.

Try in Browser brew install vais

F fib(n: i64) -> i64 {
  I n <= 1 { n }
  E { @(n - 1) + @(n - 2) }
}

F main() {
  result := fib(10)
  println("fib(10) = {}", result)
}S Vec2 { x: f64, y: f64 }

F len(v: Vec2) -> f64 {
  sqrt(v.x * v.x + v.y * v.y)
}

F main() {
  p := Vec2 { x: 3.0, y: 4.0 }
  println("len = {}", len(p))
}E Shape {
  Circle(f64),
  Rect(f64, f64),
}

F area(s: Shape) -> f64 {
  M s {
    Circle(r) => 3.14159 * r * r,
    Rect(w, h) => w * h,
  }
}

Token Efficiency Matters

AI models pay per token. Vais uses up to 40% fewer tokens than Rust for equivalent programs — saving cost and context window.

Vais ~32 tokens

S Point {
  x: f64,
  y: f64,
}

F dist(p: Point) -> f64 {
  sqrt(p.x * p.x + p.y * p.y)
}

Rust ~52 tokens

struct Point {
    x: f64,
    y: f64,
}

fn dist(p: &Point) -> f64 {
    (p.x * p.x + p.y * p.y).sqrt()
}

Python ~48 tokens

from math import sqrt
from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

def dist(p: Point) -> float:
    return sqrt(p.x * p.x + p.y * p.y)

Token Count Comparison

Vais

Python

Rust

Why Vais?

Designed from the ground up for AI-assisted development without sacrificing performance.

Single-Char Keywords

F for function, S for struct, I/E for if/else, L for loop, M for match. Minimal tokens, maximum clarity.

Self-Recursion Operator

The @ operator calls the current function recursively. No need to repeat the function name — AI-friendly and concise.

{}

Everything is an Expression

If/else, match, and blocks all return values. No return keyword needed for the last expression. Functional and ergonomic.

⚡

LLVM Native Speed

Compiles to optimized native code via LLVM. Get C-level performance with high-level ergonomics. Supports LTO and PGO.

Type Inference

Bidirectional type checking infers types automatically. Write x := 42 instead of explicit type annotations everywhere.

🔧

Full Toolchain

LSP server, formatter, debugger, REPL, package manager, and IDE plugins for VSCode and IntelliJ. Production-ready tooling.

Get Started in Seconds

macOS / Linux

brew tap vaislang/tap && brew install vais

Cargo

cargo install vaisc

Docker

docker run -it vaislang/vais:latest

Write fewer tokens, get native performance