I built a scripting language that compiles to self-contained binaries

Oleg — Fri, 13 Feb 2026 15:16:46 +0000

Hey! I've been working on a scripting language called Funxy. It's written in Go, statically typed with inference (so you rarely write type annotations), and the main idea is painless distribution — your script compiles to a single binary you can scp and run.

I know there's no shortage of programming languages, so let me focus on what actually makes this different from writing the same thing in Python/Go/Rust.

The build story

The thing that motivated this whole project: I was tired of deploying scripts that need a runtime, virtualenvs, or a build toolchain on the target.

funxy build takes your script and produces a single binary — bytecode + VM + all dependencies baked in. No Funxy installation needed on the target:

funxy build healthcheck.lang -o healthcheck
scp healthcheck prod:~/
ssh prod './healthcheck'

~25 MB binary, zero deps. Not tiny, but reasonable for a tool you're shipping to a server.

The script itself is straightforward:

import "lib/http" (httpGet)
import "lib/json" (jsonDecode)
import "lib/term" (green, red, table)

response = "https://api.example.com/services" |>> httpGet
services = response.body |>> jsonDecode

rows = []
for s in services {
    status = if s.healthy { green("●") } else { red("●") }
    rows = rows ++ [[s.name, status, s.version]]
}
table(["Service", "Status", "Version"], rows)

You can embed static files (--embed templates, --embed "static/*.css"), and the script reads them via normal fileRead — doesn't matter if it's running interpreted or compiled. Cross-compilation works via --host flag (build on Mac for Linux).

Multi-command binaries

This is probably the feature I'm most happy with. You can bundle several scripts into one binary, BusyBox-style:

funxy build api.lang worker.lang migrate.lang -o myserver

./myserver api --port 8080    # runs api.lang
./myserver worker             # runs worker.lang
./myserver migrate            # runs migrate.lang
./myserver                    # prints usage

Symlinks work too — ln -s myserver api && ./api --port 8080 dispatches by argv[0].

Embedded resources are shared across all commands, so --embed config is accessible from both api and worker. And sysArgs() strips the command name, so a script doesn't know or care if it's standalone or part of a multi-command binary.

One-liners

funxy -pe '1 + 2 * 3'                                                          # 7
echo '{"name":"Alice"}' | funxy -pe 'stdin |>> jsonDecode |> \x -> x.name'      # Alice
cat data.txt | funxy -lpe 'stringToUpper(stdin)'                                # per line

-e eval, -p print, -l line mode. All stdlib auto-imported, piped input as stdin.

Built-in TUI

No external deps for colors, prompts, spinners, tables:

import "lib/term" (red, green, bold, confirm, select, table, spinnerStart, spinnerStop)

env = select("Deploy to", ["dev", "staging", "prod"])

if confirm("Deploy to " ++ bold(env) ++ "?") {
    s = spinnerStart("Deploying...")
    // ... work ...
    spinnerStop(s, green("✓ Done"))
}

table(["Service", "Status"], [["api", green("●")], ["cache", red("●")]])

The language

Static types, full inference. Pattern matching with string patterns:

match (method, path) {
    ("GET", "/users/{id}")       -> getUser(id)
    ("GET", "/files/{...path}")  -> serveFile(path)
    _                            -> notFound()
}

Multi-paradigm — imperative and functional in the same file:

// Imperative
total = 0
for item in order.items {
    total = total + item.price * item.qty
}

// Functional
total = order.items |> map(\i -> i.price * i.qty) |> foldl(\a, b -> a + b, 0)

// Side effects
users |> filter(\u -> u.active) |> forEach(\u -> print(u.name))

ADTs, unions, records, closures, async/await, pipes, TCO.

Stdlib

HTTP/gRPC, JSON/CSV/Protobuf, SQLite (built-in), regex, crypto, WebSockets, async tasks — 31 modules. funxy -help lib/<name> for docs.

Install

curl -sSL https://raw.githubusercontent.com/funvibe/funxy/main/install.sh | bash

macOS, Linux, FreeBSD. It's early — feedback, ideas and bug reports are very welcome.

funvibe / funxy

Funxy is a general-purpose scripting language with static typing and type inference

Funxy

A statically typed scripting language that compiles to native binaries. For automation, services, and data tooling.

Write scripts, ship native binaries — funxy build creates standalone executables with embedded resources
Static types with strong inference — most code needs no annotations
Batteries-included stdlib: HTTP/gRPC, JSON/protobuf, SQL, TUI, async/await, bytes/bits
Use Go packages from scripts — declare in funxy.yaml, import as ext/*
Built-in VMM for supervisor/worker orchestration with RPC, mailbox, tracing, and circuit breaker
Command-line eval mode (-pe, -lpe) for one-liners and shell pipelines
Safe data modeling with records, unions, ADTs, and pattern matching
Immutable data structures (Records, Lists, Maps) with ergonomic update syntax
Easy embedding in Go for config, rules, and automation

funxy build server.lang -o myserver && scp myserver user@prod:~/

echo '{"name":"Alice"}' | funxy -pe '|>> jsonDecode |> \x -> x.name'   # Alice

import "lib/csv"  (csvEncode)

…

View on GitHub

Forem: Oleg

[Boost]