The simplicity of PHP and Python. The power of Go.

A statically typed scripting language with real concurrency.

Genuine, enforced types that hold at runtime, and async that runs on goroutines for true parallelism. A typed alternative to PHP, Python, and Node.js for backend services, command-line tools, automation, and web apps.

Get started Download

import io;

# Generics persist to runtime, so this is a real check.
func describe(any value): string {
    if (value instanceof list<int>) {
        return "list of ints";
    }
    if (value instanceof list<string>) {
        return "list of strings";
    }
    return "something else";
}

io.println(describe([1, 2, 3]));
io.println(describe(["a", "b"]));

Static typing

Types that hold at runtime

Scripting languages usually give you no static types at all, or optional hints a runtime never checks. Geblang enforces types before your program runs and keeps enforcing them while it runs. Unlike TypeScript, the types are not erased once your code starts: generics persist, so instanceof list<int> genuinely works, and a wrong argument or a misspelled field is caught at the type checker, not in production. Values are non-null unless you opt in with ?T.

When you do need dynamic behaviour, parsing arbitrary JSON or bridging an untyped API, you reach for any and opt out explicitly, only in the places that need it, instead of losing type safety everywhere.

import json;
# Typed by default. Reach for `any` only where you need it.
any config = json.parse('{"port": 8080, "tls": true}');
int port = config["port"] as int;

Concurrency

Parallelism, not a single thread

Geblang's async and generators run on goroutines, so an HTTP server handles requests in parallel and CPU-bound work scales across every core. There is no global lock serialising your code, and no single event loop to block. An async func starts a task; async.all waits for a batch to finish together.

import io;
import async;

async func fetch(string name): string {
    await async.sleep(50);
    return "${name} ready";
}

let results = await async.all([fetch("users"), fetch("orders"), fetch("stats")]);
for (r in results) {
    io.println(r);
}

More than a scripting layer

A complete language and toolchain

Object-oriented, fully

Classes, interfaces, inheritance, generics that persist at runtime, method and operator overloading, decorators, and immutable types. A real type system, not a thin layer over dictionaries.

One binary to deploy

The geblang build command bundles your program, its dependencies, and the runtime into a single self-contained executable. Nothing to install on the target machine.

The whole toolchain, included

A static type checker, formatter, test runner, language server, VS Code extension, REPL, and debugger ship together. Nothing to assemble from separate packages.

A standard library for real work

HTTP, WebSockets, SQLite, Postgres and MySQL, Redis, message brokers, crypto and JWT, JSON, YAML, TOML and XML, and templating, so most programs need no third-party packages.

Use cases

Where Geblang fits

Backend APIs and services

Typed handlers and a goroutine-based server that serves requests in parallel, plus Gebweb, a separate web framework written in Geblang, with routing, OpenAPI, auth, and validation. The concurrent, statically typed answer to a PHP or Express back end.

Command-line tools

Build one self-contained binary your users download and run on Linux, macOS, or Windows, with no runtime to install. Argument parsing, subcommands, and terminal widgets are in the standard library.

Automation and scripting

The quick, readable style of a Python or shell script, with types catching mistakes before they run, plus process control, file and path tools, HTTP, and structured-data parsing built in.

Web applications

Server-rendered apps with templates, forms, sessions, CSRF, and flash messages through Gebweb, the Geblang web framework. A typed, single-binary alternative to a PHP or Rails application.

Familiar, if you're coming from

PHP, Python, or Node.js

From PHP

The same class-based, web-first feel, now with static typing, generics, and interfaces enforced before the code runs, and one binary to deploy instead of provisioning a runtime and its extensions.

From Python

The dict, list, and set literals, decorators, and REPL you know, but without the GIL, so CPU-bound work scales across cores, and with types that survive to runtime instead of staying hints.

From Node.js

The async and await you already use, running on goroutines for genuine parallelism rather than one event-loop thread, with types enforced at runtime and a single binary instead of a node_modules tree.

Start writing Geblang

Install the toolchain, write your first program in a few minutes, or read the reference manual.

Get started Read the docs