Kairo Language Syntax: Modules, Imports, and Structure

Kairo source files use the .ak extension and are organized into modules. Every file declares exactly one module, followed by imports, followed by declarations. There are no hidden ordering rules, no wildcard imports, and no ambient globals.

File shape

Every .ak file follows the same structure:

module Sales.Orders

import Pulse.Console
import type Astra.Data.Database

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

Module declaration

Must be the first non-comment line. One module per file.

Imports

Zero or more import, import ... as, or import type statements.

Declarations

Types, functions, and members that make up the file’s contribution to the module.

Module declarations

The module keyword declares the logical module a file belongs to. Module names use PascalCase segments separated by dots.

module Astra.Customers.Models

The module declaration is authoritative. Studio and Forge may warn when file paths do not match module names, but paths never override the declared identity.

Rules:

Exactly one module declaration per file.
Must appear before any imports or declarations.
Segments use PascalCase; the full name uses dot separators.

Imports

Kairo has three import forms, all explicit. There are no wildcards.

Module import

import Astra.Data

Alias import

import Astra.Net.Http as Http

Type import

import type Astra.Data.Database

module Demo.App

import Pulse.Console
import Astra.Net.Http as Http
import type Astra.Data.Database

Use import type when the file only needs a specific type. It removes any ambiguity between module names and type names for Forge and for readers.

Visibility

Every declaration has a visibility. internal is the default.

Modifier	Visible to
`public`	Any package that depends on this one
`internal`	Same package only (default)
`private`	Declaring type or file scope

public value CustomerId {
    value: Text
}

internal value CustomerDraft {
    name: Text
    email: Text
}

public object Customer {
    public var name: Text

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

Comments

Kairo supports single-line comments with //. Block comments and doc comments are deferred.

// A single-line comment
let count: Int32 = 0

Identifiers and casing conventions

Kairo follows consistent casing rules so readers can tell what a name refers to at a glance.

Kind	Convention	Example
Modules	PascalCase, dot-separated	`Sales.Orders`
Types (`value`, `object`, `contract`, `enum`)	PascalCase	`Customer`, `OrderStatus`
Enum cases	PascalCase	`Draft`, `Submitted`
Functions, methods, members	camelCase	`calculateTotal`, `firstName`
Local bindings	camelCase	`let customerId = ...`

Statements and blocks

Kairo uses curly braces for all block scopes: function bodies, if/else, match arms, and type declarations. Statements do not require semicolons.

public func classify(status: OrderStatus): Text {
    if status == Draft {
        return "Not submitted"
    } else {
        return "In workflow"
    }
}

Get Started

Language

Packages & Modules

Toolchain

Ecosystem

Kairo Language Syntax: Modules, Imports, and Structure

File shape

Module declarations

Imports

Module import

Alias import

Type import

Visibility

Comments

Identifiers and casing conventions

Statements and blocks

Next steps

Type system

How Kairo Works

​File shape

​Module declarations

​Imports

Module import

Alias import

Type import

​Visibility

​Comments

​Identifiers and casing conventions

​Statements and blocks

​Next steps

Type system

How Kairo Works

File shape

Module declarations

Imports

Visibility

Comments

Identifiers and casing conventions

Statements and blocks

Next steps