V1.0 Released

VibeLang

Code with Intent.

VibeLang compiles intent, contracts, and effects into deterministic native binaries. Ship agentic services that stay correct — whether code is written by humans or AI.

Download v1.0 Read the Book

27x

Faster than Go

100x

Faster than Python

4.3MB

Avg memory

Runtime deps

agent.yb

pub run_agent(
  action: Str,
  risk: Int,
  budget: Int
) -> Result<Str, Error> {
  @intent "execute an AI agent action
    only when risk is within budget"
  @examples {
    run_agent("summarize", 2, 5) => ok
    run_agent("deploy", 9, 3)    => err
  }
  @require budget > 0
  @require risk >= 0
  @ensure . != "blocked" || risk > budget
  @effect io
  @effect concurrency
  if risk > budget {
    return err("risk exceeds budget")
  }
  result := chan(1)
  go execute(action, result)
  ok(result.recv())
}

Why VibeLang

Built for creative velocity.

Engineered for controlled execution.

5 contract annotations

Intent-Driven by Default

@intent, @require, @ensure, @examples, and @effect — all first-class language primitives that compile into real checks.

Zero-overhead runtime

Native AOT Performance

Cranelift-powered compilation to native binaries. No VM, no JIT, no garbage collection pauses in the hot path.

100% reproducible

Deterministic Builds

Same source, same flags, same binary. Deterministic diagnostics and release evidence eliminate CI surprises.

go / chan / select

Structured Concurrency

Compile-time sendability checks and transitive effect tracking catch data races before they reach production.

Optional AI sidecar

AI-Native Guardrails

Move fast with LLM copilots. Intent annotations survive refactoring and drift detection catches regressions early.

9 commands, 1 binary

Complete Toolchain

Compiler, test runner, formatter, linter, doc generator, package manager, and LSP — all in the vibe CLI.

Intent-Driven Development

Declare. Verify. Execute. Observe.

State behavior with concise syntax, verify with compiler gates, execute with runtime enforcement, observe with deterministic diagnostics.

Declare

Verify

Execute

Observe

1. Declare Intent

State What, Not Just How

@intent annotations describe purpose in natural language. They survive refactoring and guide AI-assisted code reviews.

service.yb

pub greet(name: Str) -> Int {
  @intent "print a greeting for the given name"
  @effect io
  println(name)
  0
}

2. Verify Contracts

Compiler and CI Validate Everything

@require and @ensure become executable checks. @examples generate real test cases.

math.yb

pub divide(a: Int, b: Int) -> Int {
  @require b != 0
  @ensure . * b <= a
  @examples {
    divide(10, 3) => 3
    divide(9, 3) => 3
  }
  a / b
}

3. Execute Natively

Deterministic Artifacts, Every Time

Build and run native binaries with the same semantics verified in CI. No runtime surprises.

terminal

$ vibe build main.yb --profile release 
$ vibe run main.yb

4. Observe & Improve

Close the Feedback Loop

Logs, metrics, and crash repro formats close the loop. Intent drift becomes a fixable signal, not a silent regression.

AI assists. Determinism decides. Compilation never depends on AI services — always deterministic, always offline-capable.

Transitive effect tracking. The compiler knows every function that touches IO, allocation, or shared state.

Code Snippets

Show, Don't Tell

Expressive syntax, explicit constraints, visible intent. Contracts, effects, and examples are first-class language features — they compile into real checks.

AI agents gated by compile-time contracts. Risk exceeds budget? Blocked before it runs.

guardrails.yb

1pub gate_action(
2  risk: Int, budget: Int
3) -> Int {
4  @intent "allow agent action only when
5    risk stays within budget"
6  @examples {
7    gate_action(2, 5) => 1
8    gate_action(9, 3) => 0
9  }
10  @require budget > 0
11  @require risk >= 0
12  @ensure . >= 0
13  @ensure . <= 1
14  @effect io
15
16  if risk > budget { return 0 }
17  1
18}

@intentDeclare Intent

Describe what this function should do in plain language. The AI sidecar uses this for drift detection across refactors.

@examplesExecutable Examples

Input/output pairs that the compiler turns into real test cases. Run them with vibe test — they're not just documentation.

@requirePreconditions

Checked at function entry in dev/test builds. Catch bad inputs before they propagate through your system.

@ensurePostconditions

Checked before return. The dot (.) refers to the return value. Use old(expr) to snapshot entry-time state.

@effectEffect Declarations

Declare side effects explicitly. The compiler tracks them transitively through your entire call graph.

Performance

Faster Than C. Lighter Than Go.

Benchmarked, Not Claimed.

18 benchmark programs from the PLB-CI suite, measured with Hyperfine on AMD Ryzen 9 5900X. Every number is reproducible.

0.82ms

Hello world

cold start

4.3MB

Avg memory

footprint

Benchmark

programs

AOT

Native

compilation

Runtime Performance

Geometric mean speedup across shared benchmarks

vs Python100x faster

Geomean across 16 shared benchmarks

vs TypeScript71x faster

Geomean across 12 shared benchmarks

vs Go27x faster

Geomean across 18 shared benchmarks

vs Elixir333x faster

Geomean across 3 shared benchmarks

vs C10.7x faster

Geomean across 5 shared benchmarks

vs C++10.5x faster

Geomean across 5 shared benchmarks

Memory Footprint

Average memory usage across all benchmarks

VibeLang4.3 MB

C3.5 MB

C++2.0 MB

Go9.5 MB

Python27.0 MB

TypeScript74.5 MB

Elixir79.6 MB

17x lighter than TypeScript. 6x lighter than Python. Native AOT compilation means no VM overhead, no JIT warmup, no garbage collection pauses in the hot path.

Benchmark Spotlights

binarytrees

Tree construction & GC pressure

VibeLang1.53ms

Go199ms

Python372ms

spectral-norm

Dense matrix operations

VibeLang1.40ms

C43ms

C++76ms

http-server

HTTP request handling

VibeLang2.29ms

Go89ms

Python1700ms

coro-prime-sieve

Concurrency & coroutine perf

VibeLang1.64ms

Go12.3ms

TypeScript156ms

Benchmarks run on Linux WSL2, AMD Ryzen 9 5900X, 24 cores, 32GB RAM. PLB-CI suite with Hyperfine. Full results at reports/benchmarks/. Some language lanes (Rust, Zig, Swift) not yet available for comparison.

The AI Era

Where AI Writes Code,

VibeLang Keeps It Honest.

As AI agents generate more production code, the gap between “compiles” and “correct” widens. VibeLang closes it with language-level guardrails.

The Problem

LLMs generate code that compiles but silently drifts from product intent. The more agents contribute, the faster correctness degrades. Traditional testing catches bugs — not intent violations.

VibeLang's Answer

Embed control into the language itself. Contracts, effects, and deterministic builds create guardrails that scale — whether code is written by humans, copilots, or autonomous agents.

Autonomous Agent Pipelines

Multi-agent systems where each step has explicit contracts. Guardrail functions score risk, block unsafe actions, and enforce budgets — all verified at compile time.

LLM-Generated Codebases

AI writes the code, VibeLang verifies the intent. @intent annotations survive refactoring, @examples become executable tests, and drift detection flags regressions before they ship.

Regulated & Auditable Systems

Reproducible builds, deterministic diagnostics, and release evidence make every deployment verifiable. Compliance becomes a build artifact, not a manual process.

The Road Ahead

Today

Intent annotations catch AI-generated drift
Contracts enforce correctness at function boundaries
Effect system tracks side effects across call graphs

Near Future

Multi-agent orchestration with typed channels
Self-healing pipelines with contract-driven retry
AI sidecar suggests missing contracts from code patterns

Vision

Autonomous code generation with provable intent alignment
Cross-service contract verification at deploy time
Self-hosting compiler written entirely in VibeLang

Concurrency

Structured Concurrency,

Verified at Compile Time.

Go-inspired primitives with compile-time safety guarantees. Every concurrent operation is effect-tracked and sendability-checked.

Worker Pool with Channels

workers.yb

1worker(id: Int, done: Chan) -> Int {
2  @effect concurrency
3  done.send(id * id)
4  0
5}
6
7pub main() -> Int {
8  @effect concurrency
9  @effect io
10  @effect alloc
11  done := chan(4)
12
13  go worker(3, done)
14  go worker(7, done)
15
16  first := done.recv()
17  second := done.recv()
18
19  println(first + second)
20  0
21}

Select with Timeout

select.yb

select {
  case msg := inbox.recv() =>
    println(msg)
  case after 5s =>
    println("timeout")
  case closed shutdown =>
    println("shutting down")
}

Fan-Out / Fan-In

main

worker(3)

worker(7)

chan

go

Lightweight Tasks

M:N work-stealing scheduler. Thousands of concurrent tasks without OS thread overhead.

chan

Typed Channels

Bounded channels with compile-time sendability checks. No data races in safe code.

select

Multiplexed I/O

Multiplex channels with built-in timeout and graceful shutdown detection.

@effect

Effect Tracking

Concurrency effects tracked transitively. The compiler knows every function that touches shared state.

Toolchain

One Binary. Everything You Need.

Nine commands. One CLI. Zero external dependencies.

Build

vibe check

Type-check + validate contracts

vibe build

Compile to native binary

vibe run

Build and execute

Quality

vibe test

Run tests + @examples

vibe fmt

Format source code

vibe doc

Generate API docs

Intelligence

vibe lint --intent

AI-powered drift detection

vibe pkg resolve

Manage dependencies

vibe lsp

Language server for editors

Get Started

From Source to Native in 60 Seconds

Clone, build, run. For packaged binaries, see the platform install guides.

.yb source

Lexer

Parser

Type Check

HIR

MIR

Cranelift

Native

1. Install from source

terminal

$ git clone https://github.com/skhan75/VibeLang.git 
$ cd VibeLang 
$ cargo build --release -p vibe_cli 
$ export PATH="$PWD/target/release:$PATH"

2. Create, run, test, format

terminal

$ vibe new hello && cd hello 
$ vibe run main.yb 
$ vibe test main.yb 
$ vibe fmt . --check

Your first program

main.yb

1pub main() -> Int {
2  @effect io
3  println("hello from vibelang")
4  0
5}

Expected output:

hello from vibelang

Star on GitHub Download Binaries