# Kalandra: a functional language that compiles to JavaScript

> Kalandra is a functional programming language and framework for parallel and distributed applications, written in TypeScript and compiled to JavaScript ESM, with typed parallel calls that run in Bun subprocess pools or browser Web Workers. It is a development preview with no legacy migration path from its predecessor Clio.

**kalandra-lang/kalandra** — Kalandra is a functional, parallel, distributed programming language.

- Repository: https://github.com/kalandra-lang/kalandra
- Website: https://kalandra.dev
- Stars: 929 · Forks: 28
- Language: TypeScript
- License: Apache-2.0
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/kalandra-lang-kalandra

## A language whose parallelism is part of the type surface

Kalandra describes itself as a functional programming language and framework for parallel and distributed applications, and its differentiator is that distribution is expressed in the source rather than bolted on with a task library. The project summary is direct about it: compile to JavaScript, run independent functions in workers, import typed remote services, and compose their results, with the language, runtime and tools cooperating to reduce the machinery you write to distribute work.

The example on the project page shows the shape of the thing. A function is declared with a type annotation for its parameter, and a main function pipes a list through a parallel call. The result is described as returning the doubled values through typed parallel calls. The interesting part is not the arithmetic, it is that the pipeline element is typed and runs concurrently, and the type information travels with it.

That is a meaningful design choice for a language whose runtime is JavaScript. The typical approach is to write a worker pool by hand and pass plain data across the boundary. Here the parallel call is a language construct with a declared type, and the runtime handles scheduling, cancellation and cleanup.

The repository is written in TypeScript, the compiler front end uses Chevrotain, and the output is JavaScript ESM with source maps. The name is new but the lineage is not: the project calls itself the next chapter of Clio, and Clio's commits, tags and contributor history remain in the same repository.

## Where parallel work actually runs

The execution model differs by environment, and this is the concrete detail that matters when you plan where the library fits in your stack.

In the browser, the playground uses Web Workers. Local projects use Bun subprocess workers, and typed parallel tasks run in bounded Bun subprocess pools, with nested scheduling and cancellation supported. The word bounded is the important qualifier, because it means the pool size is controlled rather than each parallel element spawning a fresh process.

Remote services are the third mode, and they are explicitly labelled experimental. The project notes that experimental authenticated services support checked remote imports and service chaining, and the same paragraph describes the runtime as exporting a Bun hosting API, with separately compiled clients using remote contract imports and runtime endpoint bindings. Tokens are read from environment variables.

So the honest summary is that the local and browser paths are the ones the project actually exercises, while the distributed path is a preview. Anyone evaluating Kalandra for genuinely distributed work is evaluating an experimental feature, and the deployment side of it still needs production TLS, which the project lists as pending.

## Installing the CLI and running the starter

The CLI is published on npm as @kalandra/cli at version 0.13.0, and the project states that this version has passed clean archive and registry install checks. Bun 1.3.12 or newer is the requirement, and the version is pinned in both .bun-version and package.json.

```bash
bun add --global @kalandra/cli@0.13.0
kalandra --version
kalandra new my-app
cd my-app
kalandra run src/main.kalandra --strict
```

The starter is the doubled values example, so a successful run prints the same result the project page advertises. The strict flag is worth using from the start: the CLI check command is documented as checking names and known types in one source file, and passing it at run time surfaces type problems rather than letting them pass silently.

The install guide is also reachable from the documentation site, and there is an offline project creation path, since the CLI can create a dependency free starter without network access. That matters for CI environments and for trying the language before wiring it into anything.

## What the CLI can do beyond running a file

The command set is wider than a compiler wrapper, and this is where the tooling shows how seriously the project takes the language server and editor integration story.

The CLI can inspect function declarations and literal descriptions in a source file, display source with terminal syntax colours, parse a file and print its AST for syntax checking only, compile supported source to an ESM file with a source map sidecar, build local modules and resolve JavaScript packages, and check a single file for names and known types with an optional strict mode. A separate language server command starts a Bun stdio language server and provides diagnostics and editing support.

```bash
bun run cli compile <file> -o output.mjs
bun run cli build <entry.kalandra> -o out
bun run cli run examples/parallel.kalandra
bun run lsp
```

That combination, a parser you can run from the command line, a formatter, a language server and a static site generator for the docs, is what a language needs before people can write in it daily. The README describes the CLI as providing offline project creation, build, run and watch, formatting, source documentation and terminal highlighting.

One caution about the developer workflow: the bun run dev command starts the Tiramisu Docs site rather than a Kalandra program runner. It prints a local address, and it is the website editing server. The project also warns that you should not rebuild underneath a running preview server, because open tabs reference the previous build's hashed JavaScript chunks.

## Tiramisu, the schema side, and the Clio break

The language guide is called Tiramisu, and version 0.13.0 continues from Clio 0.12.0 with a rebuilt compiler, runtime, tooling and Tiramisu documentation. The version history on the releases page makes the shape of the project obvious: v0.13.0 shipped on 2026-10-14, while the previous tags are v0.1.6 from 2020-07-21 and v0.1.1 from 2019-04-07.

The compiler generates Sia schemas for typed parallel tasks, which is how the type information crosses into something that can be checked on the other side of a remote call. The schema tooling comes from @timeleap/sia, listed among the development dependencies alongside Chevrotain, fast-check for property based testing, Prettier for formatting and the Babel generator packages.

The break with the past is deliberate and total. The new language uses .kalandra files and does not provide a legacy migration layer. If you have Clio code, there is no automated path. The examples directory shows the scale of the new language surface, with files for tail recursion, async tail recursion, collections, expression bindings, indexed assignment, local events, modules, nested parallel calls, package imports, parallel captures, parallel modules, parallel records, startup closures, worker tasks and workflows.

The status line is also worth reading literally: development preview, with a verified port milestone complete within its recorded scope. The referenced scope document is docs/port-acceptance.md.

## Version 0.13.0 is a preview, and the docs say what is missing

Several limitations are named directly in the project description, which is unusual and useful. Production remote deployment and the deferred language-design work both remain ahead. The repository links a current limits document at docs/language-design-backlog.md and a release queue at docs/port-completion.md, and the status is defined as a development preview rather than a stable release.

The word preview has practical consequences for adoption. The npm version 0.13.0 follows semver's pre-1.0 convention, where minor versions can carry breaking changes, and the version jump from 0.1.6 to 0.13.0 skips most of the numbers in between. Clio's history is kept in the repository, so the project has continuity of authorship, but not continuity of syntax.

The hosted site situation is also unsettled. The website is deployed at a vercel.app address and the project states that the kalandra.dev DNS connection is pending, which means the canonical domain is not yet serving. A playground is advertised at kalandra.dev/docs/playground, and there is a separate bun run test:playground script for verifying it, so the browser path is being exercised even while the domain is being connected.

Support is organised through Open Collective, and the project links a website, documentation and playground as its three entry points.

## Licence, tooling stack and the shape of the workspace

The licence is Apache-2.0, recorded both in the repository's LICENSE and NOTICE files and in the workspace package.json, which is private and marked as a monorepo with workspaces covering packages and apps. That is the permissive end of the licence spectrum and removes the copyleft question that hampers adoption of similar projects.

The toolchain is Bun end to end. The packageManager field pins bun@1.3.12 and the engines field requires bun >= 1.3.12. Bun is the package manager, the development runtime, the bundler for library scaffolds and the test runner. Node is explicitly not required for the documented development commands, though browser portability remains a compiler requirement, with production runtime support to be established through integration tests.

The check script is the aggregate gate, and it is worth reading before you start hacking.

```bash
bun run check
```

That single command runs formatting checks, type checking, the test suite, the builds and isolated CLI smoke checks in sequence. The test suite itself covers Clio syntax, semantic analysis, toolchain and CLI checks, and separate commands exist for real-browser compiler checks, for the authenticated remote runtime including explicit cancellation and worker cleanup, and for the playground.

The repository is not archived and the last push was on 2026-10-19, so the work is current even if the release is a preview.

## Conclusion

Adopt Kalandra only for greenfield work where typed parallel calls, a compiler-generated schema and a Bun based toolchain are worth more than the stability of an established language, since version 0.13.0 is a development preview and the remote service path is still experimental. Do not plan a migration from Clio or an existing TypeScript codebase around it, because the new language uses .kalandra files with no legacy migration layer. Verify first that Bun 1.3.12 or newer is what you are willing to standardise on, that your platform can run Bun subprocess workers as well as browser workers, and that you read docs/language-design-backlog.md, because the deferred language design work and pending production TLS deployment are both named as still ahead.

## FAQ

### How do I install Kalandra and run the starter project?

With Bun 1.3.12 or newer installed, run bun add --global @kalandra/cli@0.13.0, then kalandra new my-app, cd my-app and kalandra run src/main.kalandra --strict. The starter prints the doubled values example, returning [2, 4, 6].

### Does Kalandra run in the browser as well as locally?

Yes, in two different ways. The browser playground uses Web Workers, and local projects use Bun subprocess workers, with typed parallel tasks running in bounded Bun subprocess pools. Browser portability remains a compiler requirement, with production runtime support to be established through integration tests.

### Can I migrate existing Clio code to Kalandra?

No. The new language uses .kalandra files and the project states that it does not provide a legacy migration layer. Version 0.13.0 continues from Clio 0.12.0 with a rebuilt compiler, runtime and tooling, while Clio's commits, tags and contributor history remain in the repository.

### Are Kalandra remote services ready for production?

Not yet. Remote services are described as experimental, production remote deployment is listed as remaining ahead, and production TLS deployment remains pending. The authenticated remote runtime has its own test commands, bun run test:network and bun run test:network --built, which cover cancellation and worker cleanup.

## Sources

- [kalandra-lang/kalandra on GitHub](https://github.com/kalandra-lang/kalandra)
- [License: Apache-2.0](https://github.com/kalandra-lang/kalandra/blob/develop/LICENSE)
- [Project website](https://kalandra.dev)
- [README](https://github.com/kalandra-lang/kalandra/blob/develop/README.md)
- [Releases](https://github.com/kalandra-lang/kalandra/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kalandra-lang-kalandra