Kairo Command Catalog: Every Language Construct Explained

This page is the practical, developer-focused reference for every command, keyword, and construct in Kairo v0.1. Each entry explains what the construct does, how it works, its exact syntax, what you need to have in place, and a runnable example. Use it as a scannable lookup while writing code.

Kairo is pre-production. Constructs marked Version Added: 0.1.0.0 belong to the planned v0.1 baseline. Some are reserved for future work and are called out explicitly.

How to read an entry. Every command lists its category, syntax, whether it introduces shared mutable runtime behavior (Thread-Safe), what it depends on, and a short worked example. Command Number / OpCode values are internal documentation references only, not bytecode or ABI commitments.

Index

Command	Category	OpCode
`module`	Project Structure	`0x0101`
`import`	Project Structure	`0x0102`
`import ... as`	Project Structure	`0x0103`
`import type`	Project Structure	`0x0104`
`.ak` source file	File Structure	`0x0105`
`kairo.toml`	Package Manifest	`0x0106`
`public`	Visibility	`0x0201`
`internal`	Visibility	`0x0202`
`private`	Visibility	`0x0203`
`value`	Type Declaration	`0x0301`
`object`	Type Declaration	`0x0302`
`contract`	Type Declaration	`0x0303`
Contract conformance `:`	Type Declaration	`0x0304`
`enum`	Type Declaration	`0x0305`
Member field	Members	`0x0401`
Computed property	Members	`0x0402`
`func`	Callable	`0x0501`
Instance method	Callable	`0x0502`
`type func`	Callable	`0x0503`
`init`	Construction	`0x0504`
`let`	Local Binding	`0x0601`
`var`	Local Binding / Mutation	`0x0602`
`this`	Receiver	`0x0603`
`return`	Control Flow	`0x0701`
`if / else`	Control Flow	`0x0702`
`match`	Control Flow	`0x0703`
`for`	Control Flow (reserved)	`0x0704`
`while`	Control Flow (reserved)	`0x0705`
`async func`	Async	`0x0801`
`await`	Async	`0x0802`
Nullable type `T?`	Type System	`0x0901`
`null`	Literal	`0x0902`
`true` / `false`	Literal	`0x0903`
`Text` literal	Literal / Core Type	`0x0904`
Numeric literal	Literal / Core Type	`0x0905`
Boolean operators	Operators	`0x0A01`
Equality operators	Operators	`0x0A02`
Comparison operators	Operators	`0x0A03`
Arithmetic operators	Operators	`0x0A04`
Assignment `=`	Operators	`0x0A05`
Value construction	Construction	`0x0B01`
Object construction	Construction	`0x0B02`
`Result<T, E>`	Error Handling	`0x0C01`
`Result.success`	Error Handling	`0x0C02`
`Result.failure`	Error Handling	`0x0C03`
Result inspection	Error Handling	`0x0C04`
`List<T>`	Collections	`0x0D01`
`Set<T>`	Collections	`0x0D02`
`Map<K, V>`	Collections	`0x0D03`
Generic type parameter	Generics	`0x0E01`
Generic contract constraint	Generics	`0x0E02`
Application entrypoint	Runtime	`0x0F01`
`Pulse.Console.out.write`	Runtime Service	`0x0F02`
`Pulse.Console.out.writeLine`	Runtime Service	`0x0F03`
`Pulse.Console.error.write`	Runtime Service	`0x0F04`
`Pulse.Console.error.writeLine`	Runtime Service	`0x0F05`

Project Structure

module — declare the module a file belongs to

Syntax: module PascalCase.DotSeparated.NameWhat it does. Declares the logical module a Kairo source file belongs to. The module declaration is authoritative. File paths should align with module names, but paths do not define language meaning.How it works. Each .ak file has exactly one module declaration and it must appear before any imports or declarations. Module names use PascalCase dot-separated segments such as Astra.Customers.Models.Prerequisites. Must be the first non-comment line in the file. Forge validates the declaration.Thread-safe: Yes.

module Sales.Orders

Treat the module declaration as the source of truth. Studio and Forge may warn when paths look messy, but they never guess a module from folder layout.

import — bring a module into scope

Syntax: import Module.NameWhat it does. Makes another module’s public surface available to the current file.How it works. import Astra.UIX imports the module Astra.UIX. Kairo intentionally has no wildcard imports and does not guess whether the final segment is a type. Imports must appear after module and before declarations.Prerequisites. The referenced module must resolve through Forge dependency metadata.Thread-safe: Yes.

module Demo.App

import Astra.Data
import Pulse.Console

import ... as — import a module under a local alias

Syntax: import Module.Name as AliasWhat it does. Imports a module and gives it a local alias for readability. The alias is a naming convenience, not a new module identity.How it works. The alias must be unique inside the file’s import scope. All references in the file then use the alias.Thread-safe: Yes.

module Demo.App

import Astra.Net.Http as Http

import type — import a specific type explicitly

Syntax: import type Module.TypeNameWhat it does. Imports one specific type from a module, disambiguating between module names and type names.How it works. Use import type when the code depends on a single type rather than the whole module. Forge validates that the target resolves to a type when metadata is available.Thread-safe: Yes.

module Demo.App

import type Astra.Data.Database

File Structure & Manifest

.ak source file

Syntax: *.akWhat it does. Kairo source files use the .ak extension. They are the input Forge compiles.How it works. Standard packages place source under src/ and tests under tests/. Every .ak file must belong to a package with a kairo.toml.Thread-safe: Yes.

module Demo.App

public func main(): Int32 {
    return 0
}

kairo.toml — the package manifest

Syntax: kairo.toml at the package root.What it does. Declares package identity, kind, version, dependencies, and runtime settings. It is the manifest truth for package-level metadata.How it works. Forge reads kairo.toml to produce the build plan, lock file, and artifacts. Dependency source selection lives in external Forge configuration, not the ordinary manifest.Thread-safe: Yes.

[package]
name = "Demo.App"
version = "0.1.0.0"
kind = "application"

[application]
entry = "Demo.App.main"

[runtime]
target = "pulse"

Visibility

public — visible outside the package

Syntax: public declarationWhat it does. Marks a declaration as part of the package’s public API.How it works. Public API must be explicit in Kairo. Anything not marked public (or private) defaults to internal.Thread-safe: Yes.

public value CustomerId {
    value: Text
}

internal — visible inside the same package

Syntax: internal declarationWhat it does. Restricts a declaration to the current package. This is the default visibility.How it works. Other packages cannot see internal declarations even after importing the module.Thread-safe: Yes.

internal value CustomerDraft {
    name: Text
    email: Text
}

private — visible only to the declaring type or file

Syntax: private declarationWhat it does. Restricts a declaration to its declaring type or file scope, depending on where it appears.How it works. Inside a type, private restricts to that type. At file scope, it restricts to the file. protected, friend, sealed, abstract, and partial are deferred from v0.1.Thread-safe: Yes.

public object Customer {
    public var name: Text

    private func validateName(name: Text): Bool {
        return name != ""
    }
}

Type Declarations

value — declare a value type

Syntax: value Name { member: Type }What it does. Declares a value type. Values model facts (identifiers, measurements, dates, amounts, small domain facts) and are immutable by default.How it works. Value members may only store value-like types in v0.1. Values are compared by content, not identity.Thread-safe: Yes.

public value Money {
    amount: Decimal
    currency: Text
}

Use value when identity and mutation are not part of the concept. If the thing participates in workflows and changes over time, model it as an object.

object — declare an identity-bearing type

Syntax: object Name { members init(...) { ... } }What it does. Declares an object type. Objects model participants, entities, workflows, and stateful concepts.How it works. Required immutable members must be assigned during init. Object methods can mutate var members. Object methods are not thread-safe when mutating state.Thread-safe: No.

public object Customer {
    public id: CustomerId
    public var name: Text

    public init(id: CustomerId, name: Text) {
        this.id = id
        this.name = name
    }
}

contract — declare a required capability

Syntax: contract Name { requirements }What it does. Declares a capability that a value or object can promise to provide.How it works. Contracts may require methods, read-only properties, and read-write properties. They cannot declare stored fields, init blocks, type functions, or method bodies in v0.1.Thread-safe: Yes.

public contract Named {
    name: Text
}

Contracts describe what a type provides, not how it stores or implements it.

Contract conformance : — declare that a type satisfies contracts

Syntax: object Name : ContractA, ContractB { ... }What it does. Declares that a value or object explicitly conforms to one or more contracts.How it works. Forge verifies that required properties and methods are present. Enum conformance, default implementations, and generic contract conformance are deferred.Thread-safe: Yes.

public contract Named {
    name: Text
}

public object Customer : Named {
    public id: CustomerId
    public var name: Text

    public init(id: CustomerId, name: Text) {
        this.id = id
        this.name = name
    }
}

enum — declare a closed set of named cases

Syntax: enum Name { CaseA CaseB }What it does. Declares a finite set of named values. Enums are useful for status, category, mode, and workflow state.How it works. Case names must be unique. Enums are typically used with match for exhaustive branching.Thread-safe: Yes.

public enum OrderStatus {
    Draft
    Submitted
    Paid
    Cancelled
}

Members

Member field — stored data on a value or object

Syntax: name: Type or var name: TypeWhat it does. Declares data stored on a value or object.How it works. Members are immutable by default. Use var only when the member must be mutable. Value members must be value-like.Thread-safe: Immutable member name: Type is thread-safe. var name: Type is not.

public object Customer {
    public id: CustomerId
    public var name: Text
}

Computed property — get/set on a synthesized member

Syntax: name: Type { get { ... } set(value: Type) { ... } }What it does. Declares an explicit computed property. Kairo does not hide getter/setter generation behind shorthand.How it works. get returns the property value; set receives an input matching the property type. Read-only properties omit set.Thread-safe: No.

public object Customer {
    public var firstName: Text
    public var lastName: Text

    public fullName: Text {
        get {
            return firstName + " " + lastName
        }
    }
}

Callables

func — declare a function or method

Syntax: func name(parameter: Type): ReturnType { ... }What it does. Declares a function. At module level it is a free function. Inside a value, object, or contract, it is an instance method or requirement.How it works. Parameter and return types must resolve. Omitting the return type means the function returns no value.Thread-safe: Yes for the declaration itself.

public func calculateTotal(order: Order): Money {
    return order.total
}

Instance method — behavior owned by a type instance

Syntax: func methodName(parameter: Type): ReturnType { ... } declared inside a type.What it does. Declares behavior owned by an instance of a value, object, or contract.How it works. Value methods receive an immutable value receiver. Object methods receive an identity-bearing receiver and may mutate var members.Thread-safe: Value methods yes; object methods no when mutating state.

public object Customer {
    public var name: Text

    public func rename(newName: Text) {
        this.name = newName
    }
}

type func — declare a type-owned function

Syntax: type func name(parameter: Type): ReturnType { ... }What it does. Declares a function owned by the type rather than an instance. There is no this receiver, and it is called through the type name.How it works. type func must be declared inside a value or object. It is Kairo’s replacement for static in v0.1.Thread-safe: Yes.

public value EmailAddress {
    value: Text

    public type func create(value: Text): EmailAddress {
        return EmailAddress {
            value: value
        }
    }
}

Use type func for named factories and type-owned helpers.

init — initialize an object

Syntax: init(parameter: Type) { ... }What it does. Initializes an object. Required immutable members must be assigned before init completes.How it works. Only allowed inside object. Exactly one primary init is allowed in v0.1. init cannot return a value. Constructor overloading, delegation, and lifecycle hooks are deferred.Thread-safe: No.

public object Customer {
    public id: CustomerId
    public var name: Text

    public init(id: CustomerId, name: Text) {
        this.id = id
        this.name = name
    }
}

Bindings & Receiver

let — declare an immutable local binding

Syntax: let name: Type = expressionWhat it does. Declares an immutable local binding.How it works. Kairo supports local let inference when the initializer type is obvious. Once bound, a let cannot be reassigned.Thread-safe: Yes.

let name: Text = "Pete"
let active = true

var — declare a mutable binding or member

Syntax: var name: Type = expressionWhat it does. Declares a mutable local binding or mutable member.How it works. Mutability is explicit in Kairo. Local var requires an explicit type in v0.1.Thread-safe: No.

var count: Int32 = 0
count = count + 1

this — the current instance receiver

Syntax: this.memberWhat it does. References the current value or object instance.How it works. Available only inside instance methods and object init. Not available in free functions or type func.Thread-safe: No.

public func rename(newName: Text) {
    this.name = newName
}

Control Flow

return — exit the current callable

Syntax: return expression or returnWhat it does. Exits the current function or method, optionally with a value.How it works. The returned expression must be assignment-compatible with the declared return type. Functions with no declared return type must not return a value.Thread-safe: Yes.

public func answer(): Int32 {
    return 42
}

if / else — branch on a boolean condition

Syntax: if condition { ... } else { ... }What it does. Executes a branch based on a boolean condition.How it works. Kairo has no truthy or falsy conversions. The condition must be Bool.Thread-safe: Yes.

if customer.name == "" {
    return 1
} else {
    return 0
}

match — branch on patterns

Syntax: match expression { Pattern => value else => fallback }What it does. Branches based on patterns. Supports both statement and expression form.How it works. Statement matches use block arms. Expression matches use arrow arms and must be exhaustive with else in v0.1. Supported patterns are literals, enum cases, null, type names, and else. Destructuring and guards are deferred.Thread-safe: Yes.

let label: Text = match status {
    Draft => "Draft"
    Submitted => "Submitted"
    Paid => "Paid"
    else => "Unknown"
}

match status {
    Draft {
        Pulse.Console.out.writeLine("Draft")
    }

    else {
        Pulse.Console.out.writeLine("Other")
    }
}

Use match when the code is choosing between named domain states, especially enums and nullable outcomes.

for — reserved keyword (deferred)

Status: Reserved in 0.1.0.0; executable semantics deferred.What it does. for is part of the frozen keyword vocabulary, but v0.1 loop semantics are not ratified. It should not be used as executable syntax yet.

// for loop syntax is reserved for a later ratified stage.

while — reserved keyword (deferred)

Status: Reserved in 0.1.0.0; executable semantics deferred.What it does. while is reserved, but production loop semantics are not yet part of the v0.1 executable subset.

// while loop syntax is reserved for a later ratified stage.

Async

async func — declare a suspendable callable

Syntax: async func name(...): ReturnType { ... }What it does. Marks a function or method that may suspend. Kairo requires suspension capability to be visible in the signature.How it works. async may appear on module functions, instance methods, type functions, and contract method requirements. It is rejected on init and type declarations. The language shape is stable in v0.1; the async runtime is deferred.Thread-safe: Yes.

public async func fetchCustomer(id: CustomerId): Customer {
    return await CustomerApi.get(id)
}

await — mark the suspension point

Syntax: await asyncCall(...)What it does. Marks the visible suspension point at the call site.How it works. Only valid inside async func. await waits for async work; it does not unwrap Result<T, E> and does not create hidden background execution.Thread-safe: Yes.

let customer = await fetchCustomer(customerId)

Type System & Literals

Nullable type T? — an optional form of a type

Syntax: Type?What it does. Represents either a value of type T or null.How it works. Only single-level nullability is supported in v0.1; nested forms like T?? are not allowed. Inside a value, CustomerId? is allowed when CustomerId is value-like. Customer? is not allowed as a stored value member when Customer is an object.Thread-safe: Yes.

public func findCustomer(id: CustomerId): Customer? {
    return null
}

null — absence for a nullable target

Syntax: nullWhat it does. Represents absence for nullable types.How it works. null cannot be assigned to non-nullable types. It is matched against nullable targets with match.Thread-safe: Yes.

let label: Text = match email {
    null => "No email"
    else => "Has email"
}

true / false — boolean literals

Syntax: true, falseWhat it does. The two Bool literals.How it works. Kairo has no truthy or falsy values. Boolean contexts require Bool.Thread-safe: Yes.

let active: Bool = true

Text literal — a string of characters

Syntax: "text"What it does. Creates a Text value. Kairo uses Text rather than String for the core textual type.How it works. The string must be terminated.Thread-safe: Yes.

let message: Text = "Customer updated"

Numeric literal — integer and fractional numbers

Syntax: 123, 123.45What it does. Represents numeric values with business-safe defaults: integer literals default to Int64, fractional literals default to Decimal, and Float64 requires explicit typing or conversion.How it works. Overflow is a compile-time error when the literal does not fit the target type.Thread-safe: Yes.

let count: Int64 = 100
let price: Decimal = 125.50

Operators

Boolean operators — not, and, or

Syntax: not expression, left and right, left or rightWhat it does. Performs boolean negation and combination.How it works. Operands must be Bool. Kairo uses readable operator words rather than symbols for boolean logic.Thread-safe: Yes.

if not isValid or hasExpired {
    return false
}

Equality operators — == and !=

Syntax: left == right, left != rightWhat it does. Compares two compatible values for equality or inequality.How it works. Operand types must be compatible. Custom equality rules are not part of the early executable subset.Thread-safe: Yes.

if status == Paid {
    return true
}

Comparison operators — <, <=, >, >=

Syntax: left < right, left <= right, left > right, left >= rightWhat it does. Compares ordered values such as numeric values and supported comparable core types.How it works. Operands must be compatible. Kairo does not perform broad implicit numeric conversions.Thread-safe: Yes.

if total > 0 {
    return true
}

Arithmetic operators — +, -, *, /

Syntax: left + right, left - right, left * right, left / rightWhat it does. Performs basic arithmetic for compatible numeric types. + also supports Text concatenation.How it works. No silent promotion across broad numeric families. Both operands must share a compatible type.Thread-safe: Yes.

let subtotal: Decimal = 100.00
let tax: Decimal = 10.00
let total: Decimal = subtotal + tax

Assignment = — write to a mutable target

Syntax: target = expressionWhat it does. Assigns a value to a mutable local or mutable member.How it works. The target must be mutable and the expression must be assignment-compatible. Immutable let bindings and immutable members cannot be reassigned outside valid construction rules.Thread-safe: No.

var count: Int32 = 0
count = count + 1

Construction

Value construction — TypeName { field: value }

Syntax: TypeName { field: value }What it does. Constructs a value using a field initialization block. Values are assembled from explicit field values.How it works. All required fields must be supplied exactly once.Thread-safe: Yes.

let total = Money {
    amount: 125.50
    currency: "AUD"
}

Object construction — TypeName(argument: value)

Syntax: TypeName(argument: value)What it does. Constructs an object through its explicit init signature.How it works. Object construction requires named arguments in v0.1. There is no hidden default constructor for objects with required members.Thread-safe: No.

let customer = Customer(
    id: customerId,
    name: "Pete"
)

Error Handling

Result<T, E> — explicit success or expected failure

Syntax: Result<SuccessType, FailureType>What it does. Represents an explicit expected outcome: either success with a T value or failure with an E value.How it works. Result<T, E> is part of the Kairo Core prelude and requires no import. The failure type E must be value-like. Unexpected runtime explosions are faults, not Result values.Thread-safe: Yes.

public func createEmail(value: Text): Result<EmailAddress, EmailFailure> {
    if value == "" {
        return Result.failure(EmailFailure.Empty)
    }

    return Result.success(EmailAddress {
        value: value
    })
}

Result.success — construct a successful Result

Syntax: Result.success(value: T): Result<T, E>What it does. Creates a successful Result value.How it works. The payload must be assignment-compatible with the expected success type. Must be contextually typed as Result<T, E> in v0.1.Thread-safe: Yes.

return Result.success(0)

Result.failure — construct a failed Result

Syntax: Result.failure(error: E): Result<T, E>What it does. Creates a failed Result value for an expected business failure.How it works. The failure payload must be value-like. Must be contextually typed as Result<T, E> in v0.1.Thread-safe: Yes.

return Result.failure(CreateCustomerFailure.InvalidName)

Result inspection — isSuccess, isFailure, value, error

Syntax: result.isSuccess, result.isFailure, result.value, result.errorWhat it does. Inspects a Result without relying on destructuring patterns.How it works. Accessing value on a failed result or error on a successful result is a runtime fault. Guard access with isSuccess first.Thread-safe: Yes.

let result = createEmail("pete@example.com")

match result.isSuccess {
    true {
        let email = result.value
        Pulse.Console.out.writeLine(email.value)
    }

    false {
        let failure = result.error
        Pulse.Console.error.writeLine("Could not create email")
    }
}

Collections

List<T> — immutable ordered collection

Syntax: List<ElementType>What it does. Represents an immutable ordered collection of T.How it works. A List<T> is value-like only when T is value-like. Immutable collections are the default collection model in v0.1.Thread-safe: Yes.

public value CustomerPage {
    ids: List<CustomerId>
}

Set<T> — immutable unique collection

Syntax: Set<ElementType>What it does. Represents an immutable collection of unique values of T.How it works. A Set<T> is value-like only when T is value-like.Thread-safe: Yes.

public value CustomerTags {
    tags: Set<Text>
}

Map<K, V> — immutable key/value collection

Syntax: Map<KeyType, ValueType>What it does. Represents an immutable map from keys to values.How it works. A Map<K, V> is value-like only when both K and V are value-like. Map<CustomerId, Customer> is not value-like when Customer is an object.Thread-safe: Yes.

public value ExchangeRates {
    rates: Map<Text, Decimal>
}

Generics

Generic type parameter — TypeName<T>

Syntax: TypeName<T>What it does. Defines or references a type parameterized by another type.How it works. Type argument arity must match the declaration. Generic values may not store unconstrained generic parameters in value members in v0.1 unless a future value-like constraint is ratified.Thread-safe: Yes.

public contract Formatter<T> {
    func format(value: T): Text
}

Generic contract constraint — T: ContractName

Syntax: T: ContractNameWhat it does. Constrains a generic parameter to types that satisfy a contract.How it works. The constraint target must resolve to a contract. Multiple constraints and non-contract constraints are deferred.Thread-safe: Yes.

public contract Displayable {
    func display(): Text
}

public contract Formatter<T: Displayable> {
    func format(value: T): Text
}

Runtime

Application entrypoint — where the app starts

Syntax: [application] entry = "Module.function" in kairo.toml, plus the matching module-level function.What it does. Defines where a Kairo application starts.How it works. The entrypoint is determined by manifest configuration, not filename guessing. main is the recommended convention, but not a hidden requirement. Supported v0.1 entry returns are Int32 and Result<Int32, E>.Thread-safe: No.

[application]
entry = "Demo.App.main"

module Demo.App

public func main(): Result<Int32, AppFailure> {
    return Result.success(42)
}

Pulse.Console.out.write — write to stdout

Syntax: Pulse.Console.out.write(value)What it does. Writes text to standard output without appending a newline.How it works. This is a runtime service call, not a language keyword and not an ambient global. Import Pulse.Console to use it. Requires an application targeting Pulse or a backend that supports the Pulse console surface.Thread-safe: No.

import Pulse.Console

public func main(): Int32 {
    Pulse.Console.out.write("Hello")
    return 0
}

Pulse.Console.out.writeLine — write a line to stdout

Syntax: Pulse.Console.out.writeLine(value)What it does. Writes a value to standard output and appends a newline.How it works. Referenced through the explicit Pulse.Console runtime service. Import Pulse.Console to use it.Thread-safe: No.

import Pulse.Console

public func main(): Int32 {
    Pulse.Console.out.writeLine("Kairo is running")
    return 0
}

Pulse.Console.error.write — write to stderr

Syntax: Pulse.Console.error.write(value)What it does. Writes a value to standard error without appending a newline.How it works. Keeps stdout and stderr routing explicit. Import Pulse.Console to use it.Thread-safe: No.

import Pulse.Console

Pulse.Console.error.write("Warning")

Pulse.Console.error.writeLine — write a line to stderr

Syntax: Pulse.Console.error.writeLine(value)What it does. Writes a value to standard error and appends a newline.How it works. Part of the Pulse runtime MVP console surface. Import Pulse.Console to use it.Thread-safe: No.

import Pulse.Console

public func main(): Int32 {
    Pulse.Console.error.writeLine("Something went wrong")
    return 1
}

Deferred Language Areas

The following language areas are intentionally not documented as production-ready commands yet:

Destructuring match patterns
Match guards
Full enum exhaustiveness enforcement
Full loop semantics for for and while
Async runtime execution and task scheduling
Fire-and-forget background work
Fault catching and recovery syntax
Constructor overloading and delegation
Extension methods
Overload resolution
Generic function inference
Multiple generic constraints
Value-like generic constraints such as T: value
Mutable collection model
Broad numeric promotion rules
Full dependency registry protocol
Studio IntelliSense and language-server behavior

Sandbox Subset

For the first public sandbox, prefer examples that stay inside the supported executable MVP subset:

Structure

module, import Pulse.Console, application entrypoint

Types

value, object, enum

Behavior

func, init, let, var

Control flow

if / else, match, Result<T, E>

Avoid sandbox examples that rely on deferred features such as loops, async execution, destructuring match patterns, or dependency registry restore.

Language syntax

The full syntax overview: files, modules, declarations, and control flow.

Type system

Values, objects, contracts, generics, and nullable types.

Error handling

Result<T, E>, expected failures, and faults.

Pulse console

Full reference for the Pulse.Console runtime service.

Language Reference

Forge CLI

Pulse Runtime

Kairo Command Catalog: Every Language Construct Explained

Index

Project Structure

File Structure & Manifest

Visibility

Type Declarations

Members

Callables

Bindings & Receiver

Control Flow

Async

Type System & Literals

Operators

Construction

Error Handling

Collections

Generics

Runtime

Deferred Language Areas

Sandbox Subset

Structure

Types

Behavior

Control flow

Language syntax

Type system

Error handling

Pulse console

​Index

​Project Structure

​File Structure & Manifest

​Visibility

​Type Declarations

​Members

​Callables

​Bindings & Receiver

​Control Flow

​Async

​Type System & Literals

​Operators

​Construction

​Error Handling

​Collections

​Generics

​Runtime

​Deferred Language Areas

​Sandbox Subset

Structure

Types

Behavior

Control flow

​Related

Language syntax

Type system

Error handling

Pulse console

Index

Project Structure

File Structure & Manifest

Visibility

Type Declarations

Members

Callables

Bindings & Receiver

Control Flow

Async

Type System & Literals

Operators

Construction

Error Handling

Collections

Generics

Runtime

Deferred Language Areas

Sandbox Subset

Related