ZynxA general-purpose language with explicit ownership.

Explicit ownership, visible errors, and cold async compiled to native code through LLVM.

Ownership Without a Garbage Collector

Every value has one clear owner. Moves, borrows, and drops are explicit and checked at compile time, so resources release deterministically and use-after-free is rejected before runtime.

Ownership and drop

Errors That Stay in the Signature

Fallible functions declare throws(E); try propagates and catch recovers per variant. No hidden exceptions and no silent failure paths; the error set is part of the contract.

Error handling

Cold, Structured Async

A future-returning call builds the work but does not start it. Nothing runs until you await it or hand it to a structured group, so concurrency stays predictable by construction.

Async semantics

A Standard Library That Shows Its Costs

Allocation is visible, ownership is obvious, and primitives compose. The I/O, filesystem, collections, secure-entropy boundary, networking, and Unicode modules each document what they own and what they can throw.

Standard library

Native Speed via LLVM

Zynx lowers to LLVM IR and links to a native binary, with a C ABI and FFI for talking to existing libraries when you need them.

Memory, unsafe, and FFI

Documented Behavior

Public pages describe the implemented and documented surface today, with unsupported areas called out explicitly.

Project status

First Program

Fallible behavior is visible from the first program. read_id declares the errors it can raise, and the caller chooses whether to propagate with try or recover with a catch arm per variant.

Zynx

import std.io;
import std.mem.{ AllocError };

error LoadError {
  NotFound,
  Denied,
}

fn read_id(fail: bool) throws(LoadError) -> i32 {
  if fail {
    throw LoadError.NotFound;
  }
  return 42;
}

fn main() throws(AllocError) {
  let id = read_id(false) catch {
    .NotFound => 0,
    .Denied => -1,
  };

  io.println(try ^"id={id}");
}

Choose A Document

New to Zynx: start with Install, then read Zynx By Example.
Checking language behavior: use the Language chapters.
Looking up an error or warning code: use the Diagnostics Reference.
Building or testing the compiler: use the Build Reference.
Using standard-library APIs: use the Standard Library.
Checking project scope: use Status.

Development Snapshot

Zynx is development software. Public pages describe implemented and documented behavior. Prefer the language chapters when a feature guide and current compiler behavior disagree.