Build your first system#

Install a signed One release archive, keep distribution/ beside the executable, then run the same lifecycle used by every One application:

one init hello
cd hello
one setup
one check
one test
one invoke say-hello request.json

one init creates canonical .one source, a small one.one, exact one.lock, and application-owned test data. The generated source declares a greeting contract, root, native One implementation, and no hidden Cargo project.

The entry file is One source too. It contains exactly one project declaration:

one 1

semantic hello.one
    domain one.project@1
    project Hello@1
        source ./one/hello.one
        lock ./one.lock

The one.project@1 declaration establishes project scope; the selected one/hello.one supplies the contracts, system declaration, root, and implementation claim. one.one cannot select itself as source, and neither declaration is a lock, plan, artifact, or runtime binding.

one setup applies the reversible standard local configuration. It prints every provider package, configuration, selection constraint, and protected store it owns. Repeating setup is idempotent and preserves unrelated execution bindings.

one check resolves the exact lock and verifies the selected semantic and implementation closure without executing it. one test runs the root's authored scenario through the same schema and operation contracts. one invoke accepts a positional JSON request only after the checked interface proves its schema.

Build and release the same root locally:

one plan
one build
one observe local
one release local build:sha256:<build-digest>
one approve plan:<PlanId>
one apply plan:<PlanId>
one inspect operation:<OperationId>

The project plan selects an exact implementation and provider closure without mutation. Build consumes that selection without choosing again, and its reference resolves through the workspace CAS. Pass that exact Build reference to release, which commits the exact Build, provider configuration, observations, and Authority coordinates into an apply plan but stops before mutation. Approval remains distinct. Apply journals intent before dispatch; one reconcile operation:<OperationId> resumes the same operation after interruption without blind redispatch.

Inspect the persistent loopback service without creating authority:

one inspect health
one inspect logs

Export a directly consumable client from the exact Build:

one export client typescript build:sha256:…
one export client rust build:sha256:…

Each export prints package identity, artifact digest, projection receipt, archive path, and installation command.

Every displayed digest resolves to a complete owner record. Keep the project, lock, plan, Build report, release operation, and observations when you need the release to remain independently explainable or reproducible.

You have followed One's ordinary path:

declare -> check -> test -> invoke -> plan -> build -> apply -> inspect

Starting from existing software? Follow adopt an existing project. Otherwise, continue to the One mental model, then the .one source language.