Skip to main content
Kairo is a programming language and platform designed from the ground up for business software. Most languages were built for systems programming, academic research, or general-purpose scripting, then adapted to business domains as an afterthought. Kairo takes the opposite approach: it treats business concepts like identity, value types, contracts, and domain boundaries as first-class citizens of the language itself. The result is code that reads like your domain, scales with your teams, and stays maintainable over time.

​
Why Kairo Exists

Kairo prioritizes clarity, predictability, and safe defaults over cleverness, hidden behavior, or fragile freedom. It models real-world domains cleanly using object-oriented structure where identity, lifecycle, and collaboration matter, and value-oriented design where correctness, immutability, and simplicity matter more. Developer productivity is treated as a full-stack concern across the language, build system, runtime, IDE, and first-party platform layers, while the core language stays portable across supported targets.

​
Design Principles

Kairo is built on seven non-negotiable design principles that shape every language, tooling, and runtime decision.

Clarity over cleverness

Code must optimize for fast human understanding, not terseness or trick syntax.

Predictability over magic

Behavior must be consistent, transparent, and explainable without insider knowledge.

Visible control flow

Control transfer, scheduling, retries, mutation, and I/O must be visible in code.

Business-domain-first

Kairo feels natural for APIs, services, workflows, validation, and integrations.

Safe defaults

The default path prevents common mistakes; explicit opt-in for advanced behavior.

Values and objects

Values model facts; objects model entities. Composition over inheritance.
The seventh principle, progressive power on a portable core, means beginners succeed with a small mental model while professionals scale systems without switching dialects.

​
Values and Objects

Kairo distinguishes values from objects by semantics, not by cosmetic syntax. A value is a type whose meaning is defined entirely by its content. Values are compared by content, typically immutable, and have no meaningful identity beyond their state. Numbers, booleans, dates, money amounts, coordinates, and DTOs are values. An object is a type whose meaning includes identity, lifecycle, mutable state, or resource ownership. Objects are compared by identity, may be mutable, and may collaborate with other objects. Domain entities, sessions, repositories, services, and connections are objects. The normative rule is simple: values model facts, objects model entities and participants. If two instances with identical contents represent the same thing, model them as a value. If “which instance is this?” matters, model it as an object.

​
Where Kairo Fits

Kairo is designed for:
  • Backend services and APIs
  • Line-of-business applications
  • Workflow and process automation
  • Data-centric business systems with validation, policy, and rule evaluation
  • Integration services connecting databases, queues, SaaS platforms, and internal systems
  • Cross-platform internal tools and business desktop applications
  • Large team-maintained codebases where readability and correctness matter over time
Kairo is not the right tool for operating systems, kernels, hard real-time systems, browser-first UI frameworks, or ultra-low-level systems programming.

​
The Astra Kairo Platform

Kairo ships as part of the Astra Kairo platform:

Kairo

The language itself: syntax, types, and semantics.

Forge

The compiler and build engine that owns language meaning.

Pulse

The runtime that executes compiled Kairo applications.

Studio

The official IDE with editing, diagnostics, and debugging.

​
Next Steps

Quickstart

Build and run your first Kairo application in a few steps.

Installation

Install the Astra Kairo SDK on your machine.