Violet Programming Language

Quickstart

Wed, 03 May 2023 22:37:22 +0100

Violet is a systems programming language that combines:

Zig’s manual allocation philosophy, comptime metaprogramming, fast compile times, and simplicity
Rust’s interfaces (traits), generics, affine type system, and operator overloading
Pascal’s readability, keyword conventions, and syntactic clarity

Violet targets embedded systems, operating systems, games, servers, and any domain where control over memory and performance is essential. It provides memory safety without a borrow checker through a combination of linear types, scope-tagged pointers, and explicit allocator discipline.

Full Language Specification

Wed, 03 May 2023 22:37:22 +0100

Status: Design phase. Bootstrap compiler in progress (Zig). Items marked [TBD] are accepted in principle but not yet formally specified or implemented.

Introduction

Violet is a systems programming language that combines:

Zig’s manual allocation philosophy, comptime metaprogramming, fast compile times, and simplicity
Rust’s interfaces (traits), generics, affine type system, and operator overloading
Pascal’s readability, keyword conventions, and syntactic clarity

Chapter 1: Hello Violet

Tue, 14 Jul 2026 14:30:13 +0200

Every Violet program starts with a main function. The simplest possible program:

 fn main(): void {
 debug.print("Hello, Violet!\n");
}

With access to process context — arguments, environment, allocator, scheduler:

 const process = import("std/process");
const debug = import("std/debug");

fn main(ctx: process.Context): !void {
 debug.print("Hello, {}!\n", .{ctx.args[0]});
}

!void means this function can fail. The ! prefix is Violet’s error union syntax — more on this in Chapter 7.

Chapter 2: Variables and Bindings

Tue, 14 Jul 2026 14:30:13 +0200

Mutable and Immutable

 const pi: f64 = 3.14159; -- immutable, must be initialized
var count: i32 = 0; -- mutable

count := count + 1; -- reassignment uses :=
count += 1; -- compound assignment

:= for reassignment, = for initialization and equality comparison. This comes from Pascal. = in expression position is always equality — there is no == in Violet.

 if count = 5 { -- = means equality here
 debug.print("five!\n");
}

Type Inference

 var x = 42; -- inferred as i32
var s = "hello"; -- inferred as []const u8
var f = 3.14; -- inferred as f64

Constants

Constants are compile-time values. They can be used anywhere a comptime value is expected:

Chapter 3: Primitive Types

Tue, 14 Jul 2026 14:30:13 +0200

Integers

 var a: i8 = -128;
var b: u8 = 255;
var c: i32 = -2_147_483_648; -- underscores for readability
var d: u64 = 18_446_744_073_709_551_615;
var e: isize = -1; -- pointer-sized signed
var f: usize = 0; -- pointer-sized unsigned

Integer overflow always panics with plain arithmetic. Use explicit operators for other behavior:

 var x: u8 = 255;
var wrapped = x +% 1; -- wrapping: 0
var saturated = x +| 1; -- saturating: 255
-- x + 1 would panic

Floats

 var a: f32 = 3.14;
var b: f64 = 2.718281828;

Booleans

 var t: bool = true;
var f: bool = false;

if t and not f {
 debug.print("yes\n");
}

Logical operators are words: and, or, not, xor. Bitwise operators are symbols: &, |, ~, ^.

Chapter 4: Functions

Tue, 14 Jul 2026 14:30:13 +0200

Basic Functions

 fn add(a: i32, b: i32): i32 {
 return a + b;
}

fn greet(name: []const u8) { -- no return type = void
 debug.print("hello, {}\n", .{name});
}

Multiple Return Values

Violet uses anonymous structs for multiple returns:

 fn minMax(items: []const i32): struct { min: i32, max: i32 } {
 var min = items[0];
 var max = items[0];
 for item in items[1..] {
 if item.* < min { min := item.*; }
 if item.* > max { max := item.*; }
 }
 return .{ .min = min, .max = max };
}

var result = minMax(&.{3, 1, 4, 1, 5, 9});
debug.print("min={} max={}\n", .{result.min, result.max});

Destructure at the call site:

Chapter 5: Control Flow

Tue, 14 Jul 2026 14:30:13 +0200

Loops

 -- for: iterate a collection
for item in items {
 process(item);
}

-- for with index
for item, i in items {
 debug.print("[{}] {}\n", .{i, item});
}

-- for over a range
for i in 0..10 { -- exclusive: 0, 1, ..., 9
 debug.print("{}\n", .{i});
}

for i in 0..=10 { -- inclusive: 0, 1, ..., 10
 debug.print("{}\n", .{i});
}

-- while: condition-based
var n: i32 = 1;
while n < 100 {
 n *= 2;
}

-- loop: infinite, exit with break
var count: i32 = 0;
loop {
 count += 1;
 if count = 10 { break; }
}

-- loop with a value
var found = loop {
 var candidate = try nextCandidate();
 if candidate.valid { break candidate; }
};

-- repeat...until: post-condition (runs at least once)
var input: []const u8 = "";
repeat {
 input = try readLine();
} until input != "";

Multi-sequence For

 for x, y in xs, ys {
 debug.print("{} {}\n", .{x, y});
}

-- with shared index
for x, y, i in xs, ys {
 debug.print("[{}] {} {}\n", .{i, x, y});
}

Break and Continue

 outer: for i in 0..10 {
 for j in 0..10 {
 if i + j = 15 { break outer; }
 }
}

for item in items {
 if item.* = 0 { continue; }
 process(item);
}

Chapter 6: Structs

Tue, 14 Jul 2026 14:30:13 +0200

Defining and Using Structs

 type Point = struct {
 x: f32,
 y: f32,
};

var p = Point { .x = 1.0, .y = 2.0 };
var p: Point = .{ .x = 1.0, .y = 2.0 }; -- type inferred from context

debug.print("({}, {})\n", .{p.x, p.y});

Field Defaults

 type Config = struct {
 host: []const u8 = "localhost",
 port: u16 = 8080,
 timeout: u32 = 30,
 debug: bool = false,
};

var cfg = Config { .host = "example.com" };
-- port, timeout, debug use their defaults

Methods

Methods go in impl blocks. Receivers use *self (mutable), *const self (immutable), or self (consuming):

Chapter 7: Enums and Unions

Tue, 14 Jul 2026 14:30:13 +0200

Enums — Fieldless Variants

 type Direction = enum {
 North,
 South,
 East,
 West,
};

var d = Direction.North;

-- enums are always Copy
case d {
 .North => debug.print("going north\n"),
 .South => debug.print("going south\n"),
 .East => debug.print("going east\n"),
 .West => debug.print("going west\n"),
}

Unions — Tagged Variants With Data

 type Shape = union {
 Circle { radius: f32 },
 Rectangle { width: f32, height: f32 },
 Triangle { base: f32, height: f32 },
 Point, -- unit variant, no data
};

fn area(shape: Shape): f32 {
 return case shape {
 .Circle { radius } => 3.14159 * radius * radius,
 .Rectangle { width, height } => width * height,
 .Triangle { base, height } => 0.5 * base * height,
 .Point => 0.0,
 };
}

var s = Shape.Circle { .radius = 5.0 };
debug.print("area: {}\n", .{area(s)});

Optionals — `?T`

An optional is either a value or nothing:

Chapter 8: Error Handling

Tue, 14 Jul 2026 14:30:13 +0200

Defining Error Types

 type ParseError = error {
 InvalidChar { ch: u8, pos: usize },
 UnexpectedEof,
 Overflow { value: i64 },
};

Returning Errors

 fn parseU8(s: []const u8): ParseError!u8 {
 if s.len = 0 {
 return error.UnexpectedEof;
 }

 var result: u8 = 0;
 for byte, i in s.bytes() {
 if byte < '0' or byte > '9' {
 return error.InvalidChar { .ch = byte, .pos = i };
 }
 result = result *% 10 +% (byte - '0');
 }
 return result;
}

Handling Errors

 -- try: propagate if same error type
var n = try parseU8(input);

-- catch: handle inline
var n = parseU8(input) catch |e| {
 case e {
 .InvalidChar { ch, pos } => {
 debug.print("bad char '{}' at {}\n", .{ch, pos});
 return error.InvalidChar { .ch = ch, .pos = pos };
 },
 .UnexpectedEof => return error.UnexpectedEof,
 .Overflow { value } => {
 debug.print("overflow: {}\n", .{value});
 return 255;
 },
 }
};

-- orelse: provide default on error
var n = parseU8(input) catch 0;

Wrapping Errors — `wrap`

When your function has a different error type:

Chapter 9: Memory and Ownership

Tue, 14 Jul 2026 14:30:13 +0200

Allocators

Every allocation in Violet is explicit. You choose the allocator:

 const alloc_mod = import("std/alloc");

fn main(ctx: process.Context): !void {
 -- general purpose allocator
 var gpa = alloc_mod.GPA::new();
 defer gpa.deinit();
 var alloc = gpa.allocator();

 -- allocate memory
 var buf = try alloc.alloc(u8, 1024);
 defer alloc.free(buf);

 -- allocate a single value
 var ptr = try alloc.create(i32);
 defer alloc.destroy(ptr);
 ptr.* := 42;
}

`using` — Implicit Allocator Threading

When a function uses the same allocator everywhere, using reduces noise:

Chapter 10: Interfaces

Tue, 14 Jul 2026 14:30:13 +0200

Defining an Interface

 interface Animal {
 fn name(*const self): []const u8;
 fn sound(*const self): []const u8;
 fn legs(*const self): u32;
}

Implementing an Interface

 type Dog = struct {
 name_: []const u8,
};

type Cat = struct {
 name_: []const u8,
};

provide Animal for Dog {
 fn name(*const self): []const u8 { return self.name_; }
 fn sound(*const self): []const u8 { return "woof"; }
 fn legs(*const self): u32 { return 4; }
}

provide Animal for Cat {
 fn name(*const self): []const u8 { return self.name_; }
 fn sound(*const self): []const u8 { return "meow"; }
 fn legs(*const self): u32 { return 4; }
}

Static Dispatch — Generics

 fn describe[A: Animal](animal: *const A) {
 debug.print("{} says {} and has {} legs\n",
 .{animal.name(), animal.sound(), animal.legs()});
}

var dog = Dog { .name_ = "Rex" };
var cat = Cat { .name_ = "Whiskers" };

describe(&dog); -- monomorphized for Dog
describe(&cat); -- monomorphized for Cat

Dynamic Dispatch — `dyn`

When you need a collection of different types:

Chapter 11: Generics and Comptime

Tue, 14 Jul 2026 14:30:13 +0200

Generic Functions

 fn largest[T: Eq](items: []const T): ?*const T {
 if items.len = 0 { return .None; }
 var best = &items[0];
 for item in items[1..] {
 if item.* > best.* { best := item; }
 }
 return best;
}

var numbers = [_]i32{ 3, 1, 4, 1, 5, 9, 2, 6 };
if largest(&numbers) |n| {
 debug.print("largest: {}\n", .{n.*});
}

Generic Types

 type Stack[T] = struct {
 items: List[T],
};

impl[T] Stack[T] {
 static fn new(): Self {
 return .{ .items = List[T]::new() };
 }

 fn push(*self, alloc: Allocator, val: T): !void {
 try self.items.push(alloc, val);
 }

 fn pop(*self): ?T {
 return self.items.pop();
 }

 fn peek(*const self): ?*const T {
 if self.items.len() = 0 { return .None; }
 return self.items.get(self.items.len() - 1);
 }

 fn isEmpty(*const self): bool {
 return self.items.isEmpty();
 }
}

provide Destroy for Stack[T] {
 type Args = Allocator;
 fn deinit(*self, alloc: Allocator) {
 self.items.deinit(alloc);
 }
}

var stack = Stack[i32]::new();
defer stack.deinit(alloc);

try stack.push(alloc, 1);
try stack.push(alloc, 2);
try stack.push(alloc, 3);

while stack.pop() -> val {
 debug.print("{}\n", .{val});
}
-- prints: 3, 2, 1

Comptime Functions

When you need to inspect type structure:

Chapter 12: Closures

Tue, 14 Jul 2026 14:30:13 +0200

Basic Closures

 -- [capture_list](params): ReturnType { body }
var add = [](x: i32, y: i32): i32 { return x + y; };
debug.print("{}\n", .{add(3, 4)}); -- 7

-- capturing from outer scope
var offset: i32 = 10;
var addOffset = [offset](x: i32): i32 { return x + offset; };
debug.print("{}\n", .{addOffset(5)}); -- 15

Moving Into Closures

Non-Copy values must be moved:

 var name = try String::from(alloc, "World");
var greet = [move name](): void {
 debug.print("Hello, {}!\n", .{name});
};
-- name is gone from this scope
greet();

Closures as Parameters

 fn applyTwice[T](f: fn(*mut T): void, val: *mut T) {
 f(val);
 f(val);
}

var x: i32 = 0;
applyTwice([&x](_: *mut i32) { x += 1; }, &x);
debug.print("{}\n", .{x}); -- 2

Closures With Collections

 fn filter[T](items: []T, pred: fn(*const T): bool, alloc: Allocator): ![]T {
 var result = List[T]::new();
 errdefer result.deinit(alloc);

 for item in items {
 if pred(item) {
 try result.push(alloc, item.*);
 }
 }
 return result.intoSlice();
}

var numbers = [_]i32{ 1, 2, 3, 4, 5, 6, 7, 8 };
var evens = try filter(&numbers, [](n: *const i32): bool {
 return n.* % 2 = 0;
}, alloc);
defer alloc.free(evens);
-- evens: { 2, 4, 6, 8 }

Chapter 13: Concurrency

Tue, 14 Jul 2026 14:30:13 +0200

The `Io` Scheduler

Functions that may suspend take an explicit *Io parameter. This makes suspension visible at every call site — critical for lock safety:

 const io_mod = import("std/async");
const net = import("std/net");

-- provably synchronous: no *Io parameter
fn computeHash(data: []const u8): u64 {
 return fnv1a(data);
}

-- may suspend: takes *Io
fn fetchData(io: *Io, url: []const u8, alloc: Allocator): ![]u8 {
 var conn = try net.TcpStream::connect(io, url);
 defer conn.deinit();
 return try conn.readAll(io, alloc);
}

Structured Concurrency

The safest way to run concurrent tasks — all tasks are joined when the scope exits:

Chapter 14: C FFI (Foreign Function Interface)

Tue, 14 Jul 2026 14:30:13 +0200

Calling C Functions

 const c = #cImport({
 #cInclude("stdio.h");
 #cInclude("string.h");
});

fn countOccurrences(haystack: []const u8, needle: u8): usize {
 var count: usize = 0;
 for b in haystack {
 if b.* = needle { count += 1; }
 }
 return count;
}

fn main(): void {
 -- calling C functions requires unsafe
 unsafe {
 _ = c.printf("Hello from C!\n");
 }
}

Exporting Violet Functions to C

 -- Violet function callable from C
export fn violetAdd(a: i32, b: i32): i32 {
 return a + b;
}

-- with custom C name
export("violet_compute") fn compute(data: [*c]const u8, len: usize): u64 {
 unsafe {
 return hashBytes(data[0..len]);
 }
}

Generate a C header: violet build --emit-header mylib.h

Chapter 15: Complete Example Program

Tue, 14 Jul 2026 14:30:13 +0200

Putting it all together: a simple in-memory key-value store with a TCP interface.

 const process = import("std/process");
const io_mod = import("std/async");
const net = import("std/net");
const sync = import("std/sync");
const collections = import("std/collections");
const fmt = import("std/fmt");

-- the store: a thread-safe HashMap
type Store = struct {
 data: sync.Mutex[collections.HashMap[String, String]],
};

impl Store {
 static fn new(alloc: Allocator): !Self {
 return .{
 .data = sync.Mutex[collections.HashMap[String, String]]::new(
 collections.HashMap[String, String]::new()
 ),
 };
 }

 fn get(*const self, key: []const u8): ?String {
 var guard = self.data.lock();
 return case guard.*.get(key) {
 .Some { val } => .Some { .value = val.clone() },
 .None => .None,
 };
 }

 fn set(*self, alloc: Allocator, key: String, val: String): !void {
 var guard = self.data.lock();
 try guard.*.set(alloc, key, val);
 }

 fn delete(*self, key: []const u8): bool {
 var guard = self.data.lock();
 return guard.*.remove(key) != .None;
 }
}

-- parse and handle one command
fn handleCommand(
 io: *Io,
 store: *Store,
 alloc: Allocator,
 line: []const u8,
 conn: *net.TcpStream,
): !void {
 var parts = splitLine(line);

 case parts[0] {
 "GET" if parts.len = 2 => {
 if store.get(parts[1]) -> val {
 defer val.deinit(alloc);
 try conn.write(io, val.asSlice());
 try conn.write(io, "\n");
 } else {
 try conn.write(io, "NOT_FOUND\n");
 }
 },
 "SET" if parts.len = 3 => {
 var key = try String::from(alloc, parts[1]);
 errdefer key.deinit(alloc);
 var val = try String::from(alloc, parts[2]);
 errdefer val.deinit(alloc);

 try store.set(alloc, key, val);
 try conn.write(io, "OK\n");
 },
 "DEL" if parts.len = 2 => {
 if store.delete(parts[1]) {
 try conn.write(io, "DELETED\n");
 } else {
 try conn.write(io, "NOT_FOUND\n");
 }
 },
 _ => {
 try conn.write(io, "ERR unknown command\n");
 },
 }
}

-- handle one connection
fn handleConn(
 io: *Io,
 store: *Store,
 alloc: Allocator,
 conn: net.TcpStream,
): !void {
 defer conn.deinit();

 var buf: [4096]u8 = #undefined;

 loop {
 var n = try conn.read(io, &buf);
 if n = 0 { break; } -- connection closed

 var line = trim(buf[0..n]);
 handleCommand(io, store, alloc, line, &conn) catch |e| {
 var msg = try fmt.format(alloc, "ERR {}\n", .{e});
 defer alloc.free(msg);
 conn.write(io, msg) catch {};
 };
 }
}

fn main(ctx: process.Context): !void {
 using ctx.alloc;

 var io = try io_mod.IoUringScheduler::new(ctx.alloc, 1024);
 defer io.deinit(ctx.alloc);

 -- shared store, Arc for thread safety
 var store = Arc[Store]::new(ctx.alloc, try Store::new(ctx.alloc));
 defer store.deinit(ctx.alloc);

 var listener = try net.TcpListener::bind(&io, "0.0.0.0:6379");
 defer listener.deinit();

 debug.print("Listening on :6379\n");

 -- structured concurrency: all connections joined on exit
 try io.scope([](s: *IoScope) {
 while true {
 var conn = try listener.accept(&io);
 var s_clone = store.clone(ctx.alloc);

 try s.spawn([move conn, move s_clone](_: *IoScope) {
 handleConn(&io, s_clone.*, ctx.alloc, conn) catch |e| {
 debug.print("connection error: {}\n", .{e});
 };
 s_clone.deinit(ctx.alloc);
 });
 }
 });
}

Chapter 16: Quick Reference

Tue, 14 Jul 2026 14:30:13 +0200

Operators

 -- arithmetic
+ - * / % -- checked (panic on overflow)
+% -% *% -- wrapping
+| -| *| -- saturating

-- logical (word)
and or not xor

-- bitwise (symbol)
& | ~ ^ << >>

-- comparison
= != < > <= >= -- = is equality (not ==)

-- assignment
:= -- reassignment
+= -= *= /= etc. -- compound

-- type operators
is as as? -- type check, cast, safe cast

-- error/optional
try -- propagate error
? -- propagate None
orelse -- provide default
catch -- handle error

-- pointer
.* -- dereference
& -- address-of

Common Patterns

 -- defer cleanup
var x = try acquire();
defer x.release();

-- errdefer (error path only)
var buf = try alloc.alloc(u8, n);
errdefer alloc.free(buf);

-- optional unwrap
if maybe -> val { use(val); }
var n = maybe orelse 0;

-- error propagation
var n = try riskyOp();
var n = riskyOp() catch 0;
var n = riskyOp() catch wrap;

-- comptime type check
inline if #implements(T, Clone) { ... }
inline for field in #typeInfo(T).fields { ... }

Import Paths

 -- files are namespaces, . is field access
const std = import("std");
const List = std.collections.List;
const Io = import("std/io").Io;

-- re-export from your module
pub const HashMap = import("std/collections/hashmap").HashMap;

Packaging System

Tue, 14 Jul 2026 14:30:13 +0200

Terminology

“Palette” — Violet’s name for a package. A palette is a collection of colors; your dependencies are the colors in your project’s palette.

Manifest

Every package has a manifest file, called palette.kdl. This file declares the package information and dependencies.

For a full KDL reference, refer to https://kdl.dev/.

Allocator

Tue, 14 Jul 2026 14:30:13 +0200

Module: std/allocator

The allocator module provides the Allocator interface, which describes the functionality of allocators used in Violet.

Definition

This is the public allocator interface, which users derive an allocator from directly.

Allocators can implement this interface and be used for all forms of memory allocation.

 interface Allocator {
 -- Create a new pointer of type
 fn create[T](self: *Self): !*T;

 -- Create a new buffer of type with n elements
 fn alloc(self: *Self, n: usize): []T;

 -- Destroy an allocated type
 fn destroy[T](self: *Self, value: *T);

 -- Destroy an allocated buffer
 fn free[T](self: *Self, value: []T);

 -- Resize an existing allocation
 fn resize[T](self: *Self, value: T, new_size: usize): bool;
}

Build Script

Tue, 14 Jul 2026 14:30:13 +0200

Calling violet build starts the compilation process. The build.vi file is read, which provides build instructions.

 const build = import("std/build");

fn main(b: *build.Builder) {
 var opts = b.options();
 var mode = opts.enum("mode", build.BuildMode, .Debug);

 var exe = b.addExecutable(.{
 .name = "myapp",
 .root = "src/main.vi",
 .mode = mode,
 });

 exe.linkSystemLib("z");
 exe.libc(.musl);
 exe.addIncludePath("vendor/mylib/include");

 b.install(exe);
}

Async I/O

Tue, 14 Jul 2026 14:30:13 +0200

Module: core/io

Violet’s async model uses an explicit *Io parameter rather than async/await keywords. Functions that take *Io may suspend; functions without it are provably synchronous.

Definitions

 interface Io {
 fn waitFd(*self, fd: Fd, event: IoEvent): !void;
 fn sleep(*self, dur: Duration): !void;
 fn yield_(*self): void;
 fn spawnBlocking(*self, alloc: Allocator, work: BoxedBlockingTask): !void;
 fn scope(*self, alloc: Allocator, body: BoxedScopeTask): !void;
 fn spawn(*self, alloc: Allocator, task: BoxedTask): !TaskHandle;
 fn spawnDetached(*self, alloc: Allocator, task: BoxedTask): !void;
 fn waker(*self): Waker;
 fn handle(*self, alloc: Allocator): IoHandle;
 fn run(*self): !void;
 fn shutdown(*self): void;
}

interface IoScope: Io {
 fn spawn(*self, alloc: Allocator, task: BoxedTask): !void;
}

Usage

Structured Concurrency (Recommended)

 fn serveRequests(io: *Io, alloc: Allocator): !void {
 using alloc;

 try io.scope([](s: *IoScope) {
 while true {
 var conn = try acceptConnection(io);
 try s.spawn([move conn](_: *IoScope) {
 try handleConnection(io, conn);
 });
 }
 });
 -- all connection tasks joined before returning
}

Inside io.scope, use s for everything: IoScope extends Io, so s.waitFd, s.sleep, s.spawn all work through the scope.

Pascal

Tue, 14 Jul 2026 14:30:13 +0200

Word Operators: `and`, `or`, `not`, `xor`

Decision: Logical operators are English words. Bitwise operators are symbols.

Reason: The single most common C mistake is writing & when you meant &&, or | when you meant ||. They look nearly identical and silently produce wrong results. Word operators for logic, symbol operators for bitwise — makes the distinction impossible to miss.

 -- logical: words
if x > 0 and y > 0 {
 proceed();
}

if not valid or count = 0 {
 return error.Invalid;
}

if flagA xor flagB { -- exactly one is true
 handleExclusive();
}

-- bitwise: symbols (distinct, cannot be confused)
var flags = a & b; -- AND
var mask = a | b; -- OR
var inv = ~a; -- NOT
var mixed = a ^ b; -- XOR
var shifted = a << 3;

`:=` For Reassignment, `=` For Equality

Decision: := is the only reassignment operator. = in expression position is always equality comparison. = in declaration position is initialization.

Rust

Tue, 14 Jul 2026 14:30:13 +0200

Interfaces (Traits)

Decision: Interfaces are nominal — a type satisfies an interface only when explicitly stated, either through structural satisfaction (having the right methods) or an explicit provide block.

Reason: Structural typing (Go’s model) causes accidental interface satisfaction. If any type with a .close() method satisfies io.Closer, a DatabaseConnection might accidentally satisfy NetworkCloser. Nominal interfaces prevent this class of bug and make intent explicit.

 interface Serialize {
 fn serialize(*const self, writer: *Writer): !void;
}

interface Deserialize {
 static fn deserialize(reader: *Reader): !Self;
}

type Point = struct { x: f32, y: f32 };

provide Serialize for Point {
 fn serialize(*const self, writer: *Writer): !void {
 try writer.writeF32(self.x);
 try writer.writeF32(self.y);
 }
}

provide Deserialize for Point {
 static fn deserialize(reader: *Reader): !Self {
 return .{
 .x = try reader.readF32(),
 .y = try reader.readF32(),
 };
 }
}

-- generic over any serializable type
fn writeAll[T: Serialize](items: []const T, writer: *Writer): !void {
 for item in items {
 try item.serialize(writer);
 }
}

Generics With Bounds

Decision: Generic parameters use square brackets with explicit interface bounds: [T: Bound].

Zig

Tue, 14 Jul 2026 14:30:13 +0200

Explicit Allocators

Decision: Every allocation takes an explicit Allocator parameter. No hidden heap usage anywhere in the language or standard library.

Reason: Hidden allocation is one of the primary sources of unexpected latency, OOM errors in unexpected places, and difficulty reasoning about memory usage. When allocation is explicit, the programmer always knows where memory comes from, which allocator strategy is being used, and can substitute a different allocator (arena, pool, stack) for testing or performance.

Violet

Tue, 14 Jul 2026 14:30:13 +0200

Explicit `*Io` Parameter — No `async fn`

Decision: Functions that may suspend take an explicit *Io scheduler parameter. There is no async fn keyword. Suspension is visible at every call site.

Reason: Rust’s async fn colors the call graph — you cannot call an async function from a sync context without wrapping in an executor. Go’s goroutines hide suspension entirely. Both create versions of the “what color is your function” problem. Violet’s explicit *Io parameter makes suspension visible at the call site — critical for reasoning about lock safety and task scheduling.

Violet Programming Language

Quickstart

Full Language Specification

Introduction link

Chapter 1: Hello Violet

Chapter 2: Variables and Bindings

Mutable and Immutable link

Type Inference link

Constants link

Chapter 3: Primitive Types

Integers link

Floats link

Booleans link

Chapter 4: Functions

Basic Functions link

Multiple Return Values link

Chapter 5: Control Flow

Loops link

Multi-sequence For link

Break and Continue link

Chapter 6: Structs

Defining and Using Structs link

Field Defaults link

Methods link

Chapter 7: Enums and Unions

Enums — Fieldless Variants link

Unions — Tagged Variants With Data link

Optionals — ?T link

Chapter 8: Error Handling

Defining Error Types link

Returning Errors link

Handling Errors link

Wrapping Errors — wrap link

Chapter 9: Memory and Ownership

Allocators link

using — Implicit Allocator Threading link

Chapter 10: Interfaces

Defining an Interface link

Implementing an Interface link

Static Dispatch — Generics link

Dynamic Dispatch — dyn link

Chapter 11: Generics and Comptime

Generic Functions link

Generic Types link

Comptime Functions link

Chapter 12: Closures

Basic Closures link

Moving Into Closures link

Closures as Parameters link

Closures With Collections link

Chapter 13: Concurrency

The Io Scheduler link

Structured Concurrency link

Chapter 14: C FFI (Foreign Function Interface)

Calling C Functions link

Exporting Violet Functions to C link

Chapter 15: Complete Example Program

Chapter 16: Quick Reference

Operators link

Common Patterns link

Import Paths link

Packaging System

Terminology link

Manifest link

Allocator

Definition link

Build Script

Async I/O

Definitions link

Usage link

Structured Concurrency (Recommended) link

Pascal

Word Operators: and, or, not, xor link

:= For Reassignment, = For Equality link

Rust

Interfaces (Traits) link

Generics With Bounds link

Zig

Explicit Allocators link

Violet

Introduction

Mutable and Immutable

Type Inference

Constants

Integers

Floats

Booleans

Basic Functions

Multiple Return Values

Loops

Multi-sequence For

Break and Continue

Defining and Using Structs

Field Defaults

Methods

Enums — Fieldless Variants

Unions — Tagged Variants With Data

Optionals — `?T`

Defining Error Types

Returning Errors

Handling Errors

Wrapping Errors — `wrap`

Allocators

`using` — Implicit Allocator Threading

Defining an Interface

Implementing an Interface

Static Dispatch — Generics

Dynamic Dispatch — `dyn`

Generic Functions

Generic Types

Comptime Functions

Basic Closures

Moving Into Closures

Closures as Parameters

Closures With Collections

The `Io` Scheduler

Structured Concurrency

Calling C Functions

Exporting Violet Functions to C

Operators

Common Patterns

Import Paths

Terminology

Manifest

Definition

Definitions

Usage

Structured Concurrency (Recommended)

Word Operators: `and`, `or`, `not`, `xor`

`:=` For Reassignment, `=` For Equality

Interfaces (Traits)

Generics With Bounds

Explicit Allocators

Explicit `*Io` Parameter — No `async fn`