Stop wasting CI time on slow scripts.
Your pipelines shouldn’t wait for Python to boot or fail silently like Bash. Ship reliable infrastructure as native binaries.
Success! Executable 'pipeline' generated.
Infrastructure scripting is broken
Bash
Quick to write, hard to maintain. Breaks on edge cases and messy data.
Python / Node
Flexible, but slow startup and heavy runtime for simple scripts.
Go / Rust
Powerful, but verbose and overkill for small automation tasks.
Built for one thing: Fast, safe system scripting.
We stripped away the garbage collector and the heavy runtimes to give you the ultimate CI/CD weapon.
Native Binaries
Compile your pipeline once, run it anywhere. No dependency hell, no "it works on my machine" excuses.
Compile-time Safety
Catch broken pipes and invalid types before your CI even starts running. Stop deploying runtime crashes.
Zero-copy I/O
Kernel-level operations via sendfile(). Move gigabytes of logs without ever touching user-space memory.
Parse massive JSON before Python even boots
Stop loading 10MB payloads into memory just to read three fields.
import json
import requests
res = requests.get("https://api...")
data = res.json() # Loads entire tree
status = data.get("status")
if not status:
raise Exception("invalid")
print(data.get("url"))import http;
import strings;
struct Release {
tag_name: string,
status: string,
artifact_url: string
}
const payload = http.fetch("https://api...")
~> expect("invalid release");
const release_data =
parse_json_as(Release, strings.to_str(payload));
print(release_data.artifact_url);
Process gigabytes of logs without touching memory
Flint uses zero-copy I/O and kernel-level file operations via sendfile() to
process large files faster and safer than traditional scripting tools.
import os;
import io;
import strings;
const logs = os.ls("./logs")
~> expect("Failed to read dir");
for file in strings.to_str(logs) ~> strings.lines() {
# Filter and accumulate in the log
io.read_file(file)
~> strings.lines()
~> strings.grep("FATAL ERROR")
~> strings.join("\n")
~> io.write_file("report.log");
}
# Kernel-level move, bypasses user-space
os.copy("artifact.bin", "./staging/")
~> expect("copy failed");
Measured where it matters
Real-world infrastructure tasks. No synthetic loops.
Mass File Stat
Traversing directories and reading metadata (10k files).
Massive JSON
Loading 17MB of JSON. AOT mapping vs dynamic reflection.
Cold Start Network
Boot time and fetching a JSON payload via HTTP.
When to use Flint
Flint is not general-purpose. It shines in very specific, high-impact scenarios.
✓ CI scripts over 200+ lines
Your GitHub Actions or Bash scripts grew into fragile monsters. Debugging is painful, errors are silent, and Python adds cold-start overhead. Flint gives you compiled, predictable pipelines with real type safety.
✓ JSON payloads > 5MB
Python and Node load entire payloads into memory just to extract a few fields. Flint parses only what you define at compile time, avoiding unnecessary allocations.
✓ Cron jobs running every minute
Startup time compounds fast. A 300ms Python script becomes minutes of wasted compute per day. Flint binaries start instantly and execute with near-zero overhead.
✓ Log processing in production pipelines
Grep + awk pipelines break on edge cases and are hard to maintain. Flint gives you structured, typed pipelines with zero-copy I/O for massive files.
Get started in seconds
No package managers. No virtualenvs. Just clone, build, and run.
Write pipelines like this
Clean, readable, and strictly typed.
import os; import strings; os.exec("ps aux") ~> strings.lines() ~> strings.grep("root") ~> strings.join("\n") ~> print(); Mature tools know their boundaries.
Flint is a surgical tool. It makes aggressive architectural assumptions to achieve its extreme speed. Here is when you should NOT use it.
✕ Web Servers
Flint uses a 4GB Virtual Arena with a bump allocator and zero Garbage Collection. Memory is only freed when the CLI script exits. Long-running APIs will eventually hit OOM. Use Go or Rust instead.
✕ Heavy Math & ML
Flint relies entirely on 64-bit integers for memory layout speed. We do not support floats, matrices, or GPU acceleration. If you are doing Data Science or training models, stick to Python.
✕ Async & GUIs
Flint lives and breathes in the Unix terminal. The runtime is entirely synchronous by design to keep the C-emitter simple and fast. There is no event loop and no frontend windowing support.