# Native One

Native One is the small executable language for semantics-shaped connective
code. Use it when an operation mainly constructs owned values, matches typed
outcomes, sequences operations, and handles effects or uncertainty already
defined by the selected semantic closure.

It is not a general-purpose replacement for Rust or ecosystem languages.
General algorithms, numerical kernels, provider SDKs, low-level concurrency,
arbitrary I/O, FFI, and library-heavy behavior belong behind an owned contract
in another exact implementation profile.

## Implement one exact operation

A Native One body remains an isolated implementation item. The header names
the claim, realized contract, and exact profile; the indented `source` suite is
untrusted executable source:

```one
impl example.hello#HelloServiceOne@1
    realizes example.hello#Greeter.SayHello@1
    using one.language.one#SafeAsync@1
    source
        async SayHello(request: HelloRequest)
        -> Result<Greeting, GreetingDomainFault>
        {
            ok(Greeting {
                message: text("Hello, ", request.name, "!")
            })
        }
```

The realized interface supplies the expected operation name, input, result,
faults, effects, and capabilities. Do not repeat it through a wrapper,
language-local service declaration, or generic entry point. Names visible in
the body come from the exact Native One projection of the locked semantic
closure, not from workspace text search.

## Understand the execution model

The `SafeAsync@1` grammar admits only bounded forms for:

- nominal value construction and field access;
- matching, sequencing, typed results, and declared faults;
- exact operation calls and selected state access;
- cancellation and unknown-outcome handling; and
- compensation and reconciliation where the contract requires them.

Semantic packages add types, operations, states, faults, effects,
capabilities, and invariants to that vocabulary; they never add grammar or
ambient runtime powers. Network, filesystem, environment, process, clock,
entropy, credentials, and state access exist only when an exact requirement,
grant, and selected host/provider boundary supplies them.

## Check before realization

```console
one check --root hello
one inspect example.hello#HelloServiceOne@1
one test --root hello
one invoke example.hello#Greeter.SayHello@1 request.json
```

Checking parses and type/effect-checks the exact logical body in a
capability-empty analyzer and retains its analysis receipt. That receipt does
not prove compilation, selection, an artifact, a runtime binding, or authority.
Planning selects an eligible realization; Build binds the exact body,
dependency closure, language definition, frontend, toolchain, target, and
artifact; invocation still requires the applicable runtime grant.

Native One can be realized as checked bytecode or as a WebAssembly Component
when the selected root and provider support that boundary. Both preserve the
same contract and evidence path; repository package presence activates neither.

Next: [add other implementation languages](/one/authoring/implementations) or
[check, test, and invoke](/one/lifecycle/check-test-invoke).