> ## 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.

# Set Up the Kairo Toolchain: Install Forge and Pulse

> Install Forge and Pulse to start building and running Kairo applications. Covers early access options and building the toolchain from source.

To build and run Kairo applications you need two tools: **Forge**, the compiler and build system, and **Pulse**, the runtime that executes your compiled programs. Together they form the Kairo toolchain — everything you need to go from source code to a running application.

<Note>
  Kairo is currently in **v0.1 preview** and is under active development. Official installation packages have not yet been published. Installation instructions will be available with the first public release. In the meantime, see the sections below for early access options.
</Note>

## What you get

When the Kairo toolchain is installed, you will have two CLI tools available on your system.

### The Forge CLI

Forge is the compiler and build system for Kairo. It reads your `kairo.toml` manifest, compiles your `.ak` source files, and manages your project's dependencies and outputs.

| Command         | What it does                                       |
| --------------- | -------------------------------------------------- |
| `forge restore` | Download and restore package dependencies          |
| `forge check`   | Type-check and validate your code without building |
| `forge build`   | Compile your project and produce output artifacts  |
| `forge test`    | Run your project's test suite                      |
| `forge package` | Bundle your project into a distributable package   |
| `forge publish` | Publish your package to a package registry         |
| `forge clean`   | Remove build artifacts and temporary output files  |

### The Pulse CLI

Pulse is the runtime that executes compiled Kairo applications. It also provides tools for validating and inspecting compiled artifacts before you run them.

| Command          | What it does                                      |
| ---------------- | ------------------------------------------------- |
| `pulse validate` | Validate a compiled artifact without executing it |
| `pulse run`      | Execute a compiled Kairo application              |

## Getting early access

Kairo is being developed openly by Astra Kairo. If you want to follow along, get notified when the first release drops, or participate in shaping the language, the community is the best place to start.

<CardGroup cols={2}>
  <Card title="Join the Community" icon="users" href="https://community.astrakairo.dev">
    Visit community.astrakairo.dev to follow development, ask questions, and get early access announcements.
  </Card>

  <Card title="View the Source" icon="github" href="https://github.com/Astra-Kairo/kairo">
    The Kairo source is available on GitHub. You can build the toolchain from source if you want to get started today.
  </Card>
</CardGroup>

## Building from source

If you want to use Kairo before the first official release, you can build the toolchain directly from the source repository.

<Steps>
  <Step title="Clone the repository">
    Clone the Kairo repository from GitHub to your local machine.

    ```bash theme={null}
    git clone https://github.com/Astra-Kairo/kairo.git
    cd kairo
    ```
  </Step>

  <Step title="Follow the build instructions">
    Refer to the `README.md` in the repository for platform-specific build prerequisites and instructions. The repository contains the canonical, up-to-date steps for building Forge and Pulse from source.

    ```bash theme={null}
    cat README.md
    ```
  </Step>

  <Step title="Verify your installation">
    Once the build completes, verify that both CLI tools are available and show the expected version.

    ```bash theme={null}
    forge --version
    pulse --version
    ```
  </Step>
</Steps>

<Warning>
  Building from source gives you access to the latest in-development code, which may include breaking changes or incomplete features. For the most stable experience, wait for an official release package.
</Warning>

## What to expect from the toolchain

Once you have Forge and Pulse installed, the typical development workflow looks like this:

1. **Write** your Kairo source files (`.ak`) and define your project in `kairo.toml`
2. **Check** your code with `forge check` for fast feedback during development
3. **Build** your project with `forge build` to produce compiled output
4. **Run** your application with `pulse run`

You do not need any other tools to get started. The Forge CLI handles everything from dependency resolution to packaging, and Pulse handles execution.

<Tip>
  Once you're set up, follow the [Quickstart](quickstart) guide to write and run your first Kairo program in just a few minutes.
</Tip>