Use Cases

Zith is designed for specific domains where its unique features shine.

Ideal Use Cases

Game Development

Why Zith excels: Native ECS support, scenes built into the language, zero-overhead performance, safe concurrency.

component Position { x: f32, y: f32 }
component Velocity { dx: f32, dy: f32 }

scene GameLevel {
    fn update(dt: f32) {
        // Systems process entities automatically
        movement_system.run(entities, dt);
        render_system.run(entities, camera);
    }
}

Real projects: 2D game engines, game tools and editors, server-side game logic, procedural generation tools.

Systems Programming

Why Zith excels: Manual memory control without GC, compile-time safety, C FFI, predictable performance.

fn processFile(path: string): [u8]! {
    let file = File.open(path)!
    file.readAll()!
}

Real projects: CLI tools, file processors, network services, embedded controllers, device drivers (with unsafe).

Domain-Specific Languages (DSLs)

Why Zith excels: Context system for safe embedded languages, no string parsing or injection risks, type-safe by design.

use SQL QueryBlock {
    SELECT name, email FROM users
    WHERE age > 18 AND active = true
    ORDER BY name ASC
}

Real projects: Query builders, configuration languages, template engines, build systems, rule engines.

Data Processing

Why Zith excels: Fast compilation, efficient memory usage, safe parallel processing, C interop.

fn processDataset(data: view [Record]): [Result] {
    data
        -> filter(|r| r.valid)
        -> map(|r| transform(r))
}

Real projects: ETL pipelines, log processors, data analysis tools, batch processors.

Embedded Systems

Why Zith excels: No runtime overhead, deterministic memory, direct hardware access (via unsafe), small binaries.

raw fn setPin(addr: opaque, val: u32) {
    unsafe {
        let ptr = addr as *u32;
        *ptr = val;
    }
}

Real projects: Microcontroller firmware, IoT devices, real-time systems, robotics controllers.

Not Recommended For

Web Frontend Development

Why not: No native WASM target yet (in progress), better alternatives exist (TypeScript, ReScript).

Pure Functional Programming

Why not: Imperative by design, limited higher-kinded types, no lazy evaluation by default.

Rapid Web Backend Prototyping

Why not: Smaller web framework ecosystem, more verbose than Python/Ruby.

Mobile App Development

Why not: Limited mobile platform support, no native UI frameworks, iOS/Android tooling immature.

Industry Applications

Gaming Industry

• Indie studios: Quick iteration, small teams
• Tool developers: Editors, level designers
• Server infrastructure: Game servers, matchmaking

Embedded/IoT

• Device manufacturers: Firmware development
• Automation: Industrial controllers
• Robotics: Real-time control systems

Infrastructure

• CLI tools: DevOps utilities
• Network services: Proxies, load balancers
• Data pipelines: ETL, stream processing

Education

• Teaching systems programming: Safer than C/C++
• Research prototypes: Quick implementation
• Student projects: Accessible yet powerful

Getting Started with Your Use Case

Ready to build? Check out the GitHub for inspiration!