Kestrel

Convenience that doesn’t
cost you control.

Kestrel is a memory-safe, compiled language with simple defaults you can rewire.

scroll to explore

func findUser(id: Int64) -> Optional[User] {
    let user: User = match users.lookup(id).tryExtract() {
        .Continue(v) => v,
        .Break(r) => return .fromResidual(r)
    };
    if user.age.compare(18) == .Less { return Optional.None };
    user
}

func greet(id: Int64) -> String {
    let user = findUser(id).coalesce({ User(name: "guest", age: 0) });
    var s = DefaultStringInterpolation(literalCapacity: 8, interpolationCount: 1);
    s.appendLiteral("Hello, ");
    s.appendInterpolation(user.name);
    s.appendLiteral("!");
    s.build()
}

@main
func main() {
    var it = ["Alice", "Bob", "Carol"].iter();
    loop {
        match it.next() {
            .Some(name) => println(name),
            .None => break
        }
    }
}

func findUser(id: Int64) -> User? {
    let user: User = try users.lookup(id);
    if user.age < 18 { return null };
    user
}

func greet(id: Int64) -> String {
    let user = findUser(id) ?? User(name: "guest", age: 0);
    "Hello, \(user.name)!"
}

@main
func main() {
    for name in ["Alice", "Bob", "Carol"] {
        println(name)
    }
}

Sugar not magic

This looks like any modern language. Clean syntax, readable defaults, nothing unusual.

But none of it is special-cased.

Every shortcut is a protocol you can see, touch, and extend.

T?→

Optional[T]type alias

try→

Tryable.tryExtract()

<→

Comparable.compare()

null→

ExpressibleByNullLiteral.init() → .None

??→

Coalesce.coalesce()

\(...)→

Formattable.format(into:)

for...in→

Iterable.iter() → .next()

[...]→

ExpressibleByArrayLiteral.init(arrayLiteral:)

Sugar not magic

This looks like any modern language. Clean syntax, readable defaults. But none of it is special-cased.

sugar

func findUser(id: Int64) -> User? {
    let user: User = try users.lookup(id);
    if user.age < 18 { return null };
    user
}

func greet(id: Int64) -> String {
    let user = findUser(id) ?? User(name: "guest", age: 0);
    "Hello, \(user.name)!"
}

@main
func main() {
    for name in ["Alice", "Bob", "Carol"] {
        println(name)
    }
}

Same machinery with your types

The standard library uses these protocols to implement Optional, Result, Array, and String. Conform your own types and they get the same syntax — because it’s the same machinery.

for...in

Iterator

Implement next() and your type works in any for loop

try

Tryable

Implement tryExtract() and your type works with try

??

Coalesce

Implement coalesce() and your type works with ??

\(...)

Formattable

Implement format() and your type works in string interpolation

a < b

Comparable

Implement compare() and your type works with <, <=, >, >=

What you can build today

server.ksBuild HTTP servers with Perch

import perch.app.(App)
import perch.request.(Request)
import perch.response.(Response)
import perch.middleware.(Logger)
import http.content.(Text, JsonBody)

struct Ctx: Cloneable {
    func clone() -> Ctx { Ctx() }
}

var app = App(Ctx());
app.use(Logger[Ctx]());

app.route(get: "/hello/:name", { (req: Request, ctx: Ctx) in
    let name = req.param("name") ?? "world";
    Response.ok(Text("Hello, \(name)!"))
});

app.listen(8080);

output

The roadmap

Kestrel is in preview — expect sharp edges and fast iteration.

Preview 2

Types & expressiveness

Existential types

any Protocol values with dynamic dispatch

Attributes & derives

@derive(Equatable, Hashable, Cloneable)

Expression sugar

Optional chaining, pipe operator, placeholder args

Class runtime

Reference types with ref counting and weak references

Preview 3

Concurrency

Generators & yield

Lazy sequences that pause and resume with yield

Async / await

Async functions, executors, futures, async iteration

Structured concurrency

Task groups, cancellation, and data-race safety

Future

Where it's all going

Implicit context

given / using for allocators, loggers, and config

Procedural macros

Compile-time reflection and code generation

Algebraic effects

async, throws, yield unified into one composable model

And more

Shaped by real-world usage and community feedback

Preview 2

Types & expressiveness

Existential types

any Protocol values with dynamic dispatch

Attributes & derives

@derive(Equatable, Hashable, Cloneable)

Expression sugar

Optional chaining, pipe operator, placeholder args

Class runtime

Reference types with ref counting and weak references

Preview 3

Concurrency

Generators & yield

Lazy sequences that pause and resume with yield

Async / await

Async functions, executors, futures, async iteration

Structured concurrency

Task groups, cancellation, and data-race safety

Future

Where it's all going

Implicit context

given / using for allocators, loggers, and config

Procedural macros

Compile-time reflection and code generation

Algebraic effects

async, throws, yield unified into one composable model

And more

Shaped by real-world usage and community feedback

Help us shape it

Everything ships together

Not just a compiler. The package manager, registry, language server, editor extension, and agent plugins are built and released as one toolchain — one install gets all of it.

Flock

package manager

Dependencies, builds, publishing — and a registry to share it all.

Jessup

toolchain manager

Install, pin, and update compiler versions with one command.

Language server

IDE intelligence

Hover, completion, go-to-definition — the same incremental engine the compiler uses.

VS Code extension

editor support

Syntax highlighting and full LSP integration out of the box.

Claude & Codex plugins

AI pairing

An agent that already knows the language, plus docs shipped for LLMs.

Take flight

Install the toolchain and run your first Kestrel program

$ curl -fsSL https://kestrel-lang.com/install | sh

Installs Jessup (the Kestrel version manager), the latest preview toolchain, the VS Code extension, and the Claude Code / Codex plugin. Installs the toolchain, VS Code extension, and AI plugin. View the script.

Source on GitHub