Halis: The Side Project That Became My Life's Largest Ambition

Halis, a compiled, self-hosting systems programming language, began as an idle thought during a quiet evening. The developer, frustrated by the constant negotiation between performance, safety, control, and convenience, wondered what a language would look like that refused to accept these compromises. This curiosity slowly turned into a real system that could be run.

Halis is unique in that safety is the default state, not an afterthought. The compiler, hlc, is written entirely in Halis itself, and two compilation passes produce byte-identical output, verified by the bootstrap chain on every build.

Halis started as an experiment, fueled by the developer's curiosity and a desire to build a language where safety is not an option, but a fundamental aspect. As the experiment progressed, conviction turned it into a mission, ultimately becoming the largest undertaking of the developer's life. Most systems languages force a trade-off between raw speed and runtime overhead or between protection and risk. Halis rejects this trade-off, asserting that safety and performance can coexist.

The language enforces seven core guarantees that every program must respect. First, I/O is declared as an effect, ensuring that functions cannot silently perform I/O operations. If a function calls another function that performs I/O, and the outer function does not declare the effect, compilation fails. Second, every operation is checked for integer overflow, divide-by-zero, out-of-bounds array access, and invalid string indexing, halting the program safely if violated.

Third, Halis disallows null values, uninitialized variables, and hidden globals, making everything explicit and auditable. Fourth, memory safety is achieved without garbage collection, with use-after-move resulting in a compile error and deep-copying of every owned type. Fifth, fine-grained effects and capabilities split the single I/O effect into eight capabilities, each individually declared and statically verified through the entire call graph.

Sixth, taint tracking wraps any value as potentially attacker-controlled, rejecting passing tainted values to sinks such as print, println, write_file, read_file, file_exists, exit, net_lookup, and proc_exec. An explicit escape hatch allows bypassing taint tracking, but it must be visible and intentional. Finally, data-race freedom by construction ensures that data-race-free programs can be built without additional effort.