Programs.
As values.
Noble is a statically typed concatenative language that compiles to WebAssembly. Programs are immutable values: you can build them, combine them, inspect their structure, and run them. Each program carries its input and output types, the host effects it may request, and a recipe describing its composition.
Noble is under active development. The core compiler and runtime work within defined, bounded profiles; the language and interfaces are not stable. See what works today for the current scope.
40 2 quote [ + ] compose runREADME example. A successful run reports one I64 value of 42.
From the README. Wording unchanged.
Programs as values
Operations run from left to right on a typed stack. Literals push values;
words consume values and produce results. For example, 40 2 + leaves 42.
Putting code in brackets creates a program without executing its body:
40 2 quote [ + ] compose run
This also leaves 42, but builds the operation as a value first:
| Step | What happens |
|---|---|
40 2 | Push two integers. |
quote | Capture 2 in a program that pushes it when run. |
[ + ] | Construct a program that adds two integers. |
compose | Combine the two programs: push the captured 2, then add. |
run | Execute that program with 40 already on the stack. |
Composition checks that the programs' stack interfaces fit together. Captured
values and resolved definitions stay attached to the resulting program.
reflect exposes its normalized recipe as inert Syntax data; inspecting a
program does not execute its effects.
The design centers on a few properties:
- Typed composition. The frontend infers stack types and effects. An independent kernel checks the candidate, and the backend rechecks it before emitting Wasm.
- Stable meaning. Rebinding a name does not change programs that already refer to its previous definition.
- Explicit effects and ownership. Effect bounds describe possible host requests. Host authorization is separate; supported component profiles track ownership and transfer of host resources.
- Optional behavioral proofs. Contracts can describe a program's behavior and be checked using Lean. Ordinary execution does not require a proof.
Excerpt from the language specification. Wording unchanged.
A.1 Construction is not invocation
41 [ 1 + ]
The resulting stack contains 41 and a program requiring an integer input. No addition has run. Appending run yields 42.
[ "audit" test.emit ] drop
In a test environment declaring test.emit : Text -- ! {test.emit}, the quotation is checked and discarded without issuing the event. The declaration being available is distinct from executing its body.
A.2 Composition order
20 [ 1 + ] [ 2 * ] compose run
This yields 42. Reversing the two programs yields 41 for input 20, demonstrating that composition is ordered even though effect summaries use set union.
A bounded core.
Ordinary run and session use the resource-free Core-Bootstrap profile. Their host words are test.emit and test.abort. Resources and component features use separate entry points.
Recursive definitions, local bindings, general libraries and capability modules, portable package identities, and general distributed services remain open. Application contracts are optional. Model proofs do not establish compiler implementation refinement.
Scope table from the README · Core-Bootstrap contract · No browser playground