Tagkyon

TagkyonExpress intent. Let the compiler handle execution.

Tagkyon is a programming language designed to separate what your program means from how it runs. From asynchronous execution and concurrency to resource management and recovery, the compiler uses your program’s semantics to build an efficient execution plan—without burdening everyday code with unnecessary complexity.

meaning in, execution plan out

  • Write ordinary code

    Keep business logic simple and reusable.

  • Express execution intent

    Describe concurrency, alternatives, and scheduling.

  • Compose resource policies

    Choose how effects are committed, reversed, or compensated.

  • Let the compiler optimize

    Use semantic guarantees to determine valid execution strategies.

You focus on the business logic.

Write straightforward, sequential code that expresses what your program should do. You don't have to organize every operation around threads, parallel tasks, or machine boundaries.

The compiler adapts how it runs.

The compiler can map your program to parallel, concurrent, and distributed environments, managing execution and communication so you can focus on solving the problem.

Describe what it is. Let Tagkyon figure out the rest.

Tagkyon lets you describe data with shapes and extend those shapes with reusable rules. Business logic stays close to the models it belongs to, rather than being scattered across an application. As data changes, its classification can change with it. This makes large codebases easier for programmers and LLM agents to understand and modify without needing the entire codebase in context.

person.tkg
export shape person(:x) {
    x.name is str;
    x.age is nat;
    return person(x);
}

export extension old(:x person) {
    x.age > 60;
    return old(x);
}

export extension young(:x person) {
    x.age <= 25;
    return young(x);
}

export extension middle(:x person) {
    x.age > 25 and x.age < 60;
    return middle(x);
}
main.tkg
import {young, middle, person} from person

let x = person(:name = "Samir", :age = 30);

x is middle;

x.age = 17;

x is young;

console.log(x);

Documentation is code, too.

Tagkyon can also build documents using ordinary language expressions and reusable components—or pass raw Markdown to a library when that is the simplest tool for the job. The same document can be generated from live data and rendered into different formats.

guide.tkg
<-->
    title "Getting started"

    section "A small example" {
        paragraph "Tagkyon keeps content
        close to the code that builds it."

        example "Hello world" {
            code {
                console.log("Hello, world!")
            }
        }

        list {
            "Write content with functions"
            "Compose reusable sections"
            "Generate docs from data"
        }

        note {
            "Render the document as HTML,
            PDF, or another supported format."
        }
    }
<--/>

markdown <<|
# Or use Markdown

Write **ordinary Markdown** when it
fits the content best.
|>>
Generated document preview

Getting started

A small example

Tagkyon keeps content close to the code that builds it.

Hello world

  • Write content with functions
  • Compose reusable sections
  • Generate docs from data
Render the document as HTML, PDF, or another supported format.

RAW MARKDOWN

Or use Markdown. Write ordinary Markdown when it fits the content best.