---
title: "Known limits"
url: https://una-lang.org/en/docs/known-limits/
release: v0.4.0
source: https://github.com/una-lang/una/blob/v0.4.0/docs/guide/known-limits.md
---

# Known limits

This page lists what this release of Una does not do, or does only with limits, for a user who writes programs of edition `0.4`. Each item names the rule or record that states it; the [specification](https://github.com/una-lang/una/tree/v0.4.0/docs/spec/) is normative, and this page only points to it.

## Edition 0.4 is a preview

Edition `0.4` is named in `ita.una`, and it is a preview under the terms of ADR 0121 until a release declares it stable ([`spec/13 §7`](https://una-lang.org/en/docs/spec/13-diagnostics-and-abi/)). While it is a preview, a later release may, in a package of edition `0.4`, accept a construct that earlier releases reject, add obligations, errors and keywords, and change or remove a construct of the edition ([ADR 0121](https://github.com/una-lang/una/blob/v0.4.0/docs/adr/0121-the-terms-of-a-preview-edition.md) rule 3). A program that one release accepts gives the same result in a later release, or is rejected with a diagnostic, except for a fix of a soundness or security error and a change at a point that the construct's record declares unsettled (ADR 0121 rule 4). Each release that changes edition `0.4` lists those changes in its changelog under the heading "Edition `0.4` preview: changes that may need edits" (ADR 0121 rule 6).

## Assurance in this release

A guarantee of this release is proven, tested, trusted, assumed or human-reviewed, and these are not the same. `una report` lists the zones of a build ([README](https://github.com/una-lang/una/blob/v0.4.0/README.md#what-una-proves-trusts-and-assumes)), and the [trusted computing base](https://github.com/una-lang/una/blob/v0.4.0/docs/security/tcb.md) says, for each component, what a bug in it can cause and what guards it.

- **Proven means discharged by the checker and the solver.** The checker decides types, labels, information flow and capabilities by its rules, and the verifier encodes each contract, refinement and overflow obligation as an SMT-LIB query (`spec/12 §4`) for Z3, the solver built into `una` (ADR 0124). An obligation is proven when Z3 answers `unsat`. That proof is relative to the encoding and to the solver: no certificate checks an `unsat` answer, and the encoding is not modeled ([TCB §3.2](https://github.com/una-lang/una/blob/v0.4.0/docs/security/tcb.md#32-the-verifier-and-the-solver)).
- **`unknown` is an error.** An obligation the solver cannot decide within its step budget or its wall-clock guard is U5002, an error as a refuted one (U5001) is: nothing the solver could not prove is accepted (charter P8). A crash or a limit of the solver process is `unknown` too, never a proof, and it is never cached.
- **The formal re-check covers a fragment, and fails closed.** The Lean development in `formal/` proves type safety and noninterference for fragment F1, and a checker proven sound in Lean re-checks the Core that `una core --json` exports, declaration by declaration ([formal track status](https://github.com/una-lang/una/blob/v0.4.0/docs/plan/formal-track-status.md)). It runs in the release gate `hunt`, on the security hunt's 6,888 generated programs (`docs/release-gates.md`), and in local CI on the replay of past findings (`docs/reviews/formal-m2-replay`) and on the import tests of `formal/`. Its coverage of the conformance cases and the examples was measured by hand, last on 2026-11-06, with no committed script, and no gate repeats it ([formal track status](https://github.com/una-lang/una/blob/v0.4.0/docs/plan/formal-track-status.md)). `una check` does not run it on your package. A form outside F1 gives "not re-checked", never "accepted". Outside F1, and so not re-checked, are among others: HTTP servers, refused by name (a declaration whose Core holds a reply right, a kind of the server or an operation of `HttpServer`, ADR 0123); the collections of edition `0.5`, refused by the module `std.collections` (ADR 0119); a `checked` of a collection; `tasks` statements, `start` and `first of`; `for ever within`, whose deadline is timing; refinements, `together`, maps, JSON and `Http`. So no server and no collection of this release is proven by the formal model: their information flow is decided by the checker's rules and tested.
- **Tested, not proven.** The conformance suite, the unit and scaling tests, and the comparison of the native executable with the interpreter on the runnable programs of the suite and the examples are tests. That an executable of `una build` gives the interpreter's output, failures and trace is tested, not proven; with tasks on the real clock the order of the effects of different tasks may differ, and `--virtual-time` makes the executable follow the interpreter's schedule (`spec/27 §8` rules 3 and 4). The security hunts (`scripts/security-hunt`) generate programs and compare them with the rules and with the formal re-check: they search for defects and cannot show that there are none. Their server run (#1011: malformed requests, replies with injected headers, and the two-run oracle over servers whose handlers read labeled data) needs a test build of `una`, runs at release validation or overnight beside the release gate `hunt`, and is not a gate of its own ([release gates](https://github.com/una-lang/una/blob/v0.4.0/docs/release-gates.md)).
- **The timing oracles are statistical.** The timing channels of tasks, deadlines and servers are guarded first by the checker's labels (U4001, U4003) and by deterministic tests, such as the scheduler's test in `crates/una-rt/src/sched.rs`. On top of them, most timing oracles run, on the real clock, programs that differ only in `secret` input, 20 runs of each, and compare their times with a rank test or their outcomes run by run; positive controls vary a `public` input instead, so that the channel must show, and `serve_owner_spread` reads the placement of connections through a probe of the toolchain's test builds rather than timing (`crates/una-cli/tests/timing_channels.rs`, `spec/31 §6`). The oracles run in the timing step of local CI and in the release gate `timing-channels`, not on each change. A pass is evidence that the channel did not show at that sample size on that machine, not a proof that it is closed. Timing stays outside the verification model, as every report says.
- **Trusted and assumed.** The toolchain itself, the solver, the standard library, the host capabilities, the TLS stack, `trusted` modules and the key of the proof cache are trusted. The behavior of external systems beyond their declared signatures is assumed, and so is the secrecy of the key under which a server places its connections, with SipHash-2-4 as a pseudorandom function (`spec/31 §6`).
- **Human-reviewed.** A change to the soundness rules, the information-flow rules, the verifier's encoding or the trusted base, and a security fix, gets an adversarial review separate from its author before it merges. That requirements and contracts state the intent is for their authors and reviewers to judge.

The serve engine of this release has the limits of the [Servers](#servers) section below. This release also does not have or check the following:

- **No memory-model test of the serve threads.** Their sleep and wake protocol has no memory-model test with `loom`, and a grant's worst-case memory does not count the `rustls` buffer limits of serving connections.
- **A listener the program never serves.** A package that has a `serve:` grant, never uses `HttpServer` and has no `serve` section still binds its listener before `main`, silently and on any granted address, `0.0.0.0` included: the system completes the connection handshakes, nothing answers, and no `serving on` line is written ([Serving HTTP](https://una-lang.org/en/docs/guides/serving-http/), `spec/31 §6` rule 14). Read a package's `run grants`, or its report, before running it.
- **Coarser labels of concurrent work.** The labels are less precise than the design intends: `τ_conc` at the limiter's site and for `L_srv`, `L_res` where the reactor removes the residue, and the task-switch rule.
- **Scheduler measurements not made.** Structural placement on nested constructs is not measured, nor whether a rare 100 ms stall can happen without load.
- **No formal model of the server or of the collections.**

## Servers

These limits are those of [`spec/31`](https://una-lang.org/en/docs/spec/31-http-servers/), HTTP servers through the capability `HttpServer`.

- **Scripted connections.** `una run` and executables take `--serve-script` and `--serve-out`, but a script that is read and checked ends the run with the usage error "the scripted connections of `--serve-script` do not run in this release yet". Only the toolchain's own test builds serve a script (`spec/31 §8` rule 6).
- **`https` grants.** The TLS server, and the check that the key matches the certificate, wait for the decision on the project's TLS provider (#1059). Until then a run with an `https` grant checks its key and certificate files, then stops before `main` with a usage error, exit code 2; it never serves plain bytes on that address (`spec/31 §2` rule 8, `§6` rule 10).
- **`within` in a server.** The label `L_srv` of the serve threads joins the timing label of every `within`, `first of` and `for ever within` of a package that performs an operation of `HttpServer`. Under the preview it is computed coarsely: in a server of the language form, and in a package with a `serve` section, `L_srv` is the top label, and so is every timing site of the package (`spec/31 §1` rule 5 item 7, `§7` rule 3 item 6). So a `start ... within` in the block of a `tasks` statement, whose expression performs an operation that accepts `internal`, is refused, and a server starts its request tasks without `within`; the grant's `answer` deadline bounds what each peer waits (`spec/31 §1` rule 5 item 8). Every `within` of a `serve` section is U4003 (`spec/31 §7` rule 3 item 7). The specification lets this label become more precise in a later release, and not stricter (`spec/31 §1` rule 5 item 7).
- **No share per peer for three limits.** A grant's `waiting`, `/once` and `delivered` have no share per peer: at the defaults, about 16 well-behaved addresses can fill `waiting` ([ADR 0123](https://github.com/una-lang/una/blob/v0.4.0/docs/adr/0123-http-servers.md), amendment of 2026-11-02, decisions of the implementation, item 5; `spec/31 §2` rule 2). A request read in full when `waiting` is full is answered `503` with `Retry-After: 1` (`spec/31 §6` rule 5). The limits that do have shares make an exhaustion cost many addresses, not one, and do not remove it; an operator facing it raises the grant's limits or puts a filter in front (ADR 0123 rule 7).
- **No fuzz target for the HTTP parsers.** v0.4.0 has no fuzz target for the request reader of the serve engine, the response parser of `Http` or the chunked decoder: they are tested, not fuzzed, so their handling of malformed input from a peer has no fuzzing evidence in this release (#1883).

## Tasks and timing

These limits are those of [`spec/26`](https://una-lang.org/en/docs/spec/26-long-running-programs/) and [`spec/27`](https://una-lang.org/en/docs/spec/27-tasks-and-time/). The guide [Tasks and time](https://una-lang.org/en/docs/guides/tasks-and-time/) teaches the constructs they concern.

- **Only `Http` operations are interrupted.** In this edition the interruptible operations are those of `Http`: a request waits no longer than the earliest deadline that covers it and fails with `HttpError.TimedOut` (`spec/27 §5` rule 6). Other code inside `e within d` is canceled at its next check point, after an operation in progress completes (`spec/27 §5` rule 5). What a request sent before its deadline passed stays sent, so an interrupted request is an effect in doubt (`spec/27 §5` rule 6).
- **The residue label `L_res`.** In a program whose started tasks or races make requests, every `within` is at least `internal` (`spec/27 §5` rule 8). The failure of a `within` carries that label, and `if error pass` and `if error fail` on it are U4002 when it is above `public` (`spec/27 §5` rule 8). `L_res` also joins the label of every `first of`, every `for ever within`, every tick, the limits of grants and the statement an installation of `limiter` scopes over (`spec/26 §7` rule 5, item 6). A program pays for it only when its started tasks or its races make requests (`spec/26 §7` rule 5, item 6).
- **Code the checker does not see.** `L_res` is the top label when the package's code can reach a function of a standard module whose body holds a `tasks` statement or a `first of`, or a function of a dependency whose code the checker does not see, until issue #1166 makes these precise (`spec/26 §7` rule 5, item 6).
- **Coarse labels of concurrent work.** The statement a `limiter` scopes over and `L_srv` keep the preview's `τ_conc`: the top label for a site inside a lambda, a task, the block of a `tasks` statement or a handler's operation, in a function that a part of a task construct can reach, and, in a package with a task construct, in a function that a function value, a lambda or a handler's operation can run (`spec/27 §11`).
- **Grants with limits.** When a grant of `run grants` carries limits, `una check` reports U4001 at each `Http` site whose own label is above `internal`, and `una run` and the executable refuse a `--grant` with limits when the label of the program's requests is above `internal`, a usage error, exit code 2, before `main` starts (`spec/27 §9` rule 5). In a run where a grant carries limits, a request never parks on the reactor: it runs on a helper of the I/O pool and holds its slots until the helper returns (`spec/27 §9` rule 3).
- **Quiet tasks and the bound.** A task started in quiet code counts against the bound of its `tasks` statement, so whether a `start` under a raised program counter ran can make a later public `start` wait: an open channel (#1545, `spec/27 §7` rule 4).
- **A `Json` value has one label.** In edition 0.4 a `Json` constructor accepts labeled data and labels the whole value with the join of what entered, so a `public` field beside a `secret` one reads as `secret`; there is no label per position. In editions 0.2 and 0.3 the positions of `Json` are `public`, and a labeled value given to a constructor is U4001: a labeled text reaches JSON through a policy, or through `quote_json` and interpolation ([`spec/23 §5`](https://una-lang.org/en/docs/spec/23-json/) rule 2, #917).
- **`Clock` readings are not labeled before edition 0.4.** In editions 0.1 to 0.3, `Clock.now()` returns an `Int` of milliseconds with no label ([`spec/14 §3`](https://una-lang.org/en/docs/spec/14-standard-library/)), so a program with a `clock` grant can turn elapsed time into a public value. In edition 0.4 a reading carries the timing label of the code that ran before it (issue #898, the amendment of 2026-11-09 of [ADR 0116](https://github.com/una-lang/una/blob/v0.4.0/docs/adr/0116-long-running-programs.md)), so a program that also handles `internal` or `secret` data cannot print it; the amendment lists the ways to log or measure time that keep working.

## Editions

- **Collections and numerics are edition 0.5.** The collections of [`spec/28`](https://github.com/una-lang/una/blob/v0.4.0/docs/spec/28-collections.md) and the numeric foundation of [`spec/29`](https://una-lang.org/en/docs/spec/29-numerics/) §16 to §19 are not part of edition `0.4`: they exist only in packages of edition `0.5` ([ADR 0139](https://github.com/una-lang/una/blob/v0.4.0/docs/adr/0139-edition-numbering-follows-the-release-that-closes-it.md) rules 6 and 7, `spec/13 §7`). In a package of edition `0.4` each of them gets what edition `0.3` gives it, such as U1001 for `import std.collections` (`spec/13 §7`). `F64` and `spec/29` §1 to §15 stay in edition `0.3` (`spec/13 §7`).
- **Edition 0.5 is a preview too.** Edition `0.5` is a preview under the terms of ADR 0121 until the rules that target it have landed (`spec/13 §7`).

## Platforms

- **macOS and Linux on arm64.** The targets of 0.4.0 are `aarch64-apple-darwin` and `aarch64-unknown-linux-gnu` (`scripts/release-targets.txt`), and a release is tagged only when every gate passes on it, its Linux legs included ([release gates](https://github.com/una-lang/una/blob/v0.4.0/docs/release-gates.md)). Linux on x86-64 is not a target: its evidence needs a native x86-64 Linux machine (ADR 0124 rule 31, #1442). Windows is not supported. The installer refuses Linux on x86-64, a musl system, a glibc older than 2.39 and a 32-bit userland on a 64-bit kernel before any download, and as root a `UNA_HOME` or `TMPDIR` that a user other than root could change, judged by owners and mode bits only (an ACL that grants write is not seen); on any other platform it stops with "no Una release for" the platform (`install.sh`).
- **glibc 2.39 or later on Linux.** The Linux `una` is a dynamic executable against the system's glibc, from the glibc of the image it is built in, Ubuntu 24.04's 2.39, on (ADR 0124 rule 1): a system with an older glibc, such as Ubuntu 22.04 or Debian 12, cannot run it. The C++ runtime of the solver, `libstdc++` and `libgcc`, is linked into `una` statically, so it needs no C++ library of the system; beside glibc it loads only GCC's unwinder `libgcc_s.so.1`, as every Rust program for Linux on glibc does. It does not run on musl systems such as Alpine.
- **0.4.0 and later.** The installer refuses a `UNA_VERSION` before 0.4.0: such a release needs a separate Z3, which the installer no longer installs (`install.sh`).
- **`una build` and `cc`.** On macOS arm64, `una build` links with the linker built into `una` and runs no other program (ADR 0124 step 3). On Linux, `una check`, `una test` and `una run` need no other program, but `una build` links through a C compiler available as `cc` (gcc or clang, with the C library's development files), against the system's C library; without `cc` it stops with "cannot run the system linker `cc`" ([Getting started](https://una-lang.org/en/docs/get-started/), section 6).
- **Linux executables are dynamic.** An executable that `una build` writes on Linux is dynamic against the glibc of the machine that built it, and runs on the same or a newer glibc only; no static or musl executable is written yet. The Linux `una` of a release carries musl's static C library and start-up objects, checked against their digests before each link, but does not link them: its own ELF linker, which will, is not finished (ADR 0124 step 4).
- **Not as root.** The solver refuses to run as root, whose privileges no confinement removes: `una check` run as root fails with U5003, "the solver could not be confined: the solver must not run as root" (ADR 0124 rule 7). Run `una` as an ordinary user, in a container too (`docker run --user 1000:1000 ...`).
- **The solver's confinement on Linux.** The solver child confines itself with a seccomp filter before it reads the query. The filter refuses `open`, `openat` and `openat2` with `EACCES`, so that glibc, which reads the processor count again during a query, takes its fallback; `O_CREAT` is refused the same way. It kills the child at once on the dangerous calls: sockets, starting a program or another process (`execve`, `execveat`, a `clone` that does not start a thread, and on x86-64 `fork` and `vfork`), `ptrace` and reading or writing another process's memory, a signal to another process, executable memory, and on x86-64 `creat`; that ends the proof as U5003, never as a pass. Every other call it does not allow, such as `mkdirat` or `renameat`, fails with `ENOSYS` without running, and the solver goes on. Either way the child opens and creates no file (ADR 0124 rule 7, [trusted computing base](https://github.com/una-lang/una/blob/v0.4.0/docs/security/tcb.md)).
- **Foreign code inside `una`.** The `una` binary holds code not written in Rust: the Z3 solver, a C++ library (ADR 0124), which uses the system's C++ runtime on macOS (`/usr/lib/libc++.1.dylib`) and, on Linux, the GNU C++ runtime (`libstdc++`) linked into `una`, and the C and assembly of `ring`, the cryptography of the default TLS provider (ADR 0133 rule 17), which the runtime that `una build` links holds too. The [foreign code inventory](https://github.com/una-lang/una/blob/v0.4.0/docs/foreign-code-inventory.md) lists each item, where it reaches and its plan.
