> ## Documentation Index
> Fetch the complete documentation index at: https://docs.astrakairo.dev/llms.txt
> Use this file to discover all available pages before exploring further.
# Kairo: A Modern Language Built for Business Software
> Learn what Kairo is, why it was designed, and what makes it different — a language built around clarity, predictability, and business-domain-first design.
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 — and 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.
Kairo is currently in **v0.1 preview** and under active development. Language, tooling, and platform features are being defined and refined. Join the conversation at [community.astrakairo.dev](https://community.astrakairo.dev).
## Design principles
Kairo's design is guided by seven principles that shape every decision in the language, from syntax to the standard library.
### Clarity over cleverness
Code is read far more often than it is written. Kairo favors explicit, readable constructs over terse or clever ones. When something happens in your program, you should be able to see it in the code — not infer it from conventions or framework magic.
### Predictability over magic
Kairo does not do things behind your back. There is no implicit coercion, no hidden control flow, and no ambient state. What you write is what runs.
### Visible control flow and side effects
Async operations, errors, branching, I/O, and lifecycle behavior are always visible at the call site. Control transfer, scheduling, mutation, and external interactions must be apparent in syntax, declarations, or first-class tooling — never smuggled in behind decorative APIs.
### Business-domain-first design
The language includes primitives — `value`, `object`, `contract`, `enum` — that map directly to domain-driven design concepts. You model your domain in the language itself, not on top of it.
### Safe defaults and explicit boundaries
Non-null types are the default. Visibility is `internal` unless you declare it `public`. Public APIs, package boundaries, async boundaries, and external integrations become more explicit, not less. The safe path is always the path of least resistance.
### Values for facts, objects for identity
Kairo distinguishes between **values** (immutable facts like a price or a customer ID) and **objects** (entities with identity and lifecycle). This distinction is built into the type system and encourages you to design your domain model precisely.
### Progressive power on a portable core
Kairo starts simple and grows with your needs. The core language is small and portable. Advanced features like async, generics, and interop are available when you need them — not forced on you when you don't.
## The Astra Kairo ecosystem
Kairo is part of the broader Astra Kairo platform. Each component has a focused responsibility and integrates cleanly with the rest.
| Component | Role |
| ----------- | --------------------------------------------------------------------- |
| **Kairo** | The language itself — syntax, type system, and standard library |
| **Forge** | The compiler and build system — `forge build`, `forge test`, and more |
| **Pulse** | The runtime that executes compiled Kairo applications |
| **Studio** | The official IDE with first-class Kairo support |
| **UIX** | Cross-platform UI framework for building desktop and web frontends |
| **Forms** | Declarative form engine for data-entry applications |
| **Bridge** | Interoperability layer for calling into external code and libraries |
| **Gateway** | API gateway and request routing for service-oriented architectures |
| **Net** | Networking primitives — HTTP, WebSockets, and protocol support |
| **Server** | Hosting abstractions for running Kairo services in production |
Not all platform components are available in the current v0.1 preview. The language, Forge, and Pulse are the primary focus of the initial release. Check [community.astrakairo.dev](https://community.astrakairo.dev) for availability updates.
## What you can build with Kairo
Kairo is designed for the full breadth of business software. It is not a niche language for a single domain.
Build reliable, maintainable services with clear domain models and explicit error handling.
Design and implement APIs that expose your business domain cleanly and consistently.
Create cross-platform desktop apps using Kairo's core language and the UIX framework.
Model complex business rules, workflows, and processes directly in the language.
Express business workflows as readable, auditable Kairo programs with clear control flow.
Connect to external systems using Bridge and Gateway with explicit, safe interop boundaries.
## Ready to write your first program?
The quickstart walks you through creating a Kairo project, writing a simple program, and running it with Forge and Pulse in just a few minutes.
Write, build, and run your first Kairo application end to end.