Quick Start Guide

Build real programs in Wyn in minutes.

Project Templates

Wyn includes starter templates for common project types:

wyn new myapp              # default — hello world
wyn new myapp --cli        # CLI tool with arg parsing
wyn new myapp --api        # REST API with SQLite
wyn new myapp --web        # Web app with HTML + API + SQLite
wyn new myapp --lib wyn    # Wyn package (publishable)
wyn new myapp --lib python # Python extension module

Each template generates wyn.toml, src/main.wyn, tests/, and README.md — ready to wyn run.

CLI Tool: Word Counter

fn main() -> int {
    var args = System.args()
    if args.len() < 2 {
        println("Usage: wc <file>")
        return 1
    }
    var content = File.read(args[1])
    var lines = content.split("\n")
    var words = 0
    for line in lines {
        var parts = line.trim().split(" ")
        for p in parts {
            if p.len() > 0 { words = words + 1 }
        }
    }
    println("${lines.len()} lines, ${words} words, ${content.len()} chars")
    return 0
}

wyn run wc.wyn -- myfile.txt
wyn build wc.wyn        # → 50KB binary

Data Processing: CSV Reader

fn main() -> int {
    var content = File.read("data.csv")
    var lines = content.split("\n")
    var total = 0.0
    var count = 0

    for line in lines {
        var cols = line.split(",")
        if cols.len() >= 2 {
            total = total + cols[1].to_int()
            count = count + 1
        }
    }

    println("Average: ${total / count}")
    return 0
}

Concurrency: Parallel Work

fn compute(id: int) -> int {
    var sum = 0
    for i in 0..10000 { sum = sum + i }
    return sum
}

fn main() -> int {
    var t1 = spawn compute(1)
    var t2 = spawn compute(2)
    var t3 = spawn compute(3)
    println("${await t1}, ${await t2}, ${await t3}")
    return 0
}

Structs and Methods

struct Point { x: float, y: float }

fn distance(a: Point, b: Point) -> float {
    var dx = a.x - b.x
    var dy = a.y - b.y
    return Math.sqrt(dx * dx + dy * dy)
}

fn main() -> int {
    var p1 = Point { x: 0.0, y: 0.0 }
    var p2 = Point { x: 3.0, y: 4.0 }
    println("Distance: ${distance(p1, p2)}")
    return 0
}

Modules

math_utils.wyn:

export fn square(x: int) -> int { return x * x }
export fn cube(x: int) -> int { return x * x * x }

main.wyn:

import math_utils

fn main() -> int {
    println("5² = ${math_utils.square(5)}")
    println("3³ = ${math_utils.cube(3)}")
    return 0
}

Error Handling with Enums

enum Result {
    Ok(string)
    Err(string)
}

fn parse_config(path: string) -> Result {
    if !File.exists(path) {
        return Result.Err("file not found: ${path}")
    }
    return Result.Ok(File.read(path))
}

fn main() -> int {
    match parse_config("config.toml") {
        Result.Ok(data) => println("Config: ${data}")
        Result.Err(msg) => println("Error: ${msg}")
    }
    return 0
}

Higher-Order Functions

fn apply(arr: [int], f: fn(int) -> int) -> [int] {
    var result: [int] = []
    for x in arr { result.push(f(x)) }
    return result
}

fn main() -> int {
    var nums = [1, 2, 3, 4, 5]
    var factor = 3
    var tripled = apply(nums, fn(x: int) -> int { return x * factor })
    for x in tripled { println("${x}") }
    return 0
}