← All posts
October 23, 2026 · Release

Open Programs: programs that stay open to change

v3.0.0Language Design

Nexa 3.0 makes goals, implementations, evidence and revisions part of one persistent program. People and models can write the same typed contract; the compiler can ask for clarification, propose an implementation and check whether it satisfies that contract.

Nexa 3.0.0 is available. Get the wheel, source distribution and checksums, or start with the usage guide. Python 3.10+ and Linux/macOS are supported; candidate execution requires Docker/OCI.

A goal can remain open until an implementation is accepted

language "3.0"
program Answer {
    goal answer() -> Int {
        intent "Return the number 42"
        ensure checks.answer
        implementation open
    }
}

The environment binds checks.answer to a frozen check. A configured model proposes the implementation; OCI execution and separate acceptance records determine whether the program can use it. Offline checking and locked artifact replay make zero model requests.

Completion has conditions

Evidence records bind a candidate to its inputs, policy, checker and environment. A later failure prevents an older success from authorizing work. Changes create new revisions; active operations remain pinned until a checkpoint permits the next version.

Repository maintenance produces an exact patch. Applying it requires a grant for that patch and baseline. A write-ahead journal and retained original files preserve concurrent edits and support recovery.

Reuse includes provenance and verification

Local implementation capsules carry their source, license, dependencies and evidence. Receiving tasks check the conditions and verify the candidate under their current inputs. Explicit source implementations retain priority over reused candidates.

The compiler can participate in its own improvement

A model-generated diagnostic advice pass is evaluated against a frozen external suite. Locked bootstrap constructs C1 and C2 and compares their artifacts and outputs. An exact approval selects the candidate. This establishes the first small, testable step toward an evolving compiler.

The Python reference implementation includes the author protocol, CLI, migration tools, a six-stage maintenance demonstration and reproducible synthetic experiments. The tested Aliyun six-stage run used 11 requests. A 360-stage synthetic matrix records outcomes, failures and token totals, including a corrected baseline output contract. Read the complete experiment report.

Install and migrate

python -m pip install https://github.com/Nexa-Language/Nexa/releases/download/v3.0.0/nexa_lang-3.0.0-py3-none-any.whl
nexa --version

The PyPI name nexa-lang belongs to another project. Use this release URL. Existing 2.4 source retains its compiler path; language "3.0" selects Open Programs. Legacy checkpoints export to an inert archive, preserving unresolved effects for reconciliation. See the migration guide.

The first 3.0 implementation focuses on local repository maintenance. Candidates execute offline Python in OCI; the compiler owns model requests. The Rust AVM retains its 2.4 subset, and compiler bootstrap covers the diagnostic advice pass. External author clients can use the versioned protocol.