# Yeho language map

Updated 2026-09-09. [Visual map](https://demonhunterlabs.com/academy/systems/yeho/map). [AI permission](https://demonhunterlabs.com/ai-use).

## Begin

Your first useful program

### [Start and run](https://demonhunterlabs.com/academy/systems/yeho/map?topic=start)

Projects, entry files, comments, separators, and the shortest path to a native program.

- [Project entry and source files](https://demonhunterlabs.com/academy/api?item=language--project-entry): A Yeho project starts in start.yh. Top-level statements are the program, so there is no ceremonial main function. (stable)
- [Comments, newlines, and semicolons](https://demonhunterlabs.com/academy/api?item=language--comments-separators): Line comments begin with //. Newlines normally separate statements, and semicolons are optional. (stable)
- [Create, run, and build](https://demonhunterlabs.com/academy/api?item=language--create-run-build): The workspace wrapper creates a project, checks it, runs it, or emits its native Windows x64 artifact. (stable)

### [Values and types](https://demonhunterlabs.com/academy/systems/yeho/map?topic=values)

Variables, assignment, literals, text, numbers, booleans, nullability, and the complete built-in type families.

- [Variables and assignment](https://demonhunterlabs.com/academy/api?item=language--variables-assignment): Types come before names. Declare with an initial value, then use = to replace the value. (stable)
- [Literals and escapes](https://demonhunterlabs.com/academy/api?item=language--literals): Yeho has text, character, integer, floating-point, boolean, and null literals with explicit escape sequences. (stable)
- [Integer, bit, float, and decimal types](https://demonhunterlabs.com/academy/api?item=language--numeric-types): Yeho exposes signed and unsigned integer widths, packed bit widths, binary floating point, and decimal families. (stable)
- [Text, char, rune, and bool](https://demonhunterlabs.com/academy/api?item=language--text-char-rune-bool): text is an owned text value, char is a character literal unit, rune represents a Unicode scalar, and bool is true or false only. (stable)
- [Nullable types](https://demonhunterlabs.com/academy/api?item=language--nullable-values): A ? suffix declares a nullable reference-like value, but the complete flow analysis is not in the Kyber product path yet. (generated-cpp-only)

### [Functions and calls](https://demonhunterlabs.com/academy/systems/yeho/map?topic=functions)

Declarations, returns, parameters, overloads, named arguments, defaults, contracts, and function values.

- [Function declarations and returns](https://demonhunterlabs.com/academy/api?item=language--functions): A function starts with its name, not a function keyword. Parameters are typed, -> names the return type, and a missing return type means void. (stable)
- [Defaults, named arguments, and overloads](https://demonhunterlabs.com/academy/api?item=language--parameters-calls): Trailing parameters can have defaults, calls can name arguments after positional ones, and functions can overload on admitted signatures. (stable)
- [Requires, ensures, and invariants](https://demonhunterlabs.com/academy/api?item=language--contracts): Contracts attach executable meaning to valid inputs, promised outputs, and valid object state. (experimental)
- [Extension functions](https://demonhunterlabs.com/academy/api?item=language--extension-functions): Mark the first parameter extension to let an ordinary function use readable value.Method(...) call syntax. (stable)
- [Function values, lambdas, and local functions](https://demonhunterlabs.com/academy/api?item=language--function-values): Yeho has reserved syntax for typed function values and function(...) lambdas, but the feature is not in the Kyber product path. (generated-cpp-only)

### [Tools and inspection](https://demonhunterlabs.com/academy/systems/yeho/map?topic=tools)

Create, check, run, build, format, test, inspect, package, and expose compiler truth.

- [Check and inspect compiler truth](https://demonhunterlabs.com/academy/api?item=language--compiler-inspection): Compiler flags expose the parsed program, semantic model, project resolution, target check, truth report, and native bridge. (stable)
- [Format, lint, test, inspect, and package](https://demonhunterlabs.com/academy/api?item=language--workspace-commands): The Yeho wrapper keeps common engineering actions under one predictable command surface. (stable)

## Shape

Give your ideas structure

### [Data and objects](https://demonhunterlabs.com/academy/systems/yeho/map?topic=data)

Things, classes, interfaces, fields, properties, visibility, inheritance, and invariants.

- [Things: plain value data](https://demonhunterlabs.com/academy/api?item=language--things): thing defines plain value-shaped data. It is Yeho's default way to name a bundle of related fields. (stable)
- [Classes and interfaces](https://demonhunterlabs.com/academy/api?item=language--classes-interfaces): class models reference identity and methods; interface defines a behavioral surface. Full dispatch remains on the comparison oracle. (generated-cpp-only)
- [Constructors, methods, static methods, and this](https://demonhunterlabs.com/academy/api?item=language--constructors-methods): A constructor is a same-name method inside a type. Instance methods can read this, while static methods belong to the type itself. (stable)
- [Fields, properties, and visibility](https://demonhunterlabs.com/academy/api?item=language--fields-properties-visibility): Members can be public, internal, protected, or private, with static, readonly, init, and get/set/init property shapes. (experimental)

### [Collections](https://demonhunterlabs.com/academy/systems/yeho/map?topic=collections)

Typed lists, maps, sets, literals, indexing, membership, and mutation.

- [Lists](https://demonhunterlabs.com/academy/api?item=language--lists): list of T is an ordered typed value container with literals, indexing, count, and explicit mutation methods. (experimental)
- [Maps](https://demonhunterlabs.com/academy/api?item=language--maps): map of K to V associates typed keys with typed values. Map literals use key to value pairs. (experimental)
- [Sets](https://demonhunterlabs.com/academy/api?item=language--sets): set of T stores unique typed values and supports membership and explicit mutation. (experimental)

### [Memory and lifetime](https://demonhunterlabs.com/academy/systems/yeho/map?topic=memory)

Ordinary values, explicit copies, original aliases, address aliases, buffers, and the unsafe boundary.

- [Ordinary, copy, original, and memoryAddress](https://demonhunterlabs.com/academy/api?item=language--binding-modes): Binding modes make value transfer and aliases visible at function and loop boundaries. (experimental)
- [Buffers](https://demonhunterlabs.com/academy/api?item=language--buffers): buffer of T is a shared resource shape used for explicit data movement and compute boundaries. (experimental)

### [Packages and native interop](https://demonhunterlabs.com/academy/systems/yeho/map?topic=packages)

Using declarations, package visibility, manifests, C ABI declarations, effects, and target boundaries.

- [Using and external declarations](https://demonhunterlabs.com/academy/api?item=language--using-external): using imports a dotted package path. external makes an eligible top-level declaration visible outside its package. (stable)
- [project.mech](https://demonhunterlabs.com/academy/api?item=language--project-manifest): project.mech declares project identity, source roots, packages, target intent, and feature gates such as tuple experiments. (stable)
- [C ABI interop](https://demonhunterlabs.com/academy/api?item=language--extern-c): extern c declares an external function with cdecl by default and optional stdcall or sysv conventions. (experimental)

## Run

Decisions, work, and time

### [Expressions and decisions](https://demonhunterlabs.com/academy/systems/yeho/map?topic=logic)

Arithmetic, comparison, boolean logic, casts, enums, flags, and exhaustive match branches.

- [Arithmetic, comparison, and bit operators](https://demonhunterlabs.com/academy/api?item=language--operators): Scalar expressions use explicit arithmetic, comparison, bitwise, shift, and unary operators with ordinary precedence. (stable)
- [Boolean logic and short-circuiting](https://demonhunterlabs.com/academy/api?item=language--boolean-logic): Use !, and, and or with bool values. and and or short-circuit, so the right side runs only when needed. (stable)
- [If, else if, and else](https://demonhunterlabs.com/academy/api?item=language--if-else): if branches on a bool expression. Parentheses around the condition are optional, and each branch uses a block. (stable)
- [Enums, payloads, and match](https://demonhunterlabs.com/academy/api?item=language--enums-match): enum names a closed set of cases. Payload cases can carry one typed value, and match selects a branch with an optional binding. (experimental)
- [Flags enums](https://demonhunterlabs.com/academy/api?item=language--flags-enums): A [flags] enum represents combinable named bits. Test membership with .Has rather than treating a combination as one match case. (experimental)
- [Type checks and casts](https://demonhunterlabs.com/academy/api?item=language--casts-type-checks): is asks whether a value has a named type; as requests a cast to that named type. (experimental)

### [Loops and iteration](https://demonhunterlabs.com/academy/systems/yeho/map?topic=loops)

While, infinite loops, range loops, collection loops, filters, indexes, and loop control.

- [While loops](https://demonhunterlabs.com/academy/api?item=language--while-loop): while repeats a block while its bool condition remains true. (stable)
- [Loop, next, and end](https://demonhunterlabs.com/academy/api?item=language--infinite-loop-control): loop creates an explicit indefinite loop. next skips to the next iteration and end exits the nearest loop. (stable)
- [Range for loops](https://demonhunterlabs.com/academy/api?item=language--range-for): A range loop names its counter, start, exclusive or inclusive end, and optional step expression. (stable)
- [Collection loops, indexes, reverse, and where](https://demonhunterlabs.com/academy/api?item=language--collection-for): for can iterate collection values, expose an index, start that index elsewhere, reverse the traversal, or filter with where. (stable)

### [Errors and contracts](https://demonhunterlabs.com/academy/systems/yeho/map?topic=errors)

Typed error values, preconditions, postconditions, invariants, and the current exception boundary.

- [Typed error values](https://demonhunterlabs.com/academy/api?item=language--error-values): error is a typed value created with Error(type, message) and exposes type and message fields. (experimental)
- [Try, catch, and throw](https://demonhunterlabs.com/academy/api?item=language--try-catch-throw): The parser models try, catch, and throw, but exception control flow is not part of the Kyber product route today. (generated-cpp-only)

### [Tasks, time, and tunnels](https://demonhunterlabs.com/academy/systems/yeho/map?topic=concurrency)

Asynchronous work, delayed starts, waits, cancellation, parallel blocks, and bounded communication.

- [Tasks and delayed work](https://demonhunterlabs.com/academy/api?item=language--tasks): task starts a named function asynchronously, can carry a typed result, and can be delayed with after. (experimental)
- [Wait, stop, and parallel](https://demonhunterlabs.com/academy/api?item=language--wait-stop-parallel): wait can pause for a duration, frame, task, or condition. stop requests cancellation, and parallel scopes concurrent branches. (experimental)
- [Tunnels](https://demonhunterlabs.com/academy/api?item=language--tunnels): tunnel carries typed values between concurrent work with capacity-one FIFO handoff and backpressure. (experimental)

## Create

Pixels, interfaces, experiments

### [CPU and GPU compute](https://demonhunterlabs.com/academy/systems/yeho/map?topic=compute)

Portable compute functions, execution tags, dispatch, buffers, indexes, completion, and restrictions.

- [Compute functions and execution tags](https://demonhunterlabs.com/academy/api?item=language--compute-functions): compute defines a portable data-parallel kernel. [auto], [cpu], or [gpu] states the admitted execution preference. (experimental)
- [Dispatch and computeTask](https://demonhunterlabs.com/academy/api?item=language--compute-dispatch): dispatch launches a compute function and returns a computeTask whose finished, failed, and error state can be inspected. (experimental)

### [YUI apps and surfaces](https://demonhunterlabs.com/academy/systems/yeho/map?topic=yui-start)

Create a native YUI project, connect its manifest, and author the first retained application surface.

- [Create and run a YUI application](https://demonhunterlabs.com/academy/api?item=language--yui-create-project): YUI is Yeho's native retained UI system. One command creates a project with Yeho behavior, a .yui interface, and a Kyber-ready Windows x64 application path. (candidate)
- [Connect a .yui entry in project.mech](https://demonhunterlabs.com/academy/api?item=language--yui-project-manifest): The project manifest declares a frontend application and points to one deterministic .yui entry document. The SDK selects Kyber, so product manifests do not name a generated-C++ backend. (candidate)
- [Surfaces, layouts, and widgets](https://demonhunterlabs.com/academy/api?item=language--yui-surfaces-layout): A surface is the root of an authored interface. Layout containers such as column, row, grid, stack, dock, overlay, and panel organize semantic widgets without turning the file into pixel-by-pixel drawing code. (candidate)

### [YUI components and controls](https://demonhunterlabs.com/academy/systems/yeho/map?topic=yui-authoring)

Typed state, commands, properties, slots, reusable components, controls, layouts, and event bindings.

- [Typed state, commands, and event bindings](https://demonhunterlabs.com/academy/api?item=language--yui-state-commands): State names the values a surface reads. Commands name actions the application can perform. Widget bindings connect them explicitly, so an event is not a hidden string callback. (candidate)
- [Reusable components, typed properties, and slots](https://demonhunterlabs.com/academy/api?item=language--yui-components-slots): A project-local component can expose required or defaulted properties and named content slots. It imports like ordinary source and needs no compiler registration or global component catalog. (candidate)
- [Controls, forms, navigation, and large data](https://demonhunterlabs.com/academy/api?item=language--yui-control-vocabulary): YUI's public widget vocabulary covers ordinary controls, forms, menus, overlays, navigation, tables, property editors, virtual lists, creator surfaces, and loading, empty, or error presentations. (candidate)

### [YUI rendering and access](https://demonhunterlabs.com/academy/systems/yeho/map?topic=yui-runtime)

The custom retained renderer, semantic accessibility tree, inspection path, performance model, and current platform boundary.

- [Retained custom rendering and exact damage](https://demonhunterlabs.com/academy/api?item=language--yui-retained-rendering): YUI owns one retained scene and renderer-neutral display commands. A mutation lowers only dirty owners, while semantic-only changes can update accessibility state without creating paint work. (candidate)
- [One semantic tree for interaction and accessibility](https://demonhunterlabs.com/academy/api?item=language--yui-accessibility-interaction): The same semantic nodes drive pointer and keyboard interaction, focus, accessible roles and names, visible state, bounds, commands, and custom rendering state. (candidate)
- [Inspect YUI truth and respect the candidate boundary](https://demonhunterlabs.com/academy/api?item=language--yui-inspection-boundary): Readable and JSON inspection expose expanded widgets, bindings, semantic nodes, layout, display commands, resources, dirty receipts, damage, provider selection, and diagnostics without mutating the application. (candidate)

### [Experiments and boundaries](https://demonhunterlabs.com/academy/systems/yeho/map?topic=boundaries)

Opt-in tuples, deprecated spellings, removed syntax, and features Yeho deliberately does not pretend to ship.

- [Tuples and deconstruction](https://demonhunterlabs.com/academy/api?item=language--tuples): Tuple values are an opt-in experiment, gated by tuple-values, and currently run only through generated C++. (generated-cpp-only)
- [Yielding functions](https://demonhunterlabs.com/academy/api?item=language--yielding-functions): yield can produce a sequence of values from one function, but the final lowering operation is deliberately rejected by Kyber today. (generated-cpp-only)
- [Planned collection mutation](https://demonhunterlabs.com/academy/api?item=language--planned-loop-mutations): plan remove, removeAt, add, and addAt describe mutations to apply around iteration without mutating the active traversal directly. (generated-cpp-only)
- [Deprecated migration spellings](https://demonhunterlabs.com/academy/api?item=language--deprecated-aliases): dobox, string, returns, and main.yh are accepted only to help older code move to the current language. (deprecated)
- [Deliberately unavailable language features](https://demonhunterlabs.com/academy/api?item=language--unavailable-syntax): Yeho Core 2026.1 explicitly does not admit generics, slices, interpolation, alternate numeric literals, compound assignment, computed properties, operator overloading, truthiness, or raw allocation/free. (unavailable)
- [Removed and reserved statement words](https://demonhunterlabs.com/academy/api?item=language--rejected-words): Several readable ideas are intentionally not source-language features yet. The compiler rejects them with a supported replacement instead of silently inventing behavior. (unavailable)