Language Overview¶

Catalyst is a general-purpose, performance-first native programming language. It aims to combine explicit runtime behavior, composable type semantics, deterministic comptime, visible ownership, native systems reach, and first-class realtime constraints.

The language is not a DSP-only DSL. DSP and realtime kernels are the first validation target because they expose hidden allocation, layout ambiguity, aliasing assumptions, blocking behavior, and backend surprises quickly.

Identity¶

Catalyst should be:

• native and ahead-of-time compiled
• explicit about allocation, IO, blocking, dispatch, and other costs
• ergonomic enough for large programs
• predictable enough for realtime systems
• tooling-friendly even with heavy comptime
• general-purpose rather than domain-specific

Influences¶

From Zig:

• explicit cost model
• allocators and visible memory behavior
• comptime
• compact syntax
• native tooling

From TypeScript:

• composable types
• unions and intersections
• structural constraints
• strong inference
• ergonomic API expression

From Rust:

• explicit ownership vocabulary
• move-aware resource flow
• strong correctness culture
• pattern matching ergonomics

From C++:

• native systems programming reach
• value types and predictable layout
• zero-cost abstraction goals
• interop expectations

Catalyst intentionally avoids TypeScript-style type-level programming complexity, Rust-style pervasive lifetime proofs, Zig-style tooling opacity around heavy comptime code, and C++-style dependency complexity.

Implementation Strategy¶

The compiler starts small: functions, basic types, basic expressions, semantic analysis, structured IR, and a C backend. Larger language features should fit the pipeline without requiring backends to inspect AST or SIR directly.