Open source · in active development

Backend scripting,
no cold start.

Langoost is a statically-typed scripting language that compiles to bytecode and runs on a fast VM. A long-running process serves every request — like PHP, without the per-request warm-up.

Get started → Browse examples

Open source and in active development. Build from source with Go today; prebuilt binaries are planned.

hello.goost

// hello.goost
let name: string = "world"
print("Hello, " + name + "!")

$ langoost run hello.goost Hello, world!

Why Langoost

Built for warm processes.

No cold start

A single long-running process serves every request. Compiled modules are cached, so imports after the first are a map lookup — not a recompile.

Batteries included

A large standard library ships in the box: strings, math, json, yaml, xml, http, net, crypto, io, exec, collections, and thread.

Typed, but light

Python-like simplicity with TypeScript-style annotations. Write let x: int = 1 when it helps, omit it when it doesn't.

Inspectable bytecode

Source compiles to a compact 4-byte bytecode that runs on a stack VM. Disassemble any script to see exactly what executes.

HTTP server

An API in a single function.

Call http.serve with a handler that takes the method, path, query, and body and returns a string. Every request runs in its own isolated VM, so concurrent requests never share mutable state.

HTTP server guide →

server.goost

import http
import json

// Each request runs in its own isolated VM.
fn handle(method: string, path: string, query: string, body: string): string {
    if path == "/health" {
        return "{\"status\": \"ok\"}"
    }
    let data: json = {message: "Hello from Langoost"}
    return json.pretty(data)
}

http.serve(8080, handle)

fetch.goost

import http
import json

// Fetch and reshape JSON in a handful of lines.
let body = http.get("https://api.example.com/users/1")
let name = json.get(body, "name")

let out: json = {greeting: "hello", to: name}
print(json.pretty(out))

Standard library

Batteries already included.

HTTP, JSON, YAML, XML, crypto, files, sockets, compression, and concurrency all ship in the box. Inline json literals make shaping data feel native.

Explore the stdlib →

Built by AI

A language created by AI.

Langoost was designed and written by AI. Every layer — the lexer, parser, bytecode compiler, and stack VM in Go, the 40+ standard-library modules, and this website — was implemented, tested, and documented by AI under human direction. It's an experiment in how far that collaboration goes: a real, working language built end to end.

Compiler & VM

Lexer, parser, bytecode compiler, and a fast stack VM — written in Go.

40+ stdlib modules

HTTP, crypto, SQL, WebRTC, Raft, image, and more — all AI-authored.

Docs & this site

The documentation and the site you're reading were generated too.

At a glance

The shape of the language.

A quick reference while the full specification grows.

Kind: Statically-typed scripting language
Typing: Optional annotations, strong values
Compiles to: 4-byte bytecode on a stack VM
Runtime: Persistent process · isolated VM per request
Implementation: Written in Go
File extension: .goost
Toolchain: langoost run · repl · server · disasm

For humans & machines

Readable by people. Parseable by models.

Every page ships clean semantic HTML, JSON-LD structured data, and a plain-text .md mirror. Point an AI assistant at our llms.txt and it gets the whole language in one fetch.

/llms.txt /llms-full.txt

Start with the language tour.

A few minutes to the shape of Langoost — syntax, types, and the standard library.

Take the tour → Read the FAQ

Backend scripting,no cold start.