Skip to main content

Getting Started

Telo is a runtime for declarative backends. You describe what your system should do in YAML, and Telo runs it — no imperative glue code.

This guide walks through installing Telo, running a minimal manifest, and understanding what just happened.

Install​

Currently Telo kernel is written only in NodeJS (Rust version is planned next). Install it globally with npm or pnpm:

npm install -g @telorun/cli
# or
pnpm add -g @telorun/cli

The CLI installs as telo. Verify with:

telo --version

Prefer not to install globally? Run Telo via Docker:

docker run -v .:/srv -w /srv telorun/node:latest-slim ./manifest.yaml

Your first manifest​

Create hello.yaml:

kind: Telo.Application
metadata:
  name: HelloConsole
  version: 1.0.0
imports:
  Run: std/run@0.10.0
  Console: std/console@0.9.0
targets:
  - Main
---
kind: Run.Sequence
metadata:
  name: Main
steps:
  - name: SayHello
    invoke: !ref Console.writeLine
    inputs:
      output: "Hello from Telo!"

This declares:

  • A Telo.Application — the runnable root, with Main as its target.
  • Two imports: entries — pulling in the Run and Console modules from the standard library.
  • A Run.Sequence named Main with a single step that invokes the exported Console.writeLine singleton.

Run it​

telo ./hello.yaml

You should see:

Hello from Telo!

What just happened​

When you ran telo ./hello.yaml, the kernel:

  1. Loaded the YAML, resolved each import, and compiled any ${{ … }} CEL expressions into an in-memory registry.
  2. Resolved the resource dependency graph — Main references Console.writeLine, the singleton exported by the imported Console module.
  3. Initialized each resource in dependency order, calling its controller's lifecycle hook.
  4. Dispatched the targets declared on the Application — here, Main — and ran the sequence to completion.

Telo itself doesn't know what a console is. Each kind: is owned by a controller module (loaded over npm at boot) that implements the resource's lifecycle. The kernel just orchestrates loading, init order, references, and dispatch.

Add something runtime-shaped​

A console one-shot is the simplest possible Telo manifest, but the runtime really shines once you wire long-running services together. The next stop is examples/hello-api.yaml — a minimal HTTP server with one route, a CEL-templated request handler, and a JavaScript script that builds the response. Same four phases, but with a Telo.Service (the HTTP server) that stays alive after init.

What's next​

  • Kernel reference — Resources, capabilities, modules, and the CEL evaluation model.
  • HTTP Server — Route definitions, request / response shaping, OpenAPI generation.
  • Standard library overview — All built-in modules (HTTP, SQL, AI, Lambda, MCP, …).
  • Style guide — Naming, structure, and CEL conventions.
  • CLI reference — telo check, telo install, telo publish, watch mode, registry config.