V (Vlang)

V is a simple, fast, and compiled language designed for building maintainable software with ultra-fast compilation speeds, memory safety, and minimal dependencies.

When to Use

• Lightweight, High-Speed Systems Programming: Compiling native executables with C-equivalent performance and zero dependencies.
• Rapid Cross-Platform Tooling & CLI Development: Building standalone command-line utilities with instant compile times (< 1 second).
• Clean Embedded & WebAssembly Applications: Low-memory footprint services and game engines without garbage collection spikes.
• Direct Seamless C Interop: Calling existing C libraries directly without header generation or binding wrappers.

Quick Start

struct User {
    id   int
    name string
}

fn main() {
    users := [User{id: 1, name: 'Alice'}, User{id: 2, name: 'Bob'}]
    for u in users {
        println('User $u.id: $u.name')
    }
}

Core Concepts

Memory Management & Immutability by Default

V uses compile-time autofree memory management without garbage collection pauses:

module main

import os

// Struct definition with explicit access controls
pub struct UserSession {
pub:
    username string
    user_id  int
pub mut:
    token    string
}

fn main() {
    // Variables are immutable by default
    user := UserSession{
        username: 'alice'
        user_id: 101
        token: 'tok-abc'
    }
    println('User: ${user.username}, ID: ${user.user_id}')
}

Result & Option Types for Error Propagation

Handling missing values and errors explicitly without exceptions:

module main

import os

struct Config {
    port int
    host string
}

fn parse_port(env_var string) !int {
    val := os.getenv(env_var)
    if val == '' {
        return error('Environment variable ${env_var} not found')
    }
    port := val.int()
    if port <= 0 || port > 65535 {
        return error('Port ${port} out of valid range (1-65535)')
    }
    return port
}

fn main() {
    port := parse_port('SERVER_PORT') or {
        eprintln('Failed to load port: ${err}')
        8080 // fallback default
    }
    println('Starting server on port ${port}')
}

Concurrency with Coroutines & Channels

Lightweight thread spawning with built-in CSP channels:

module main

import sync

fn worker(id int, ch chan int) {
    for i in 0 .. 3 {
        ch <- id * 10 + i
    }
}

fn main() {
    ch := chan int{cap: 10}

    // Spawn concurrent green threads with 'spawn' keyword
    spawn worker(1, ch)
    spawn worker(2, ch)

    for _ in 0 .. 6 {
        val := <-ch
        println('Received: ${val}')
    }
    ch.close()
}

Common Patterns

Result and Option Types for Robust Error Handling

Problem: Nil-pointer crashes and unhandled error states.

Solution: Use V's built-in ? Option and ! Result return types:

fn divide(a f64, b f64) !f64 {
    if b == 0.0 {
        return error('division by zero')
    }
    return a / b
}

fn main() {
    res := divide(10.0, 2.0) or {
        eprintln('Calculation failed: $err')
        return
    }
    println('Result: $res')
}

Best Practices

Do:

• Run v fmt -w . to enforce standard formatting across the entire codebase.
• Use v -prod when building release binaries to enable aggressive compiler optimizations and stripping.
• Handle all errors using or { ... } blocks rather than panicking on unhandled results.
• Write unit tests directly alongside code with fn test_*() functions and execute them with v test ..

Don't:

• Use global mutable variables; pass context structs and state objects explicitly.
• Disable autofree in production unless explicitly using an arena allocator for game loop allocations.
• Ignore compiler warnings; treat warnings as errors during CI builds.

Troubleshooting

Error	Cause	Solution
unhandled option / result	Function returning Option or Result called without or { ... }.	Handle error with or { ... } or propagate with ?.
variable '...' is immutable	Attempting to reassign an immutable variable.	Declare variable with mut: mut count := 0.
builder error: C compilation failed	Missing C compiler (gcc or clang) in system PATH.	Install gcc/clang and ensure it is available in terminal PATH.

References

• V Lang