Hylo: A New Systems Programming Language Built on Value Semantics and Generic Programming

In the ever-evolving landscape of systems programming languages, a new contender has emerged with a distinctive approach to safety, performance, and expressiveness. Hylo represents a significant departure from traditional systems languages by placing value semantics and generic programming at the core of its design philosophy.

The Foundation: Value Semantics as a First-Class Citizen

At the heart of Hylo lies a commitment to value semantics that goes beyond what most modern languages offer. While languages like Swift and Rust have embraced value semantics to varying degrees, Hylo takes this concept to its logical extreme. The language's design ensures that value semantics aren't just a feature but the fundamental way of thinking about data and computation.

This approach addresses one of the most persistent challenges in systems programming: managing mutable state safely. By making value semantics the default and providing sophisticated mechanisms for controlled mutability, Hylo aims to eliminate entire categories of bugs that plague traditional systems code.

Generic Programming Reimagined

Hylo's take on generic programming is equally ambitious. The language extends concepts from Swift's powerful generics system while introducing novel techniques for compiling generics with coherence. This allows developers to write highly abstract, reusable code without sacrificing performance or safety.

The language's generic system is designed to work seamlessly with its value semantics model, creating a synergistic relationship where the strengths of each approach reinforce the other. This combination enables developers to express complex abstractions while maintaining the predictability and safety that value semantics provide.

Compiler Innovation and Tooling

Hylo's compiler represents a significant technical achievement in its own right. Built using LLVM, it employs novel techniques for compiling generics with coherence and includes sophisticated caching and serialization of the compiler's program state. These innovations contribute to both compilation speed and the ability to handle complex generic code patterns. The development experience is enhanced through a VSCode extension with syntax highlighting and code execution capabilities, a documentation compiler, and a language server prototype. The team has also invested in developer experience through support for development containers, making it easy to get started with Hylo development.

Research-Driven Development

The Hylo project is deeply rooted in academic research, with numerous papers exploring various aspects of the language's design and implementation. Topics range from high-fidelity C interoperability to type checking with rewriting rules, demonstrating the rigorous theoretical foundation underlying the language's practical features.

This research focus is evident in the language's approach to complex problems like double-linked lists with value semantics, which the team has shown can be both safe and faster than traditional reference semantics approaches. Such innovations demonstrate how Hylo's design principles can lead to genuinely novel solutions to longstanding systems programming challenges.

Practical Examples and Early Results

Despite being in its early stages, Hylo already demonstrates compelling capabilities through working examples. The language's approach to subscripts as a safe projection mechanism showcases how value semantics can be expressed naturally while maintaining safety guarantees.

Another notable feature is the concept of sink methods, which provide capability for deinitializing objects in a controlled manner. This allows for explicit resource management while preventing common pitfalls like use-after-free errors. The language's move semantics are equally sophisticated, with custom move operations that can track and validate object state transitions.

The Team and Community

The Hylo project benefits from the involvement of prominent figures in the programming language community, including Dave Abrahams, a well-known figure in the C++ community who has been instrumental in shaping modern C++ through his work on the Boost libraries and the C++ standard. This expertise, combined with contributions from academic researchers and industry practitioners, positions Hylo to make a meaningful impact on the systems programming landscape.

The project has cultivated an active community through Slack channels, GitHub discussions, and regular talks at conferences like C++ On Sea and ACCU. This community engagement suggests strong interest in the language's approach and potential for growth.

Looking Forward

As Hylo continues to evolve, it represents an intriguing experiment in how systems programming languages might address the tension between performance, safety, and expressiveness. By making value semantics and generic programming first-class concerns rather than add-on features, Hylo challenges conventional wisdom about what systems programming languages should look like.

The language's early achievements in areas like double-linked list implementation and C interoperability suggest that its approach is more than theoretical. As the compiler matures and the standard library expands, Hylo has the potential to become a significant player in the systems programming space, particularly for developers who prioritize safety and abstraction without sacrificing performance.

For developers interested in exploring the cutting edge of systems programming language design, Hylo offers a compelling vision of what's possible when value semantics and generic programming are elevated from features to foundational principles. The language's combination of theoretical rigor, practical innovation, and strong community support makes it one to watch in the coming years.