Build native software for Frames.

Nexus SDK 6.10.0

The SDK repository packages the same immutable canonical compiler/toolchain source intended for Frames consumption. Published versions are version/hash pinned so Frames does not carry a silently forked compiler.

From source file to running program

./nexus --version
./nexus check examples/hello.nx
./nexus run examples/hello.nx
./nexus doctor
./nexus targets
./nexus abi

Hello Nexus

module hello;

fn add(a: i64, b: i64) -> i64 {
    return a + b;
}

fn main() -> i32 {
    let answer = add(20, 22);
    print(answer);
    return 0;
}

let creates an immutable binding; var creates a mutable binding. Functions declare parameter and return types explicitly, while modules give source units a stable identity.

One tool for create, lock, build and package.

./nexus new hello-frames
cd hello-frames
../nexus lock
../nexus build --reproducible --receipt
../nexus test tests
../nexus fmt --check .
../nexus lint --deny-warnings src/main.nx

A Nexus project uses nexus.toml plus a deterministic nexus.lock. Lock format v2 records the Nexus version, source hash, project files and dependencies. Reproducible mode and build receipts make the build inputs/output identity inspectable instead of implicit.

Example Frames project manifest

[package]
name = "HelloFrames"
version = "1.0.0"
publisher = "Example Developer"

[build]
entry = "src/main.nx"

[frames]
kind = "app"
capabilities = []
icon = "assets/app-icon.png"

Systems language fundamentals

The hosted C17 backend is intentionally the broadest executable language profile today. Native Frames backends implement a narrower systems/bootstrap subset; see Current boundaries before assuming hosted/native parity.

Ownership and explicit unsafe boundaries

Nexus combines move/use-after-move checking, borrowing/reference rules, deterministic cleanup, bounds-checked collections, effects/capabilities and an explicit unsafe boundary. The toolchain includes audit and safety-certificate commands so projects can make those boundaries visible in CI.

./nexus audit src/main.nx --deny-unsafe --deny-extern
./nexus safety-cert src/main.nx --strict -o safety.json
./nexus compare-safety --json

Owned resources registered in a lexical cleanup scope are released when that scope exits; explicit drop is idempotent, and defer is block-scoped/LIFO. This is still an evolving systems memory model rather than a claim of complete path-sensitive destruction/unwind analysis.

Hosted development plus native Frames output

./nexus build src/main.nx --target frames-x64 -O3 -o Hello.fex
./nexus inspect Hello.fex
./nexus targets --json
./nexus abi --json

NexusABI/1 fixes scalar widths, defines explicit extern "C" boundaries for hosted FFI, avoids C++ name mangling at that boundary and records versioned build receipts. Native Frames programs use the Frames ABI rather than pretending to be Linux applications.

Native file identity

Extensions are dispatch/presentation metadata; Frames still validates the binary/container metadata and integrity before granting execution or trust.

Build a verified application bundle

./nexus build src/main.nx --target frames-x64 -O3 -o HelloFrames.fex
./nexus keygen -o publisher.key --publisher "Example Developer"
./nexus package . --kind app --locked --sign-key publisher.key -o HelloFrames.fapp
./nexus inspect HelloFrames.fapp --require-signed --trust-key publisher.key

Frames application/setup/package containers use deterministic bundle contracts with a manifest and integrity data. The SDK also exercises Ed25519 publisher signing, trust and tamper-rejection paths. A signature proves publisher-key possession/trust policy; it does not automatically grant application capabilities.

Port incrementally instead of rewriting everything first.

Hosted C ABI import

extern "C" fn puts(s: str) -> i32;

fn main() -> i32 {
    puts("Hello through the C ABI");
    return 0;
}

Generate bindings / exports / bridge

./nexus bindgen-c library.h -o library_bindings.nx --module library_bindings
./nexus export-c src/api.nx -o include/api.h
./nexus cxx-bridge library.hpp -o build/bridge --compile

The bindgen intentionally supports a conservative C prototype subset and skips unsupported declarations rather than guessing. Native Frames external-symbol relocation/dynamic FFI is not yet part of the current native contract.

Concurrency is part of the language/tooling model.

The hosted profile includes structured tasks, async/await, channels, atomics and effect/capability contracts. Safety checks are intended to reject selected invalid ownership/borrowing/concurrency patterns before execution.

async fn work(seed: i64) -> i64 effects() {
    return seed * 2;
}

fn main() -> i32 effects(io, task, panic) {
    let a = work(21);
    let value = await a;
    print(value);
    return 0;
}

These broader hosted capabilities should not be assumed to have complete parity on every native Frames backend yet.

Developer tooling ships with the language.

./nexus debug-build src/main.nx -o build/app-debug
./nexus ide-info src/main.nx --json
./nexus profile src/main.nx -n 5 --json
./nexus explain NX3005
./nexus doctor

SDK self-tests cover structured diagnostics, debug/profile/IDE tooling and the language-server-oriented information path. JSON diagnostic/report modes are intended for editors, CI and build systems as well as terminal use.

The Nexus 6.10.0 command surface

The following list mirrors the packaged nexus --help command surface.

Core workflow

Project, package & integrity

Platform & diagnostics

Safety, interop & performance

Kernel/native tooling

Strict freestanding FKRN64 tooling

./nexus kernel check examples/frames_kernel/kernel.nx
./nexus kernel build examples/frames_kernel/kernel.nx -o FramesKernel.fkrn
./nexus kernel inspect FramesKernel.fkrn

The x86-64 kernel profile emits FKRN64/1 and enforces freestanding restrictions. Hosted allocation, normal hosted printing and async facilities are rejected in kernel-profile code. The SDK also carries Frames Kernel ABI and FKRN format documentation in the reference library below.

Make performance and safety claims reproducible.

./nexus verify-sdk
./nexus claim-check -n 3 -o claim.json
./nexus compare-cpp benchmarks/cpp-compare/loop.nx benchmarks/cpp-compare/loop.cpp -O3 -n 5 --json
./nexus compare-build benchmarks/cpp-compare/loop.nx benchmarks/cpp-compare/loop.cpp -n 5 --json
./tools/test-sdk.sh

In the checked local eight-workload C++ corpus, the Nexus/C++ median-runtime geometric mean is approximately 0.732 and the worst individual workload ratio approximately 1.127; the configured gates pass. This is a scoped result for the tested Linux x86-64 host/corpus—not a claim that every Nexus program is faster than every C++ program.

The external certification foundation produces NexusExternalCertificationLane/1 records and a NexusExternalCertificationAggregate/1 result. All required lanes must point to the same canonical tree hash.

Bundled detailed documentation

The website package preserves the SDK's source documentation alongside this integrated guide.

What Nexus 6.10.0 does not claim

• Complete feature parity between the hosted reference backend and native Frames backends.
• LLVM-class production optimizer breadth or universal C++ performance superiority.
• Native Frames dynamic/external symbol linking for arbitrary C/C++ libraries.
• A production remote package registry/downloader.
• Production RISC-V or WebAssembly targets.
• A fully self-hosted Nexus compiler.
• External GitHub x64/ARM64 matrix certification until those real runner artifacts pass the aggregate gate.