CLI & developer tools
Argument-aware entry points, filesystem APIs, child processes, streams and static or dynamic linking.
The Strut language
Native power.
Less friction.
Strut is an experimental compiled language for building native software with familiar syntax, explicit safety, real concurrency, and a toolchain that works equally well for humans and coding agents.
Native C++20 outputSafe explicit ownershipUseful batteries included
What is Strut?
A concise route from intent to native code.
Strut pairs a structured type system and checked errors with owning safe pointers, explicit raw-pointer escape hatches, threads and atomics.
Current development also composes practical backend surfaces: strict HTTP/TLS servers, buffered and streaming clients, cancellation, crypto, SQLite, full-duplex WebSockets, subprocess ownership, and cross-platform PTYs including Windows ConPTY. WebSocket terminal sessions remain application composition rather than a built-in bridge. These post-v0.0.3 capabilities are certified development work, not a claim that the complete stack is production-grade.
server.pSTRUT
function main() -> int : NetworkError {
app := http_server();
app.get("/health", (http_request req) => {
return http_text("ready");
});
app.listen("127.0.0.1", 8080);
return 0;
}typednativedeployable
What can you build?
One language. Real projects.
Use Strut for focused native tools or compose the built-in surfaces into larger applications.
Backends & full-stack services
HTTP/TLS, streaming bodies, NDJSON, outbound requests, WebSockets, cancellation, crypto and SQLite in a native service.
Data applications
Parse, transform, persist and serve structured data without assembling a framework first.
Concurrent native programs
Native threads, atomics, mutexes, channels and async work with explicit crossing rules.
Package-backed projects
Multi-module builds with immutable commits, SHA-256 verification, lockfiles and an offline cache.
Agent-driven development
Stable diagnostics, JSON inspection commands and authoritative metadata make feedback easy to consume.
Native by construction
A transparent compilation pipeline.
The compiler resolves and checks Strut source, selects the runtime components the program actually needs, then hands focused C++20 to the native toolchain. There is no bytecode VM and no hidden application server.
Conservative fallbacks preserve correctness for complex combinations while small programs stay small.
Safety without a hidden runtime
Ownership is visible. Escape hatches are explicit.
memory.pSAFE BY DEFAULT
struct Job { string name; }
Job* owner := new(Job { name: "compile" });
weak_ptr<Job> observer := weak(owner);
atomic<int> completed := 0;
unsafe {
raw_ptr<Job> view := ptr(owner);
print(view->name);
}T* Reference-counted ownership.
weak_ptr<T> Non-owning observation.
raw_ptr<T> Available inside explicit unsafe.
atomic<T> Shared state across native threads.
Tooling & AI-DX
Designed to be inspected.
The compiler, API registry and language server share authoritative language metadata. Humans get completions and diagnostics; agents get stable JSON surfaces and exact project context.
Controlled AI-DX benchmarks certify representative tasks and diagnostics. They are project tests—not claims that every model or workflow behaves identically.
Packages that stay put
Short name in. Immutable build out.
$
strut install sqlite↵Official shorthand resolves through the strut-packages repository to an immutable Git commit, verified SHA-256, lockfile and offline cache.
0.0.3 performance
Less runtime. Faster feedback.
Hello Worlddirect A/B compile
~81% fasterPlain threadsdirect A/B compile
~62% fasterMeasured against immutable v0.0.2 in the documented certification environment. The Strut frontend is sub-millisecond for these small fixtures; native C++ compilation now dominates. Results vary by machine and toolchain.
A language in active development
Build close to the machine.
Keep the code human.
Strut is young and intentionally honest about its status. The implemented surface is already useful for native tools, services and experiments—and every release makes the path from source to shipped binary clearer.