Skip to main content
Studio is the official integrated development environment for Kairo. It brings together editing, live diagnostics, intelligent completions, safe refactoring, and direct Forge workflow integration into a single environment purpose-built for the Kairo package model. Rather than treating the build system and the editor as separate concerns, Studio treats them as one: the same semantic analysis that powers forge check drives the diagnostics you see as you type, and every Forge operation is available without leaving the IDE.
Studio is under active development. Features and UI are subject to change as the language and toolchain mature. Consult the release notes for your installed version for the definitive list of supported capabilities.

​
Features

​
Editing and navigation

Syntax highlighting

Full syntax highlighting for .ak source files, kairo.toml manifests, and forge.lock.

Navigation

Go-to-definition, find-all-references, and symbol search across the entire package (or workspace).

Search

Full-text and symbol-aware search scoped to source, tests, or the whole workspace.

Formatting

Automatic code formatting and non-semantic hygiene fixes on save or on demand.

​
Diagnostics and completions

Studio keeps its diagnostic view continuously aligned with Forge semantics. The errors and warnings you see in the editor are the same diagnostics forge check produces — there is no separate “Studio linter” with different rules.
  • Live diagnostics — errors, warnings, and notes appear inline as you edit, sourced from the same analysis pipeline as Forge.
  • Completion — context-aware suggestions for identifiers, module members, keywords, and import paths.
  • Signature help — function parameter hints displayed as you type call expressions.
  • Hover info — type information, documentation, and declaration details on hover.

​
Refactoring

Studio supports safe, preview-first refactoring operations that update all affected references across the package or workspace before making any change:

Rename

Rename any symbol — function, type, module, variable — and Studio propagates the change to every reference, including import paths and cross-file usages.

Move

Move a declaration to a different module or file. Studio updates all import paths and references automatically.
Every refactoring operation shows you a preview of all proposed changes before applying them. You review and confirm the diff; Studio does not apply anything silently in the background.
Studio will never silently rewrite your source files, manifests, or package structure. Quick fixes and refactorings always require explicit confirmation. Background processes do not mutate source.

​
Scaffolding and templates

Studio provides template and scaffolding workflows to help you create new packages, modules, and common code patterns without writing boilerplate by hand:
  • Create a new application or library package from a template, with kairo.toml pre-populated.
  • Add a new module file with the correct declaration stub and file name convention.
  • Generate test stubs for existing modules.

​
Forge workflow integration

You can trigger every Forge command from within Studio without switching to a terminal: Studio also surfaces Forge diagnostics inline — if forge build produces an error in a source file, Studio highlights the relevant line and shows the FRG, SYN, or BCK diagnostic code alongside the message.
Studio does not bypass forge.lock or any other package resolution rules when invoking Forge. Every build triggered from within Studio is governed by the same deterministic pipeline as a manual forge build on the command line.

​
Debugging

Studio includes a debugging UX for stepping through Kairo application execution:
  • Set breakpoints in source files.
  • Inspect local variables, call stacks, and execution state at breakpoints.
  • Step over, step into, and step out of function calls.
  • Evaluate expressions in the context of a paused execution.

​
Project view

Studio’s project view distinguishes between different categories of files so you always know what you own and what is generated:

​
Rooting Studio at your project

Studio must be rooted at the right file to provide full package-aware tooling:
  • Single-package project — open the directory containing kairo.toml. Studio will discover and index the package.
  • Multi-package workspace — open the directory containing workspace.toml. Studio will discover all member packages and show them in a unified project view, with cross-package navigation and refactoring working across the whole workspace.
If you open a subdirectory that doesn’t contain a kairo.toml or workspace.toml, Studio will operate in a limited mode without package context. Always open at the package or workspace root for the full experience.

​
Extensions

Studio supports extensions that add new capabilities to the IDE — additional language support, custom views, external tool integrations, and more. Extensions may augment Studio’s behaviour, but they operate within firm boundaries:
  • Extensions cannot redefine language semantics, type-checking rules, or build behaviour.
  • Extensions cannot change how Forge resolves dependencies or produces artifacts.
  • Extensions cannot alter Pulse runtime contract handling.
  • Extensions must respect Studio’s policy of no silent source mutations.
The core Kairo experience — language rules, build pipeline, runtime behaviour — is defined by the language specification, Forge, and Pulse. Extensions layer on top without undermining that foundation.

​
Next steps

Forge

Learn the full Forge command suite that Studio orchestrates.

Overview

Understand the package structure and project layout Studio is built around.