saQut 0.9.4 - Eclosion - Unstable Alpha

saQut 0.9.4 "Eclosion"

The compiler stops guessing and starts proving: errors are caught, defaults are honest, and null keeps its promises.

This is the first published release since 0.8.0. Instead of adding surface area, the 0.9.1–0.9.4 line closed soundness gaps — places where the compiler compiled something it could not honor at runtime. The result is a toolchain that rejects more at compile time and behaves predictably at run time, in both the VM and the experimental JIT.

Highlights

• JIT try/catch/throw — the experimental MIR JIT now runs try/catch/throw and catchable runtime errors (division by zero, failed casts, array out-of-range) with the same stdout and exit code as the VM. Six previously known-broken parity fixtures are now required to match byte-for-byte. The planned setjmp/longjmp bridge turned out to be undefined behavior in a JIT (setjmp in a returned frame); a per-instruction pending-error check is used instead, and functions without a try still pay zero cost.
• GC correctness in the JIT — recursive calls that allocate no longer get live objects garbage-collected out from under the program (shadow-stack frames now unwind per call).
• Honest defaults — an uninitialized string starts as "" (locals, struct fields and globals alike), struct fields with an array type start as an empty array, and an untouched nullable global really reads as null.
• Null keeps its promises — ordering comparisons (<, >, <=, >=) on a nullable value are now a compile error, same as arithmetic: pass the null gate first. Equality (==, !=) is unchanged.
• UTF-8 strings — indexing and length() count Unicode code points; upper()/lower() do real case mapping; file contents move as byte[].
• Simpler host surface — the capability (permission) system was removed (ADR-043): host calls are open by default and file operations work identically in the JIT.
• A stricter top level — statements at module scope are rejected (declarations only); using a built-in method without calling it (s.length) is a compile error instead of silently producing 0.
• Numeric honesty — radix literals (hex, binary) round-trip exactly; 64-bit hex literals keep their exact bit pattern as longint; out-of-range literals are caught at compile time.

Evidence

Clean build at c26dcb8; bash tests/run.sh exits 0: 112/112 golden tests, 94/94 differential (VM≡JIT) passes with 1 honest skip, 7/7 unit tests, module-cycle 2/2, GC 3/3, builtin-syntax 2/2.

Current Status

This is not a stable release.

The language, standard library and tooling are expected to evolve before version 1.0. Backward compatibility is not guaranteed during the 0.x series.

Known limitations (deliberate, on record): the JIT is [EXPERIMENTAL]; its Error.trace field is not at VM parity (recorded in #228); nullable globals are explicitly rejected by the JIT rather than silently mis-executed; compound && null-narrowing applies to the right operand only, not the if-body; the 0o octal prefix is not supported (leading-zero octal works). Tested on Linux x64.

saQut 0.9.4 — Unstable Alpha.

saQut 0.8.0 - Incubation - Unstable Alpha

saQut 0.8.0 "Incubation"

The first public preview of the saQut compiler.

This release marks the point where the compiler becomes usable as a complete toolchain. While many features are still evolving, the core architecture is now in place and future releases will focus on expanding the language and improving stability rather than redesigning the compiler.

Highlights

• Tokenizer
• Parser
• Abstract Syntax Tree (AST)
• Symbol collection
• Type checking
• Intermediate Representation (IR)
• Virtual Machine (VM)
• Built-in functions and FFI
• Diagnostics
• Compiler benchmarking
• Human-readable CLI output
• Machine-readable JSON output

Compiler Philosophy

saQut is designed around three principles:

• Deterministic behavior
• Transparent compilation
• Developer control

The compiler exposes every compilation stage instead of hiding internal decisions. Tokens, AST, symbols, diagnostics and IR can all be inspected through the CLI or consumed programmatically.

Current Status

This is not a stable release.

The language, standard library and tooling are expected to evolve before version 1.0.

Backward compatibility is not guaranteed during the 0.x series.