From clear intent to native software.

WYSOFIA · SYSTEMS & COMPILERS · ECUADOR

wysna-compiler — bash — 80x24

$ wysna build src/main.wysna -o app –opt-level 3

[1/4] Scanning source tree and loading stdlib modules…

✓ High-Level IR (HIR): Type safety and exhaustive match verified (8ms)

✓ Mid-Level IR (MIR): Deterministic ARC + CoW lifetime lowering (14ms)

✓ Backend: Emitted ISO C99 translation unit -> Invoking native toolchain

✓ Build successful: build/bin/app (executable, 42 KB, 0 external runtime dependencies)

---

Architectural Pillars

Designed from first principles to eradicate runtime crashes, garbage collection pauses, and cognitive overhead.

Zero Tracing GC Pauses

Deterministic memory management via Automatic Reference Counting (ARC) with transparent Copy-on-Write (CoW). Resources are freed the microsecond they exit scope.

Pure Value Semantics

Every variable behaves like an isolated value. Modifying a list, dictionary, or struct passed into a function never silently alters the caller’s state.

Typed Fallible Channels

No untyped exceptions or hidden panics. Operations that can fail explicitly return T ! E with postfix ? propagation and inline else err recovery.

Clean C99 & WASI Output

Lowers directly to standard ANSI C99 and WASI (wasm32-wasip1). Auditable machine code, instant startup times, and seamless C FFI interoperability.

---

Language Walkthrough

Inspect how Wysna combines the readability of modern expressive languages with the rigor of systems programming.

Value Semantics (ARC + CoW)

## Pure value semantics: modifications never bleed across scopes!
struct ServerConfig {
    host: str
    port: int
}

fn main() -> unit {
    let base_config = ServerConfig {
        host: "127.0.0.1",
        port: 8080,
    }

    # Assigning base_config creates a shared view (O(1) refcount bump)
    let mut dev_config = base_config

    # Mutating dev_config triggers transparent Copy-on-Write (CoW)
    dev_config.port = 3000

    print("Base config port: ", base_config.port)  # 8080 (unmodified)
    print("Dev config port:  ", dev_config.port)   # 3000 (isolated)
}

Algebraic Types & Match

## Tagged unions with exhaustive pattern matching
enum Payload {
    Text(str)
    Binary(list[int])
    Empty
}

fn process_payload(p: Payload) -> str {
    return match p {
        Payload.Text(msg) => "Text payload: " + msg
        Payload.Binary(data) => "Binary buffer of length: " + str(len(data))
        Payload.Empty => "No payload"
    }
}

fn main() -> unit {
    let message = Payload.Text("Deploying native binary")
    print(process_payload(message))
}

Fallible Channels (No Exceptions)

## Explicit error channels: compile-time checked recovery
fn parse_port(input: str) -> int ! str {
    let port = int(input)
    if port < 1 or port > 65535 {
        return error("Port must be between 1 and 65535")
    }
    return port
}

fn main() -> unit {
    # Inline recovery using `else err`
    let active_port = parse_port("999999") else err {
        print("[WARNING] Invalid port:", err)
        8080  # Fallback to port 8080
    }

    print("Server initialized on port:", active_port)
}

OOP & Interfaces

## Object-oriented polymorphism with constant-time vtable dispatch
interface Logger {
    fn log(msg: str) -> unit
}

class ConsoleLogger implements Logger {
    prefix: str

    fn init(prefix: str) -> ConsoleLogger {
        return ConsoleLogger { prefix: prefix }
    }

    fn log(msg: str) -> unit {
        print("[" + self.prefix + "]: " + msg)
    }
}

fn main() -> unit {
    let logger: Logger = ConsoleLogger.init("PRODUCTION")
    logger.log("Wysna engine running at native speed")
}

---

Comparative Engineering Matrix

How Wysna fits within the modern programming language ecosystem.

Feature	Wysna	C / C++	Rust	Go	Python
Memory Safety	Deterministic ARC + CoW	Manual free() (Unsafe)	Borrow Checker / Lifetimes	Tracing Garbage Collector	Tracing Garbage Collector
GC Pause Times	Zero (0ms)	Zero (0ms)	Zero (0ms)	1ms - 20ms	10ms - 100ms+
Semantics	Pure Value Semantics	Pointers / References	Single-Owner Move / Borrow	Pointer references	Reference sharing
Error Handling	Fallible Channels (T ! E)	Error codes / Exceptions	Result<T, E> (?)	val, err tuples	Untyped Exceptions
Compilation Target	Clean C99 & WASI	Machine code	LLVM IR / Machine code	Custom Machine code	Bytecode VM
Learning Curve	Low (Ergonomic)	High	Very High	Low	Very Low

---

Quickstart in 3 Steps

Get up and running with the Wysna toolchain in less than two minutes.

1. Install the Compiler Toolchain Clone the repository and run the automated installer:

   git clone https://github.com/WashingtonYandun/Wysna.git
   cd Wysna && ./install.sh

2. Scaffold a New Project Initialize a structured package with wysna init:

   wysna init my_app
   cd my_app

3. Build and Run Compile and execute the program with instant feedback:

   wysna run src/main.wysna

---

Explore the Handbook

Dive into the complete specification and learn how to construct production-ready software with Wysna.

Getting StartedToolchain installation, C99 compiler prerequisites, and project structure.

Language BasicsVariables, mutability rules, scalar types, and control flow expressions.

Memory & ARC + CoWDeep dive into value semantics, borrowing optimizations, and deterministic destruction.

Compound Types & MatchProduct types (structs), sum types (enums), and compile-time exhaustive matching.

Safe Error HandlingExplicit nullability (T?), coalescing (??), and fallible channels (T ! E).

Tooling & WASIThe wysna CLI, C99 translation units, and compiling to WebAssembly System Interface.