What is Syntella

Syntella is a small, general-purpose programming language built around a single idea: a program should behave exactly the way it reads. Nothing is coerced, nothing jumps, nothing happens off the page.

It is statically checked. The same source runs two ways: a tree-walking interpreter written in Rust runs it directly while you develop, and an LLVM backend compiles it to a standalone native binary when you ship. There is no VM and no runtime to install on the machine that runs the result.

use io

type Point {
    x: int
    y: int
}

impl Point {
    func manhattan(): int { self.x + self.y }
}

func main() {
    let p: Point = Point(3, 4)
    io.println(str(p.manhattan()))   // 7
}

The idea: no surprises

Most languages accumulate conveniences that quietly change what your code means. Syntella removes them on purpose, and the whole design follows from that one decision.

• No implicit coercion. An int is never silently promoted to a float. With type annotations, int + float is a compile error, not a hidden conversion. You convert on purpose or not at all.
• No truthiness. A condition is a bool. An int or a string is not a condition, so if count { ... } does not exist. You write the comparison you mean.
• No hidden control flow. There are no exceptions that unwind across call frames. A function that can fail returns the failure as a value, and you propagate it with a visible ?. Reading a program, you can see every place control can leave a function.
• No semicolons. Statements end at the next keyword, brace, or end of file. There is nothing to forget and nothing to insert.
• One way to iterate with a block. Instead of iterators, generators, and block syntax all at once, there is one primitive, flow with yield, and you can see the loop it drives.

The payoff is that reading Syntella is enough. You do not have to know a table of implicit rules to predict what a line does.

A fuller taste

Here is a program that uses a custom flow, defer, and lightweight concurrency together:

use io

// A flow runs the caller's block at each yield.
flow times(n) {
    for i in range(n) {
        yield
    }
}

func main() {
    defer io.println("done")

    let results = chan(3)
    let i = 0
    while i < 3 {
        spawn { results <- i * i }
        i = i + 1
    }

    times 3 {
        io.println(str(<-results))
    }
}

spawn starts three tasks that send into a channel, times 3 { ... } runs the block three times to receive them, and defer prints done on the way out. Every one of those behaviours is written where it happens.

Two ways to run the same code

	syt run	syt build
Backend	Tree-walking interpreter (Rust)	LLVM native binary
Startup	Instant	Microseconds, no runtime
Coverage	The whole language	Almost the whole language
Use it for	Iterating, scripts, tests	Shipping a CLI or service

You develop with run and ship with build. The language does not change between the two; only how it is executed does. See Native binaries.

Where it comes from

Syntella is a deliberate blend, not a clone of any one language:

• From Go: func, defer, and CSP concurrency (chan, spawn, select), plus the idea that a small language with a batteries-included toolchain is a feature.
• From Rust: let and const, type with impl and contract, use, static checking, and errors as ordinary values propagated with a trailing ?.
• From Ruby: blocks, reworked into the explicit flow and yield primitive.

The thesis on top of all of it is explicitness. Where those languages keep a convenience that hides behaviour, Syntella drops it.

What it is for

Syntella targets everyday backend and tooling work. It has an HTTP server in the standard library, a package manager, a formatter, and a language server, all inside the single syt binary. Because you can compile to a small, fast, dependency-free executable, it fits command-line tools and services you want to hand someone as one file.

Honest status

Syntella is young. The foundations are solid: a full pipeline (lexer, parser, semantic analysis, type checking), a tree-walking interpreter with complete Go-style concurrency, typed error handling without exceptions, strict generics, a native regex engine, a package manager, a language server, a formatter, and native compilation through LLVM. By the project's own STATUS, it is roughly 80% of the way to a production, general-purpose language: what is missing is volume, not the core design.

How to read these docs

The guide is a tour of the language, one concept at a time, in order. Start at Installation, or jump to a chapter:

• Values and types and Variables and operators
• Control flow, Functions, and flow and yield
• Types and contracts, Generics, and Error handling
• Concurrency and Modules and packages

The reference covers the CLI and the standard library.