v1.6.0 Beta

VibeLang

Code with Intent. Ship with Confidence!

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.6.0 Read the Book

1.1x

Faster than C, Rust

~20x

Faster than Python

1.7ms

Cold start

Runtime deps

Agentic Guardrails

agent.yb

pub run_agent(
  action: Str,
  risk: Int,
  budget: Int
) -> Result<Str, Error> {
  // Declare intent: used for drift checks + reviews.
  @intent "execute an AI agent action
    only when risk is within budget"
  @examples {
    // Examples compile into tests.
    run_agent("summarize", 2, 5) => ok
    run_agent("deploy", 9, 3)    => err
  }
  // Preconditions: enforced in dev/test (and optionally release).
  @require budget > 0
  @require risk >= 0
  // Explicit effects: makes I/O + concurrency visible to the compiler.
  @effect io
  @effect concurrency
  // Guardrail: block high-risk actions before doing any work.
  if risk > budget {
    return err("risk exceeds budget")
  }
  // Spawn the action and receive a typed result through a channel.
  result := chan(1)
  go execute(action, result)
  ok(result.recv())
}

1/4

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.

AI sidecar (BYOK)

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

C-Level Speed. Modern Syntax.

Competes with C, C++, and Rust on real-world workloads.

VibeLang compiles directly to native machine code — no virtual machine, no interpreter, no garbage collector pauses. We benchmark against the fastest compiled and interpreted languages to keep ourselves honest.

Against the Fastest Compiled Languages

Average performance ratio — below 1.0 means VibeLang is faster

vs C

0.89x

VibeLang is faster

Across 3 shared benchmark programs

vs Rust

0.93x

VibeLang is faster

Across 16 shared programs — wins 9 of 16

vs Zig

0.82x

VibeLang is faster

Across 12 shared programs

vs C++

1.74x

C++ is faster

Across 4 shared programs

Where VibeLang Outperforms C and Rust

Real programs where VibeLang beats established systems languages

binarytrees

VibeLang13.9ms

Rust86.1ms

6.2x faster

json-serde

VibeLang3.3ms

Rust56.2ms

17x faster

http-server

VibeLang36.5ms

Rust192.5ms

5.3x faster

merkletrees

VibeLang14.5ms

Rust107.4ms

7.4x faster

nsieve

VibeLang1.7ms

C55.0ms

32x faster

lru

VibeLang3.8ms

Rust20.0ms

5.3x faster

Against Interpreted Languages

The speed gap you get by switching from a scripting language to VibeLang

vs Python~20x faster

VibeLangPython

vs TypeScript~8.6x faster

VibeLangTypeScript

vs PHP~25x faster

VibeLangPHP

Compiles1.5x fasterthan Rust

Binary size328 KBno runtime needed

View Full Benchmark Results

All benchmarks run inside Docker on identical hardware. Every program's output is verified for correctness before timing. Full methodology and raw data available on the benchmarks page.

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 (Claude) 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 (Claude)

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

Want to contribute? Check out our contributing guide.