v0.15.1: Toolchain Confidence

v0.15.1 is a release-integrity and toolchain-confidence update for With.

The main job of this release is to make the self-contained toolchain story real across release artifacts: Windows installer assets are now published, Windows SDK packaging is stricter, SDKs must prove they were built with the pinned Clang toolchain, and SDK packages now carry the With-owned CMake and Ninja needed to reproduce future SDK builds without trusting host tooling.

This release also brings the checked-overflow implementation into the v0.15.1 tag line and tightens several spec/requirements sections so the written contract matches With's actual philosophy: safe by default, low ceremony where the compiler has the facts, and explicit boundaries only where real danger remains.

Highlights

Checked arithmetic is now in the release line

Plain arithmetic overflow is checked by default. Overflow is a bug, not implicit wraparound. Intentional modular or saturating arithmetic remains explicit.

with -e 'let x: i32 = 2147483647; let _ = x + 1'
# panic: integer overflow

with -e 'const X: i32 = 2147483647 + 1; let _ = X'
# error: integer overflow in comptime

with -e 'let x: u8 = 255; assert(x +% 1u8 == 0)'
with -e 'let x: u8 = 250; assert(x +| 20u8 == 255u8)'

Builds may also select an overflow policy explicitly with --overflow=panic, --overflow=wrap, or --overflow=saturate.

Windows release install and SDK assets

The release now publishes the Windows installer scripts and native Windows compiler asset alongside Darwin and Linux:

with-windows-x86_64.exe
install.ps1
install.cmd
with-llvm-sdk-22.1.6-windows-x86_64.tar.zst

README installation docs now include the Windows install flow.

Self-contained SDK packaging is stricter

The release SDK packages now enforce the invariant that SDKs are With-owned toolchain artifacts, not accidental products of whatever compiler happened to be on the host.

SDK packaging now checks that:

• Unix SDKs were built with Clang/clang++.
• Windows SDKs were built with clang-cl and SDK-owned LLVM assembly tools.
• SDK archives include With-owned cmake, ninja, clang, clang++, lld, llvm-nm, and llvm-strip.
• Windows SDK archives include the required LLVM/MSVC-compatible tools such as clang-cl, lld-link, llvm-lib, llvm-ml, and llvm-ml64.

This matters because With's bootstrap and release story depends on reproducible, self-contained toolchain inputs.

SDK bootstrap tooling is now packaged

CMake and Ninja are now first-class SDK build tools. The bootstrap scripts can build them from source, install them into the SDK prefix, and then use those SDK-owned tools for chained LLVM builds.

This removes another source of host-tool drift and makes SDK production less dependent on local machine setup.

Windows SDK build fixes

The Windows SDK build path was hardened in several places:

• Ninja bootstrap uses clang-cl shims.
• clang-cl warning noise is suppressed where it would break bootstrap.
• llvm-lib is used where Windows archive tooling expects it.
• Windows manifest tooling is passed explicitly.
• CMake test tools are avoided in the SDK build.
• Windows SDK builds honor the requested parallel job count.
• LLVM assembly uses SDK-owned llvm-ml / llvm-ml64.

Spec and requirements cleanup

Several requirements were corrected to match the language With is actually becoming:

• unsafe exists, but ordinary safe code should not need it.
• "Trust the programmer" is a rule of thumb for weird-but-safe code, not a license to accept unsafe programs.
• The old if ... then ... form and naked else expr requirements were removed from the spec.
• FFI unsafe boundaries were clarified: c_import calls are direct when the importer can model the contract; unmodeled memory, ownership, or lifetime assumptions remain unsafe or raw.

The problematic-requirements audit now records the BDFL rulings behind these corrections.

Changelog

Language and safety

• Checked integer overflow is implemented for runtime and comptime arithmetic.
• Added explicit overflow policies through compiler/build configuration.
• Added checked-overflow behavior tests for signed, unsigned, comptime, project, and explicit-mode cases.

Windows and release packaging

• Added Windows installer assets: install.ps1 and install.cmd.
• Documented Windows installation in README.md.
• Added Windows release SDK packaging.
• Quieted Windows SDK packaging under PowerShell.
• Recorded Clang-built Windows SDK verification and corrected final SDK status docs.

SDK/toolchain

• Enforced Clang-built LLVM SDKs in package scripts and docs.
• Packaged SDK-owned CMake.
• Packaged SDK-owned Ninja.
• Added Unix and Windows CMake/Ninja bootstrap scripts.
• Fixed chained SDK tool builds.
• Made SDK tool build scripts executable.
• Accepted CMake string compiler cache entries.
• Avoided CMake test tools in SDK builds.
• Honored parallel job count in Windows SDK builds.
• Passed Windows manifest tooling explicitly.
• Used SDK-owned LLVM assembler/archive tools for Windows.

Documentation and spec

• Updated README Windows install instructions.
• Scoped unsafe and memory-management requirements.
• Scoped "trust the programmer" as guidance, not a global compiler rule.
• Removed stale if then requirements from the spec and requirements matrix.
• Clarified FFI unsafe boundaries.
• Recorded BDFL problematic-requirements rulings.

Published assets

install.sh
install.ps1
install.cmd
with-bootstrap-c-v0.15.1.tar.zst
with-darwin-aarch64
with-linux-x86_64
with-windows-x86_64.exe
with-llvm-sdk-22.1.6-darwin-aarch64.tar.zst
with-llvm-sdk-22.1.6-linux-x86_64.tar.zst
with-llvm-sdk-22.1.6-windows-x86_64.tar.zst

Verification notes

Darwin arm64 release gates were run from the v0.15.1 tag:

WITH_VERSION=v0.15.1 with build
WITH_VERSION=v0.15.1 ./out/release/bin/with build :fixpoint
WITH_VERSION=v0.15.1 ./out/release/bin/with build :test
WITH_VERSION=v0.15.1 ./out/release/bin/with build :test-green
WITH_VERSION=v0.15.1 ./out/release/bin/with build :last-green

Published asset digests include:

with-darwin-aarch64
sha256:2b4cce52b9b6d2e90c45e65de9edf9f260c58d427968776890b9bd219b7708f3

with-linux-x86_64
sha256:603c55ec1db85f3080a8e245c33f228bcbe64788c734d8d0e7f631a499fab1af

with-windows-x86_64.exe
sha256:9327fbec781298a8e537ecd964a2f311105129d282e3d87fcb7ebafa62168385

with-llvm-sdk-22.1.6-darwin-aarch64.tar.zst
sha256:aae25a6d115051061afa7249d3ce590296f4695bb23ccb04bdf6e2d8c530a7c2

with-llvm-sdk-22.1.6-linux-x86_64.tar.zst
sha256:f978cae85045617ce9f8e426e64bb05c667cd15d47e0e39adc541e9575b4b387

with-llvm-sdk-22.1.6-windows-x86_64.tar.zst
sha256:0c4f9860cf528b3821781d89e5b42947ef8ee2249327cffa64fb9fb5eac09a4a

Commits since v0.15.0

502b6a1c Check integer overflow by default
6e799dc6 Add Windows release SDK packaging
c02f8b2e Add Windows installer assets
3f20cf64 Document Windows install in README
4ed83fb1 Enforce Clang-built LLVM SDKs
be61fd29 Package SDK CMake as a build tool
9b20ced4 Package SDK Ninja as CMake backend
8d752d79 Use clang-cl shims for Ninja bootstrap
03a8c7ba Suppress clang-cl shim flag warning for Ninja
0a97886e Disable warnings-as-errors for clang-cl Ninja shim
061cb065 Use llvm-lib shim for Ninja bootstrap
134a14be Mark SDK tool build scripts executable
1b4a57b0 Fix chained SDK tool builds
7ce00f7e Pass Windows manifest tool to SDK builds
90ec7293 Avoid CMake test tools in SDK build
7541d5d3 Accept CMake string compiler cache entries
23d2a780 Use SDK llvm-ml for Windows LLVM assembly
8a8cfb75 Use SDK llvm-ml64 for Windows x64 assembly
b43d6d1a Honor parallel job count in Windows SDK builds
03e1c91e Scope unsafe and memory-management requirements
3a4e508d Scope trust-the-programmer requirement
dcc3ae0b Remove if-then requirements from spec
ea0a7944 Clarify FFI unsafe boundaries
305b96d1 Keep Windows SDK packaging quiet under PowerShell
c18e9040 Record Clang-built SDK verification
d9613b76 Correct final SDK status summary
3a0fcb97 Record BDFL problematic requirement rulings
5f47453e Bump version to v0.15.1

v0.15.0: Self-Hosting Everywhere

v0.15.0 is a portability and safety checkpoint for With. The compiler is no longer just proving itself on Darwin and Linux: this release brings native Windows bootstrap support into the release flow, publishes per-platform static LLVM SDK assets, and tightens the rules that make With feel high level without giving up systems-language guarantees.

This is also a language-quality release. Arithmetic overflow is now a checked bug by default, C ABI callback types are modeled directly, if expression bodies use one consistent marker rule, and the spec gained a requirements traceability matrix plus a mission-driven audit. The throughline is the With bargain: make the compiler carry the complexity so user code stays direct, native, and safe.

Highlights

Native Windows bootstrap support

Windows x86_64 is now part of the self-hosting release story.

This release adds the Windows platform runtime, fiber core, fiber assembly, bootstrap source fixes, stack-budget checks, release packaging, and static LLVM SDK packaging needed to ship a native Windows compiler asset.

Published assets now include:

with-windows-x86_64.exe
with-llvm-sdk-22.1.6-windows-x86_64.tar.zst
install.ps1
install.cmd

The Windows release gate verified the compiler build, fixpoint, emitted-C fixpoint, PE stack reserve, and system-DLL-only imports.

Checked integer overflow by default

Plain arithmetic is now safe arithmetic. Overflow is a bug, not implicit wraparound. Runtime overflow traps, comptime overflow is rejected, and intentional modular or saturating arithmetic remains explicit.

with -e 'let x: i32 = 2147483647; let _ = x + 1'
# panic: integer overflow

with -e 'const X: i32 = 2147483647 + 1; let _ = X'
# error: integer overflow in comptime

with -e 'let x: u8 = 255; assert(x +% 1u8 == 0)'
with -e 'let x: u8 = 250; assert(x +| 20u8 == 255u8)'

Builds can also select an overflow policy explicitly with --overflow=panic, --overflow=wrap, or --overflow=saturate.

Explicit C ABI function pointer types

With now has a distinct raw C ABI callback type:

type CallbackHolder {
    cb: extern "C" fn(value: i32) -> i32,
}

fn add_one(value: i32) -> i32:
    value + 1

fn apply_raw(cb: extern "C" fn(i32) -> i32, value: i32) -> i32:
    cb(value)

fn main:
    let from_name: extern "C" fn(value: i32) -> i32 = add_one
    assert(from_name(41) == 42)

    let from_closure: extern "C" fn(i32) -> i32 = value => value * 2
    assert(from_closure(21) == 42)

    let holder = CallbackHolder { cb: value => value - 1 }
    assert(holder.cb(43) == 42)
    assert(apply_raw(value => value + 2, 40) == 42)

c_import and with migrate now map C function-pointer typedefs to this type. Non-capturing With functions and closures can coerce to extern "C" fn; capturing closures are rejected because a raw C function pointer cannot carry With closure context.

Consistent if body markers

The final bare else expr exception is gone. Every if, else if, and else body now uses the normal With body forms: inline colon, newline colon, or braces.

fn label(score: i32) -> str:
    if score >= 90: "excellent"
    else if score >= 70:
        "ok"
    else: "needs work"

Mixed block forms remain legal when the body shape warrants it:

fn describe(x: i32) -> str:
    if x < 0:
        "negative"
    else if x == 0 { "zero" }
    else: "positive"

This is now rejected:

else "needs work"

Use:

else: "needs work"

Compiler-internal ABI cleanup

Compiler-owned With runtime code no longer uses @[c_export] as an internal linkage mechanism. That attribute is for intentional foreign ABI surfaces exposed to C, Rust, Zig, Python, and other non-With callers. With-to-With code uses modules and normal visibility.

The release also fixes several internal codegen/runtime issues found while tightening that boundary, including Vec pointer field C codegen, regex runtime string pointer extraction, closure MIR memory scanning, and tailrec optimizer accessors.

Release and SDK packaging cleanup

The release flow now publishes self-contained static LLVM SDK assets by platform, matching the compiler's self-contained toolchain model.

Published SDK assets:

with-llvm-sdk-22.1.6-darwin-aarch64.tar.zst
with-llvm-sdk-22.1.6-linux-x86_64.tar.zst
with-llvm-sdk-22.1.6-windows-x86_64.tar.zst

The release scripts also gained better stale-artifact pruning and clearer guidance that emit-c-fixpoint is a manual emit-C verification target, not a normal release gate unless the release scope calls for it.

Spec traceability and mission audit

The spec now has a generated requirements traceability matrix in docs/requirements.md, with stable hierarchical requirement IDs and source references. The requirements were then audited against the With mission in docs/problematic-requirements.md, and the mission statement was added in docs/mission.md.

This is groundwork for treating the spec as an executable engineering contract rather than prose that drifts away from implementation.

Changelog

Language semantics

• Checked integer overflow is now the default for runtime and comptime arithmetic.
• Explicit wrapping and saturating arithmetic remain available through operators such as +% and +|.
• Build/project overflow policy can be selected through --overflow=<panic|wrap|saturate>.
• Final else bodies in mixed-form if chains now require a body marker (: or {}), matching all other block forms.
• extern "C" fn(...) -> T is now a first-class raw C ABI function pointer type.
• Non-capturing With functions and closures can coerce to raw C function pointers; capturing closures cannot.

C interop, migration, and emit-C

• c_import emits C function pointer typedefs as extern "C" fn types.
• with migrate preserves C function pointer shapes through the new callback type.
• C void-cast discards are preserved without accidentally becoming With tail expressions.
• Emit-C bootstrap packaging now uses the workspace emitted-C flow.
• Linux bootstrap C support handles GCC 15 CRT object locations.
• Several C backend correctness fixes landed, including Vec pointer field typing and large aggregate / regex literal ABI coverage.

Self-hosting and platforms

• Added Windows x86_64 runtime/platform support for bootstrap and release packaging.
• Added Windows fiber core and Windows x86_64 fiber assembly.
• Added PE stack-budget verification and release import checks.
• Added Windows bootstrap source fixes and release status documentation.
• Removed duplicate main filesystem extern declarations.
• Avoided declaring command directories as build outputs.
• Supported staged compiler layout in p7 tests.

Runtime and compiler internals

• Removed compiler-internal @[c_export] usage from runtime/platform code.
• Fixed regex runtime string pointer extraction.
• Scanned closure MIR memory locals correctly.
• Passed MIR tailrec optimizer state by reference and hardened tailrec optimizer accessors.
• Fixed Sema pointer/reference handling in tailrec compatibility checks.

Build, release, and tooling

• Added per-platform static LLVM SDK packaging.
• Tightened release pruning and stale artifact cleanup.
• Clarified release-runbook emit-C guidance.
• Added static SDK packaging for Darwin, Linux, and Windows.
• Added release/package verification scripts for stack budget and internal c_export regressions.

Documentation

• Added docs/requirements.md, a full requirements traceability matrix derived from the spec.
• Added docs/problematic-requirements.md, a mission-based audit of requirements that need redesign or clarification.
• Added docs/mission.md.
• Updated the spec for checked overflow, explicit C ABI function pointers, and final-else body marker rules.
• Added Windows bootstrap status and updated bootstrap/release runbooks.

Commits since v0.14.8

c8b887e Require body marker for final if else
610a18c Checkpoint Windows bootstrap work
c427cbf Remove internal runtime c_export usage
98aa774 Fix Vec ptr field C codegen type
6d8f3a3 release: tighten pruning and emit-c guidance
3f30f05 Complete Windows bootstrap source fixes
282794b Remove duplicate main filesystem extern
e883121 Find GCC 15 CRT objects on Linux
84af035 Use workspace emit-C for bootstrap packaging
29424dc Avoid declaring command directory as output
2d71391 Fix remaining Windows bootstrap C compile issues
6eb7592 Dereference Sema for tailrec signature check
5313673 Use unsafe block for Sema dereference
e4aa059 Pass Sema value to tailrec compatibility check
dee6289 Implement extern C function pointer type
db8d813 Add requirements traceability matrix
9600ea3 Add problematic requirements audit
f2300bb Clarify problematic requirements audit scope
0cc2e4d Expand problematic requirements audit
afba6a8 Align requirements audit with mission
73cbb94 Bootstrap With on Windows
f36ba83 release: v0.15.0
5c7cc01 Scan closure MIR memory locals
7698f54 Pass MIR tailrec optimizer by reference
878ccb8 Harden MIR tailrec optimizer accessors
53ffb3b Fix regex runtime string pointer extraction
36f2ecd Check integer overflow by default
24d6b4d Support staged compiler layout in p7 tests
e498da5 Complete Windows release bootstrap gates

Merge-only commits in the tag range were omitted from the list above unless they carried release-relevant integration context.

Verification

Darwin arm64:

WITH_VERSION=v0.15.0 with build
WITH_VERSION=v0.15.0 ./out/release/bin/with build :fixpoint
WITH_VERSION=v0.15.0 ./out/release/bin/with build :test
WITH_VERSION=v0.15.0 ./out/release/bin/with build :test-green
WITH_VERSION=v0.15.0 ./out/release/bin/with b...

v0.14.8: The Spec Comes Alive

With is about keeping the good shape of Python while bringing systems-level
safety, direct C interop, and a self-hosting compiler to the same language.
v0.14.8 is where that starts to feel real: generators, comprehensions,
destructuring, pattern parameters, in, Option/Result flow, scoped
concurrency, no_suspend, and no-std tiers all move from spec sketches into
working, tested language. At the same time, the compiler sheds internal C ABI
exports and gets closer to being one self-contained With executable.

Language Features

Membership: in, not in, and in patterns

let primes = [2, 3, 5, 7, 11, 13]

assert(5 in primes)
assert(4 not in primes)
assert('k' in 'a'..='z')
assert("hello" in "hello world")

let category = match "filter":
    in ["map", "filter", "take", "skip"] => "lazy"
    in ["collect", "fold", "sum", "count"] => "eager"
    _ => "other"

Struct and tuple destructuring

type Point { x: i32, y: i32 }

let p = Point { x: 3, y: 4 }
let { x, y } = p
assert(x + y == 7)

let pair = (1, 2)
let (a, b) = pair
assert(a + b == 3)

Pattern parameters

type Point { x: i32, y: i32 }

fn manhattan({ x: x1, y: y1 }: Point, { x: x2, y: y2 }: Point) -> i32:
    let dx = if x2 > x1: x2 - x1 else: x1 - x2
    let dy = if y2 > y1: y2 - y1 else: y1 - y2
    dx + dy

assert(manhattan(Point { x: 0, y: 0 }, Point { x: 3, y: 4 }) == 7)

Reference pattern ergonomics

type Point { x: i32, y: i32 }

let point = Point { x: 4, y: 5 }
let { x, y } = &point
assert(*x + *y == 9)

let pairs: Vec[(i32, i32)] = Vec.new()
pairs.push((1, 2))
pairs.push((3, 4))
for (a, b) in pairs.iter_ref():
    assert(*a < *b)

Struct default field values

type Config {
    host: str = "localhost",
    port: u16 = 8080,
    debug: bool = false,
}

let c = Config { port: 9090 }
assert(c.host == "localhost")
assert(c.port == 9090)
assert(c.debug == false)

Optional chaining and ??

type Address { city: Option[str] }
type Profile { address: Option[Address] }

let profile = Profile { address: None }
let city = profile.address?.city ?? "unknown"
assert(city == "unknown")

fn find(id: i32) -> Option[str]: None
fn get_or_fail(id: i32) -> Result[str, str]:
    let name = find(id) ?? return Err("not found")
    Ok(name)

Final else expression in mixed-form if chains

let name =
    if code == 200:
        "ok"
    else if code == 404:
        "missing"
    else: "error"

Exhaustive expression-position match

enum Color:
    Red
    Green
    Blue

fn name(c: Color) -> str:
    match c:
        .Red => "red"
        .Green => "green"
        .Blue => "blue"

Missing an enum variant in an expression-position match is now a hard
compile error instead of a warning.

Option, Result, and Collection Flow

Option and Result combinators

let doubled = Some(5).map(n => n * 2).unwrap_or(0)
assert(doubled == 10)

let filtered = Some(10)
    .filter(x => x > 5)
    .and_then(x => if x < 20: Some(x) else: None)
assert(filtered.unwrap() == 10)

let err_len: Result[i32, usize] = Err("bad").map_err(s => s.len())

sequence, traverse, and transpose

fn checked_positive(x: i32) -> Result[i32, str]:
    if x > 0: Ok(x) else: Err("negative")

let values: Vec[Result[i32, str]] = Vec.new()
values.push(Ok(1))
values.push(Ok(2))

let all: Result[Vec[i32], str] = values.sequence()

let nums: Vec[i32] = Vec.new()
nums.push(1)
nums.push(2)
let checked = nums.traverse(x => checked_positive(x))

Option and Result for-comprehensions

let maybe_sum =
    for a in Some(2); b in Some(3); if a < b:
        yield a + b

let checked_sum: Result[i32, str] =
    for a in Ok(2); b in Ok(3):
        yield a + b

Iterator combinator substrate

let total = nums.iter()
    |> filter(x => x % 2 == 0)
    |> map(x => x * x)
    |> take(3)
    |> sum()

New iterator adapters include the substrate for map, filter, flat_map,
zip, take, fold, reduce, partition, sum, and collect.

Collection comprehensions

let squares = [x * x for x in 0..5]
let evens = [x for x in 0..8 if x % 2 == 0]
let pairs = [x * 10 + y for x in 0..3 for y in 0..3 if x != y]
let sums = [a + b for (a, b) in [(1, 2), (3, 4), (5, 6)]]

HashMap convenience methods

var counts: HashMap[str, i32] = HashMap.new()

counts.update("alice", 0, n => n + 1)
counts.increment("bob")
counts.decrement("carol")

StringBuilder and faster repeated append

var sb = StringBuilder.with_capacity(64)
sb.push_str("with")
sb.push_byte(32 as u8)
sb.push_str("v0.14.8")
assert(sb.to_str() == "with v0.14.8")

var s = ""
for _ in 0..64:
    s = s ++ "x"
assert(s.len() == 64)

Generators and Concurrency

Generators

gen fn countdown(from: i32) -> i32:
    var i = from
    while i >= 0:
        yield i
        i -= 1

var total = 0
for n in countdown(4):
    total += n
assert(total == 10)

Generators preserve locals across yield and reject yielding local references.

Scoped async tasks

async fn fetch_data(id: i32) -> Result[i32, str]:
    id + 1

async fn answer -> Result[i32, str]:
    async scope s =>:
        let task = s.track(fetch_data(41))
        task.await?

fn main:
    let result = answer().await.unwrap()
    assert(result == 42)

Scoped OS-thread workers

let base = 40
let result = scope s =>:
    let handle = s.spawn(() => base + 2)
    handle.join()
assert(result == 42)

no_suspend blocks

fn add_one(value: i32) -> i32:
    value + 1

let value = no_suspend:
    add_one(41)

let inline = no_suspend: add_one(41)
let braced = no_suspend { add_one(41) }

no_suspend rejects direct awaits, transitive suspension, select-await, and
implicit task cleanup that would yield.

Guarded with dispatch

use std.sync

let lock = mutex_new(42)
let value = with lock.enter() as data:
    data + 1
assert(value == 43)

The compiler now distinguishes guarded with blocks from builder-style with
blocks by type, and no-await-guard liveness catches guards that remain live
across scheduler-yielding suspension points.

Systems and Safety

no-std / freestanding tier

//! args: --no-std

@[panic_handler]
fn on_panic -> Never: unreachable()

@[entry]
fn start -> i32:
    let opt: Option[i32] = Some(10)
    opt.unwrap() + 32

--no-std now selects the core prelude, --prelude=alloc selects the alloc
prelude, and the compiler diagnoses missing @[entry], @[panic_handler],
and allocator requirements for the selected tier.

Raw pointer and manual extern safety

extern fn raw_write(ptr: *mut i32) -> void

var value = 0
let p = (&raw mut value) as *mut i32

unsafe {
    raw_write(p)
    *p = 42
}

Manual extern calls and raw pointer field/access operations now require
unsafe, while c_import keeps C ergonomics for imported C APIs.

Raw pointers as Option

let p: *mut i32 = null
assert(p.as_option().is_none())

var x = 42
let q = (&raw mut x) as *mut i32
assert(q.as_option().is_some())

Length accessors

let items: Vec[i32] = Vec.new()
items.push(10)
items.push(20)
items.push(30)

let n: usize = items.len()
let n32: i32 = items.len32()
let n64: i64 = items.len64()
let un32: u32 = items.ulen32()

Build, Test, and Release Flow

with build is now the canonical build interface:

with build
with build :fixpoint
with build :test
with build :test-green
with build :last-green
with build :update-seed
with build :install-user
with build :prune

with test --help now prints command-specific help, and explicit multi-file or
directory test invocations run each listed target instead of silently using only
the first path.

Compiler and Runtime Internals

• Compiler-owned LLVM/Clang bridge code moved from rt/ into
  src/compiler/ as ordinary With modules.
• Compiler/runtime internal code no longer uses @[c_export] as an internal
  linkage trick. @[c_export] is reserved for user code that intentionally
  exposes a C ABI to other languages.
• Runtime ABI symbols are preserved without foreign export annotations.
• Bootstrap-C packaging was updated for the bridge migration.

Assets

• with-darwin-aarch64
• with-linux-x86_64
• with-bootstrap-c-v0.14.8.tar.zst
• with-llvm-sdk-22.1.6-darwin-aarch64.tar.zst
• with-llvm-sdk-22.1.6-linux-x86_64.tar.zst
• install.sh

Verification

Darwin arm64 and Linux x86_64 both passed:

WITH_VERSION=v0.14.8 with build
WITH_VERSION=v0.14.8 with build :fixpoint
WITH_VERSION=v0.14.8 with build :test
WITH_VERSION=v0.14.8 with build :test-green
WITH_VERSION=v0.14.8 with build :last-green

The full :test target includes the release-gate emit-C smoke. The
bootstrap-C source bundle was generated from the verified compiler.

v0.14.7: self-contained c_import + published LLVM SDK

v0.14.7 makes the toolchain self-contained: c_import no longer needs an external LLVM at runtime, and the static LLVM SDK the compiler builds against is now published and fetched, never rebuilt from source or taken from the system.

Highlights:

• c_import is self-contained at runtime (#312). Clang's builtin headers (stddef.h, stdarg.h, …) are embedded in the compiler binary and materialized to ~/.cache/with/clang-resource/<v>/ on first use; -resource-dir points there. The compiler no longer probes LLVM_PREFIX / llvm-config / /usr/local/llvm for an external resource dir. This fixes use c_import("stdio.h") on a clean host that has no LLVM installed (previously failed with 'stddef.h' file not found). WITH_CLANG_RESOURCE_DIR remains an explicit override for a header outside the embedded C/POSIX set.
• The static LLVM/Clang/lld SDK is published as a per-platform release asset and fetched, pinned, by the build (#313). with build :deps (or make deps) downloads with-llvm-sdk-<llvm-ver>-<platform>.tar.zst into .deps/llvm-<ver>-<host>, so a clean checkout builds the compiler without rebuilding LLVM from source and without trusting a system LLVM. Building LLVM from source is now strictly a new-platform bootstrap step.
• The self-contained-toolchain invariant is documented in AGENTS.md and both runbooks: after bootstrap the seed depends on nothing external from LLVM.

Verification:

• Darwin arm64: WITH_VERSION=v0.14.7 with build
• Darwin arm64: WITH_VERSION=v0.14.7 with build :fixpoint
• Darwin arm64: WITH_VERSION=v0.14.7 with build :test
• Darwin arm64: WITH_VERSION=v0.14.7 with build :emit-c-fixpoint
• Linux x86_64: WITH_VERSION=v0.14.7 ./out/bin/with build
• Linux x86_64: WITH_VERSION=v0.14.7 ./out/bin/with build :fixpoint
• Linux x86_64: WITH_VERSION=v0.14.7 ./out/bin/with build :test

Assets:

• with-darwin-aarch64: verified Darwin arm64 compiler binary
• with-linux-x86_64: verified Linux x86_64 compiler binary
• with-bootstrap-c-v0.14.7.tar.zst: emitted-C bootstrap source bundle; not a release compiler binary
• with-llvm-sdk-22.1.6-darwin-aarch64.tar.zst: static LLVM SDK for the Darwin arm64 build (with build :deps)
• with-llvm-sdk-22.1.6-linux-x86_64.tar.zst: static LLVM SDK for the Linux x86_64 build
• install.sh: installer script

v0.14.6: c_import resilience for opaque-by-value declarations

v0.14.6 makes c_import resilient to glibc headers that pass opaque structs by value, and improves optional-chaining and fieldless-enum typing.

Highlights:

• c_import no longer fails an entire header import when a C declaration passes or returns an opaque (incomplete) struct by value. Such a function is uncallable from With — you can never construct an opaque value — so it is now stubbed with a loud comptime_error instead of emitting an extern fn the backend cannot lower. This fixes use c_import("stdio.h") on Linux/glibc, where the transitively-declared offenders previously produced 16 hard errors (#311).
• Optional-chaining (?.) results now type per the §10.3 type-aware desugaring, so a chain checks against a written Option[T] annotation the same as in inferred let position (#307).
• Fieldless enums infer an i32 backing, so a bare enum with auto-incrementing variants parses and lowers (including as i32) without an explicit : i32: backing (#309).

Verification:

• Darwin arm64: WITH_VERSION=v0.14.6 with build
• Darwin arm64: WITH_VERSION=v0.14.6 with build :fixpoint
• Darwin arm64: WITH_VERSION=v0.14.6 with build :test
• Darwin arm64: WITH_VERSION=v0.14.6 with build :emit-c-fixpoint
• Linux x86_64: WITH_VERSION=v0.14.6 ./out/bin/with build
• Linux x86_64: WITH_VERSION=v0.14.6 ./out/bin/with build :fixpoint
• Linux x86_64: WITH_VERSION=v0.14.6 ./out/bin/with build :test

Assets:

• with-darwin-aarch64: verified Darwin arm64 compiler binary
• with-linux-x86_64: verified Linux x86_64 compiler binary
• with-bootstrap-c-v0.14.6.tar.zst: emitted-C bootstrap source bundle; not a release compiler binary
• install.sh: installer script

v0.14.5: Raylib ABI and Build Invalidation Fixes

v0.14.5 fixes C interop ABI lowering for raylib-style value structs and tightens build invalidation.

Highlights:

• Darwin arm64 C ABI lowering now packs and unpacks small C aggregates correctly for c_import calls and returns. This fixes raylib APIs such as ClearBackground(RAYWHITE) and DrawText(..., LIGHTGRAY).
• C-imported object-like macros such as raylib colors now fail loudly if they cannot be translated correctly instead of disappearing into undefined variables later.
• Build graph action targets now track build.w, build/*.w, and std.build source changes, so generated action outputs and install verification cannot reuse stale action results.
• with run rebuild invalidation now includes the compiler binary fingerprint, so changing the installed with automatically invalidates stale build outputs.
• The release runbook now records the Linux x86_64 release host, explicit seed compiler path, LLVM SDK path, and detached worktree workflow.

Verification:

• Darwin arm64: WITH_VERSION=v0.14.5 with build
• Darwin arm64: WITH_VERSION=v0.14.5 with build :fixpoint
• Darwin arm64: WITH_VERSION=v0.14.5 with build :test
• Darwin arm64: WITH_VERSION=v0.14.5 with build :emit-c-fixpoint
• Linux x86_64: WITH_VERSION=v0.14.5 ./out/bin/with build
• Linux x86_64: WITH_VERSION=v0.14.5 ./out/bin/with build :fixpoint
• Linux x86_64: WITH_VERSION=v0.14.5 ./out/bin/with build :test
• Linux x86_64: WITH_VERSION=v0.14.5 ./out/bin/with build :emit-c-fixpoint

Assets:

• with-darwin-aarch64: verified Darwin arm64 compiler binary
• with-linux-x86_64: verified Linux x86_64 compiler binary
• with-bootstrap-c-v0.14.5.tar.zst: emitted-C bootstrap source bundle; not a release compiler binary
• install.sh: installer script

v0.14.4: Raylib c_import and Manual PCRE2 Tests

v0.14.4 tightens the first-run C package experience and publishes verified Darwin arm64 and Linux x86_64 binaries.

Highlights:

• with run works from a project without requiring an explicit source file argument.
• with get c.raylib resolves the current ConanCenter recipe version automatically.
• c_import("raylib.h") supports the raylib 6.0 header path and imports compound-literal object macros such as RAYWHITE and LIGHTGRAY.
• PCRE2 migration smoke/prep targets are manual-only again and are not part of the normal test path.
• Git LFS hooks were removed from the repository workflow.

Verification:

• Darwin arm64: WITH_VERSION=v0.14.4 out/bin/with build
• Darwin arm64: WITH_VERSION=v0.14.4 out/bin/with build :fixpoint
• Darwin arm64: WITH_VERSION=v0.14.4 out/bin/with build :test
• Darwin arm64: WITH_VERSION=v0.14.4 out/bin/with build :emit-c-fixpoint
• Linux x86_64: WITH_VERSION=v0.14.4 out/bin/with build
• Linux x86_64: WITH_VERSION=v0.14.4 out/bin/with build :fixpoint
• Linux x86_64: WITH_VERSION=v0.14.4 out/bin/with build :test
• Linux x86_64: WITH_VERSION=v0.14.4 out/bin/with build :emit-c-fixpoint

Assets:

• with-darwin-aarch64: verified Darwin arm64 compiler binary
• with-linux-x86_64: verified Linux x86_64 compiler binary
• with-bootstrap-c-v0.14.4.tar.zst: emitted-C bootstrap source bundle; not a release compiler binary
• install.sh: installer script

v0.14.3: Linux x86_64 Bootstrap Release

This release adds Linux x86_64 as a published compiler platform alongside
Darwin arm64.

Assets

• with-darwin-aarch64 — Darwin arm64 compiler binary.
• with-linux-x86_64 — Linux x86_64 compiler binary.
• with-bootstrap-c-v0.14.3.tar.zst — emitted-C bootstrap source bundle.
• install.sh — host-aware installer for Darwin arm64 and Linux x86_64.

Notes

• Normal With builds no longer need the clang executable as a linker driver.
• Release binaries are linked against the pinned static LLVM SDK and static
  libclang.a. The Linux x86_64 binary also statically links the C++ compiler
  runtime (libstdc++, libgcc, and libgcc_eh).
• Linux x86_64 seed download and release packaging now use the
  with-linux-x86_64 asset.
• Generated compiler version sources now declare WITH_VERSION and the current
  Git ref as build inputs, preventing stale release version text after commits
  or tags.

Verification

Darwin arm64:

WITH_VERSION=v0.14.3 with build
WITH_VERSION=v0.14.3 with build :fixpoint
WITH_VERSION=v0.14.3 with build :test
WITH_VERSION=v0.14.3 with build :emit-c-fixpoint

Linux x86_64:

WITH_VERSION=v0.14.3 with build
WITH_VERSION=v0.14.3 with build :fixpoint
WITH_VERSION=v0.14.3 with build :test
WITH_VERSION=v0.14.3 with build :emit-c-fixpoint

Dynamic dependency checks:

otool -L with-darwin-aarch64
ldd with-linux-x86_64

Both platform binaries contain static clang_createIndex symbols and no
dynamic LLVM/Clang library dependency.

v0.14.2: Bootstrap C Bundle

v0.14.2 publishes the emit-C self-hosting fix and adds a bootstrap-C source bundle for bringing With up on new platforms.

Verification:

• WITH_VERSION=v0.14.2 with build
• WITH_VERSION=v0.14.2 with build :fixpoint
• WITH_VERSION=v0.14.2 with build :test

Assets:

• with-darwin-aarch64: verified Darwin arm64 compiler binary
• install.sh: installer script
• with-bootstrap-c-v0.14.2.tar.zst: emitted-C bootstrap source bundle; not a release compiler binary

v0.14.1: static LLVM release build

v0.14.1

This release packages the Darwin arm64 compiler as a self-contained with binary for normal use. LLVM and libclang are linked from a pinned static LLVM 22.1.6 SDK, so a clean system does not need a separate LLVM, Clang, or Zig installation to run the compiler.

Highlights:

• Build graph support sources moved from repository root into build/; root keeps only build.w.
• Normal compiler linking uses ld64.lld directly instead of invoking the clang executable as a linker driver.
• Release linking requires static libclang.a and includes the required Clang component archives.
• Emit-C/bootstrap C compilation now uses WITH_EMIT_C_CC, then CC, then cc; Zig is no longer the default or required C compiler.
• Darwin release packaging verifies there are no dynamic LLVM, Clang, zlib, zstd, or libxml2 dependencies.

Verification:

WITH_VERSION=v0.14.1 with build
WITH_VERSION=v0.14.1 with build :fixpoint
WITH_VERSION=v0.14.1 with build :test

Release asset check:

with v0.14.1
otool -L: /usr/lib/libSystem.B.dylib, /usr/lib/libc++.1.dylib
sha256: 9b621721d18a6e280532f50f1d55ea387e8701e4ba7c09a17c2bc4325d71d2cc