VIBE 0.4.0

VIBE 0.4.0 — SIMD

Vector types f32x4, f64x2, s32x4 compile natively to SSE; f32x8, f64x4, s32x8 (AVX2) build through the C backend automatically. Lane-wise + - * / (floats) and + - * & | ^ (s32), scalar broadcast (f32x4(x), or a literal next to a vector), unaligned loads and stores through vector pointers (*f32x4(p)'), and \vsum \vget \vsqrt \vmin \vmax. Vectors are ordinary values: locals, parameters, results, struct fields, array elements.

A hand-vectorised saxpy runs 1.6x faster than the scalar loop on the native backend, within 1.16x of gcc -O2's auto-vectorised code. All three build paths produce identical results (\vsum adds lanes in a fixed pairwise order so float results match bit for bit). 62 tests, 600 fresh fuzz seeds.

VIBE 0.3.1

VIBE 0.3.1 — native optimiser

The dependency-free native backend closes much of the gap to gcc -O2: dominator-based common-subexpression elimination, strength reduction of loop-counter multiplies, rotated loops (one branch per iteration) with aligned heads, fused float compare-and-branch, rcx/rdx allocation with per-instruction clobber sets, loop-weighted spill choice for integer and float registers, coalesced loop-counter updates, three-operand adds via lea, hoisted float constants, and no redundant zero-extension on narrow-integer chains.

Measured against the previous release on the same programs: fib +15%, sieve +23%, matmul +26%, mandelbrot +24%, saxpy +66%, nbody +23%, byte scan +11%, inlining-heavy loop +39%. Versus gcc -O2: sieve and byte-scan loops at parity; matmul 1.6x, mandelbrot 1.2x, nbody 1.4x, recursion 1.7x, vectorisable float loops 1.9x. --backend=c remains the release path when the last factor matters.

One allocator bug found by the fuzzers during this work (a shift count loaded over its own left operand) was fixed before release; 58 tests on three build paths, 2,400 fresh fuzz seeds.

VIBE 0.3.0

VIBE 0.3.0

Language. Method syntax (v.push(3) calls push(&v, 3)); %Res<T,E> / %Opt<T> in std with postfix ! propagation; formatting \print("x={} y={.2}\n", x, y), \fmt, \eprint; untyped literal globals ($~ total = 0); $$ float constants and float arithmetic/casts in initialisers; extern aliasing (@< "c" cabs = abs (s32) s32); a program's declarations replace same-named library ones without touching the library's own callers.

Library. Generic %Vec<T>, %Map<V> (string keys), %IMap<V> (integer keys); string helpers (ssub sidx sfind sstarts sends strim stok sint sfloat uchars); Buf appenders for unsigned, float and hex; a futex-backed %Lock; guard pages under thread stacks.

Compiler. Exact u64 ↔ float conversions above 2^63; native ELF binaries carry a symbol table (gdb/perf/objdump name VIBE functions; -s strips) and a bss segment; a stripped hello world is about 300 bytes; 64-bit literal range checks; robust float printing (exponent form, inf, nan).

Tooling. tools/restyle.py rewrites source in the economical style (stdlib, examples and benchmarks now use it: idiomatic VIBE costs 0.99x the tokens of the same C); tools/tokens.py measures it; tools/disasm.py.

Fixes. Third independent audit: C-backend u64 -> f32 miscompile, double evaluation of a method receiver, float formatting overflow, x! - 1, and more. 57 tests on three build paths, two differential fuzzers.

VIBE 0.2.0

VIBE 0.2.0

Speed. vibec --backend=c builds the same program through gcc or clang at -O3 — level with C on every benchmark, still a static binary with no libc. The native backend gained inlining, precise clobber sets and inline aggregate copies.

Language. Generics (%Vec<T>, @ push<T>, inferred type arguments), counted loops (* i 0 n { }), compound assignment, ~ defer, namespaced includes (<<"file" ns), intrinsics (\sqrt \popcnt \cas \xadd ...), C interop (@< "lib" name (T, ...) R), constant tables of values, strings and function pointers, unlimited parameters, else on a new line.

Library. heap.vibe (allocator with free, %Buf, %Vec, %Map), thread.vibe (kernel threads, spawn/join), spin locks, long names for the std functions.

Correctness. Three optimiser miscompiles and over twenty front-end and backend bugs fixed, found by two independent audits. String == compares bytes; float compares are IEEE; literals are range-checked; a missing return is a compile error; all errors are reported in one run (--json available); --check traps bad indexes and division by zero with file:line. Two differential fuzzers ship in tests/.

See SPEC.md for the whole language.

VIBE 0.1.0

First release.

A systems language with no natural-language keywords, compiled straight to x86-64 machine code. The compiler writes the ELF bytes itself: no assembler, no linker, no C library, and no runtime in the produced binary.

Install

Linux / macOS:

curl -fsSL https://raw.githubusercontent.com/hanos1987/vibe/master/install.sh | sh

Debian / Ubuntu:

sudo apt install ./vibe_0.1.0_all.deb

Windows (PowerShell):

irm https://raw.githubusercontent.com/hanos1987/vibe/master/install.ps1 | iex

The compiler needs only python3. Executables it emits are static Linux x86-64 and depend on nothing.

What is in it

Sized integers, floats, booleans, pointers, arrays, structs, tagged unions with exhaustive pattern matching, function pointers, compile-time constants, direct syscalls and inline machine code. A standard library written in VIBE itself. Worked examples: a playable terminal Snake, a wc clone byte-identical to GNU wc, an HTTP server, and parallel prime counting across forked processes.

Measured

Against gcc on identical programs, outputs verified equal: about 2x faster than gcc -O0 and within roughly 1.5x of gcc -O2. A static binary is 2 KB where the equivalent static C binary is 785 KB.

26 tests pass with and without optimisation.

Read SPEC.md — it is the complete language.