Built-in system modules

TON618 ships with twelve built-in system modules. They aren't files on disk — they live inside the interpreter — but you still IMPORT://ton.<name> them before using them, exactly like a user module:

IMPORT://ton.sys
IMPORT://ton.os
IMPORT://ton.requests
IMPORT://ton.random
IMPORT://ton.time
IMPORT://ton.json
IMPORT://ton.mathutils
IMPORT://ton.strings
IMPORT://ton.encoding
IMPORT://ton.regex
IMPORT://ton.path
IMPORT://ton.tensor

Calling any of the functions below without first importing its module fails with an "undefined function" error — this is intentional: a script only pays for (and only exposes) the built-ins it actually asked for. Every module follows the naming convention recommended for user modules above: every function is prefixed with the module's own name.

#ton.sys — runtime & process information

#ton.os — environment variables & filesystem

#ton.requests — a minimal HTTP client

A small, dependency-free HTTP client (raw sockets, same spirit as the built-in server). Limitation: http:// only, no TLS/https:// — there is no bundled SSL library, so it can talk to local services, other TON618 servers, or any plain-HTTP endpoint, but not to an HTTPS-only API.

All three return a ton.dict with the same shape:

{
    ok: true,      // whether a response was received at all
    status: 200,     // the HTTP status code (0 if the request failed outright)
    body: "...",       // the raw response body
    error: ""            // a human-readable reason when ok is false
}

IMPORT://ton.requests

ton.dict res = requests_get("http://localhost:8081/api/users")
if res["ok"] {
    print("Status: " + str(res["status"]))
    print(res["body"])
} else {
    print("Request failed: " + res["error"])
}

#ton.random — extra randomness helpers

Complements the always-available random() with a few common patterns:

#ton.time — clocks & timestamps

#ton.json — JSON parsing & pretty-printing

The always-available json(x) native already turns a value into compact JSON. IMPORT://ton.json adds the other direction, plus a multi-line format:

IMPORT://ton.json
IMPORT://ton.requests

ton.dict res = requests_get("http://localhost:8081/api/users")
ton.array users = json_parse(res["body"])
print(len(users))

#ton.mathutils — trig, logs & stats helpers

Complements the always-available sqrt/pow/abs/floor/ceil/round/min/max with trigonometry, logarithms, and small statistics/number-theory helpers:

IMPORT://ton.mathutils

print(mathutils_gcd(48, 18))          // 6
print(mathutils_mean([1, 2, 3, 4]))   // 2.5
print(mathutils_clamp(15, 0, 10))     // 10

#ton.strings — extra string helpers

Complements the always-available upper/lower/trim/split/replace/contains/substring:

IMPORT://ton.strings

print(strings_capitalize("hello world"))  // "Hello world"
print(strings_pad_left("7", 3, "0"))      // "007"

#ton.encoding — base64, hex, and URL percent-encoding

Dependency-free encoders/decoders for the formats scripts most often need when talking to web APIs:

IMPORT://ton.encoding

print(base64_encode("hello world"))  // aGVsbG8gd29ybGQ=
print(url_encode("a b/c"))            // a%20b%2Fc

#ton.regex — pattern matching

Backed by C++'s standard <regex> library (ECMAScript syntax) — no external dependency, and the same regex flavor used by JavaScript.

IMPORT://ton.regex

print(regex_test("hello123", "[0-9]+"))                          // true
print(regex_replace("2024-01-15", "(\\d+)-(\\d+)-(\\d+)", "$3/$2/$1"))  // 15/01/2024

#ton.path — filesystem path manipulation

Pure string/path manipulation — no disk access (see ton.os for that).

IMPORT://ton.path

print(path_join("a", "b", "c.txt"))     // a/b/c.txt
print(path_extension("/foo/bar.txt"))    // .txt

#ton.tensor — small 1D/2D numeric arrays for basic ML work

A tensor is a ton.dict with two fields — {shape: [...], data: [...]} (data is flat, row-major) — so it prints, str()s, and json()s like any other dict. The functions below implement element-wise/matmul/reduction ops as real C++ loops (bypassing the AST), a genuine speed-up over the same loop hand-written in TON618 — but see honest limits below before reaching for this to do anything ambitious. This same {shape, data} convention is what the community atome module (a plain .ton file, not part of the interpreter — see ton618 install atome) builds its autograd/training layer on top of.

IMPORT://ton.tensor

ton.dict a = tensor_from_array([[1, 2], [3, 4]])
ton.dict b = tensor_from_array([[5, 6], [7, 8]])
print(tensor_to_array(tensor_matmul(a, b)))   // [[19, 22], [43, 50]]
print(tensor_to_array(tensor_relu(tensor_from_array([-1, 0, 2]))))  // [0, 0, 2]

Honest limits — read this before building anything ambitious on top of ton.tensor:

• CPU only. There is no GPU compute backend (no CUDA/OpenCL bindings) anywhere in this interpreter, and none is planned — "GPU support" isn't something a .ton module can add on its own.
• 1D and 2D shapes only — no 3D+ tensors (so no image batches, no attention-head-shaped tensors, etc. without flattening/reshaping tricks yourself).
• Only scalar broadcasting (plus the one explicit tensor_add_bias exception above) — tensor + differently-shaped-tensor (general NumPy-style broadcasting) does not work.
• No autograd built in. ton.tensor gives you the forward ops and the matching _grad helpers to build backpropagation by hand — there's no automatic computation-graph tracking. See the community atome module (ton618 install atome) for a from-scratch autograd/training layer built on top of this.
• Not remotely competitive with a real numeric library. These are still C++ loops over a dynamically-typed Value array — real work for a small language, but nowhere near BLAS/cuDNN performance. Fine for learning, toy models, and small experiments; not for training anything at real scale.

Edit this page on GitHub