Hylo (language)
By the Hylo project (formerly Val)
Hylo (formerly known as Val) is an experimental, open-source, general-purpose programming language exploring mutable value semantics as an alternative to reference-based and ownership/borrow-checker-based memory management, aiming to…
Definition
Hylo (formerly known as Val) is an experimental, open-source, general-purpose programming language exploring mutable value semantics as an alternative to reference-based and ownership/borrow-checker-based memory management, aiming to combine memory safety with performance comparable to Rust or C++ without those systems' complexity.
Overview
Hylo is a research-oriented systems programming language whose central idea is mutable value semantics: instead of memory safety being guaranteed through a borrow checker (as in Rust) or garbage collection (as in Java or Go), Hylo treats every value as if it were independently copied whenever it is passed around, while using compiler optimizations to avoid the cost of actual copying whenever safe to do so. This model is inspired by how value types behave in languages like Swift, but Hylo pushes the concept further, applying it uniformly rather than as one option among several. The goal is to eliminate entire classes of memory-safety bugs — dangling pointers, data races, use-after-free — without requiring programmers to reason about lifetimes, borrow rules, or explicit ownership annotations the way Rust demands, while still achieving performance in the same league as Rust or C++ through aggressive compiler-driven optimization (sometimes called 'law of exclusivity' enforcement). The project began under the name Val, created by a team including former Swift compiler contributors, and was renamed Hylo as the design matured. Hylo remains an active research and experimental project rather than a production-ready language; it does not yet have the tooling maturity, library ecosystem, or industry adoption of established systems languages. Its significance lies primarily in language design research: it represents a distinct point in the design space between garbage-collected safety and Rust-style ownership-checked safety, and is closely watched by programming-language researchers and systems programmers interested in alternatives to the borrow checker for achieving memory safety without runtime garbage collection overhead.
Key Features
- Built around mutable value semantics rather than references or ownership/borrowing
- Aims for memory safety without a Rust-style borrow checker
- Targets performance comparable to Rust and C++
- Compiler-driven optimization avoids unnecessary copying implied by value semantics
- No garbage collector; safety is achieved statically at compile time
- Originated as the Val language before being renamed Hylo
- Open-source and actively developed as a research/experimental language
- Influenced by Swift's value-type semantics, generalized further