Code with Intent. Ship with Confidence!

Native AOT compilation · First-class contracts · Structured concurrency · AI-era guardrails

Website · Documentation · Quickstart · Performance · Benchmarks · Contributing

---

VibeLang is a statically typed, natively compiled language where intent is a first-class citizen. You declare what a function should do, what it promises, how to test it, and what side effects it has — the compiler turns all of that into executable checks and native code.

As AI agents generate more production code, the gap between "compiles" and "correct" widens. VibeLang closes it with language-level guardrails that work whether code is written by humans, copilots, or autonomous agents.

Beta — VibeLang is in active beta. The compiler, type system, contract enforcement, and AI sidecar are functional and benchmarked. The language is evolving — syntax, stdlib, and toolchain APIs may change between releases. Recommended for experimentation, side projects, and early adoption. Feedback and contributions from experienced engineers are welcome and actively shape the language.

pub transfer(mut from: Account, mut to: Account, amount: Int) -> Result<Receipt, BankError> {
  @intent "move funds between accounts preserving total balance"
  @require amount > 0
  @require from.balance >= amount
  @ensure to.balance == old(to.balance) + amount
  @ensure from.balance == old(from.balance) - amount
  @effect io

  from.balance = from.balance - amount
  to.balance   = to.balance + amount
  ok(Receipt { from: from.id, to: to.id, amount })
}

Quickstart

Build from source (requires Rust stable + a C linker):

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

Or download a binary. This release attaches signed archives and checksums for macOS on Apple Silicon and Intel, Linux x86_64, and Windows x86_64. Every release for the past year shipped with no assets at all, because the packaging job could not build on Windows. That is fixed, and this is the first release in that time with binaries you can actually install.

Note for Windows users: std.net does not work on this platform. Its functions are stubs that return empty values without attempting a connection. Everything else, including the compiler, the filesystem and JSON APIs, works normally.

For a minimal binary without AI sidecar dependencies:

cargo build --release -p vibe_cli --no-default-features

Create and run a project:

vibe new myproject && cd myproject
vibe run main.yb          # compile + execute
vibe test main.yb         # run tests including @examples
vibe fmt . --check        # check formatting
vibe lint . --intent      # AI-powered drift detection (optional)

Enable AI-powered intent analysis (optional — local heuristic checks work without a key):

export ANTHROPIC_API_KEY="sk-ant-..."   # your own Anthropic key (BYOK)
vibe lint . --intent --mode hybrid      # local checks + AI drift detection

Platform guides: Linux · macOS · Windows

Supported Platforms

Platform	Architecture	Tier
Linux	x86_64	1 (CI-tested, prebuilt binaries)
macOS	ARM64 (Apple Silicon)	1
macOS	x86_64	2 (builds, not all CI lanes)
Windows	x86_64	2 (std.net is stubbed and does not connect)

Tier 1: full CI coverage, prebuilt release binaries, actively tested. Tier 2: builds from source, community-tested, best-effort support.

Performance

VibeLang compiles to native AOT binaries with zero runtime dependencies. We benchmark against 8 languages using the PLB-CI suite in Docker.

Geomean ratios (Docker-verified, March 2026):

vs Language	Geomean	Shared Benchmarks	Result
C	0.89x	3	VibeLang 1.1x faster
Rust	0.93x	16	VibeLang 1.1x faster (wins 9 of 16)
Zig	0.82x	12	VibeLang 1.2x faster
C++	1.74x	4	VibeLang 1.7x slower
Python	0.05x	3	VibeLang ~20x faster
TypeScript	0.12x	12	VibeLang ~8.6x faster
PHP	0.04x	3	VibeLang ~25x faster

VibeLang compiles 1.5x faster than Rust and produces a 328 KB binary for hello-world.

• Full results: benchmarks/third_party/local_full_run_report.md
• Interactive dashboard: thevibelang.org/benchmarks
• Publication policy: benchmarks/third_party/APPLE_TO_APPLE_BENCHMARK_POLICY.md
• CI runner: the release_benchmark_publication_gate job in .github/workflows/v1-release-gates.yml

Contracts & Intent

Annotation	Purpose
@intent "..."	Natural-language purpose; checked by AI sidecar for drift
@require expr	Precondition — verified at function entry
@ensure expr	Postcondition — . is the return value, old() snapshots pre-state
@examples { f(x) => y }	Executable test cases via vibe test
@effect tag	Side effects (io, alloc, mut_state, concurrency, nondet) — tracked transitively

AI Sidecar (BYOK)

VibeLang ships with an AI-powered intent drift detector backed by Anthropic Claude. It uses a Bring Your Own Key model — there is no centralized proxy. All LLM traffic goes directly from your machine to the Anthropic API.

$ vibe lint . --intent --mode hybrid

W0801: warning: possible intent drift in `sort_ascending` (confidence=0.95)
  Function sorts in descending order instead of ascending order
  due to the unnecessary reverse() call after sort()

Mode	Behavior
local	Heuristic checks only (I5001–I5004). No network calls. Default.
hybrid	Local checks first, then AI drift detection if API key is available.
cloud	AI analysis for all functions with @intent. Requires API key.

Setup — choose one:

# Option 1: Environment variable (recommended)
export ANTHROPIC_API_KEY="sk-ant-..."

# Option 2: Global config (~/.config/vibe/sidecar.toml)
echo 'api_key = "sk-ant-..."' > ~/.config/vibe/sidecar.toml

Without a key, all local checks still run — no error, no degraded exit code. See the Toolchain docs for full configuration.

Concurrency

results := chan(4)
go worker(3, results)
go worker(7, results)
first := results.recv()

select {
  case msg := inbox.recv() => handle(msg)
  case after 5 => timeout()
}

go spawns tasks, chan creates typed channels, select multiplexes with timeouts. The compiler tracks @effect concurrency transitively and checks sendability at compile time.

Toolchain

One binary, nine commands:

Command	What it does
vibe check	Type-check and validate contracts
vibe build	Compile to native binary
vibe run	Build and execute
vibe test	Run tests including @examples
vibe fmt	Format source code
vibe doc	Generate API documentation
vibe lint	Intent drift detection (local heuristics + optional AI via Claude)
vibe pkg	Dependency management
vibe lsp	Language server for editors

VS Code extension: editor-support/vscode/

Documentation

Resource	Description
The Book	Learning path from basics to production patterns
Language Spec	Grammar, type system, semantics, memory model
CLI Manual	Commands, flags, and exit codes
Stdlib Reference	Module index with stability tiers
Examples	87 programs across 11 categories
Release Process	How a version is chosen, cut, verified, and rolled back

Roadmap

Development is tracked in the development checklist and the features and optimizations backlog.

Contributing

See CONTRIBUTING.md for the full guide.

git clone https://github.com/<you>/VibeLang.git && cd VibeLang
cargo build --release -p vibe_cli
cargo fmt --all && cargo clippy --workspace --all-targets -- -D warnings
cargo test -p vibe_cli

Where to start: issues labeled good first issue · feature gaps · development checklist

License

Apache License 2.0 — Copyright 2025–2026 VibeLang Contributors