Scripting languages are pleasant to read until a project gets big enough that missing types start hiding bugs. Systems languages give you native binaries and predictable memory, though everyday business logic often ends up buried in punctuation.
At Undrocs, I have been writing Gable in C++ to find a middle ground I enjoy using: static types and ahead-of-time native compilation, with syntax that stays close to plain pseudocode.
fn summarize(values: [int]) -> int {
var total = 0
for n in values {
total = total + n
}
return total
}
Early choices in the compiler
Writing the lexer, recursive-descent Pratt parser, semantic checker, and code generator by hand forced me to settle details you barely notice as a language user.
First, int is always a signed 64-bit integer. In 2026, overflowing a 32-bit loop counter or file offset by accident is a silly bug to keep around. Fixed-width types (i8 through u64) are still right there when you are packing binary formats, and converting between widths requires an explicit as cast rather than C’s silent integer promotion rules.
Second, let bindings are immutable and var marks variables that actually change. Most local bindings in real functions are written once and read two lines later; catching accidental reassignment during semantic analysis costs almost nothing in syntax.
Third, line breaks end statements. Semicolons are still accepted if you want multiple statements on one line, so the parser stays simple without noisy line endings everywhere.
Strings carry an explicit byte length in UTF-8 instead of relying on null terminators, with built-in slicing, splitting, trimming, and "$interpolation". Working on SQLite Clone and SYPAS gave me plenty of appreciation for C and C++, and building my own compiler made it clear which sharp edges a new language does not need to inherit.