The New Generation of Systems Programming Languages: A Comprehensive Survey

The landscape of systems programming is undergoing a dramatic transformation. As software systems grow increasingly complex and security vulnerabilities continue to plague C and C++ codebases, a new generation of systems programming languages has emerged, each attempting to solve the fundamental problems of memory safety, concurrency, and developer productivity while maintaining the performance characteristics that make systems programming languages essential.

The proliferation of these languages raises an important question: why now? Several factors contribute to this renaissance. Modern compiler construction tools like LLVM have made it easier to build high-performance compilers, but paradoxically, the bar for creating a successful systems language has actually risen. The existence of LLVM has certainly helped, though notably many of these languages use alternative backends like GCC, QBE, or even C++ output rather than LLVM.

Let me walk you through the most notable contenders in this space, organized by their maturity and adoption.

Rust: The Established Standard

Rust stands as the most mature and widely adopted systems language in this new generation. Its home page emphasizes the language's core innovation: achieving memory safety without garbage collection through a sophisticated ownership and borrowing system. Rust's approach combines several key features:

• Sum types via enums with pattern matching
• Expression-oriented syntax (no statements, only expressions)
• A borrow checker that enforces single ownership and single mutable borrowing
• Manual memory management without explicit allocation or deallocation
• Strong built-in threading support with memory safety guarantees

What makes Rust truly remarkable is that if your code compiles, it's highly likely to be both memory-safe and functionally correct. This "if it compiles, it works" philosophy represents a fundamental shift from traditional systems programming. However, Rust's sophistication comes with complexity. The borrow checker can be challenging to work with, particularly for developers accustomed to graph-like data structures common in garbage-collected languages. The automatic elision of lifetimes, while convenient, can make explicit lifetime annotation surprisingly difficult when required.

Zig: The C Spirit Reborn

Zig positions itself as a modern replacement for C, maintaining C's spirit while eliminating its pitfalls. The language's philosophy centers on predictability: no hidden control flow, no hidden allocations, no macros or metaprogramming. Key features include:

• Manual memory management with streamlined patterns using defer
• Tagged unions and exhaustive switch statements
• Compile-time function execution
• Seamless C and C++ interoperability

Zig's 0.10.1 release demonstrates remarkable polish for a pre-1.0 language. It produces some of the fastest executables among these languages and serves as a compelling alternative C/C++ toolchain. The requirement to explicitly choose an allocator makes memory allocation behavior completely transparent in Zig code.

Odin: Simplicity and Performance

Odin takes inspiration from Wirth languages like Pascal and Oberon, emphasizing simplicity and high performance. Its design choices include:

• Manual memory management with defer and easy-to-use allocators
• Simple syntax without operator overloading or uniform function call syntax
• Bitsets and "distinct" types for stronger type checking
• Tagged unions

Odin's syntax is imperative like C and Pascal rather than expression-oriented. The language includes some surprising features for a systems language, such as built-in support for complex numbers and quaternions, reflecting its game development origins.

Jakt: Readability First

Jakt, developed as part of the Serenity OS project, prioritizes readability above all else. Notable design decisions include:

• Memory safety through reference counting
• Sum types with enums and pattern matching
• Value semantics with structs, reference semantics with classes
• Named function arguments (no positional parameters)
• Compile-time function execution
• C++ output as the backend

Jakt's development pace is impressive, with the language already self-hosting. The decision to always use named arguments, while unconventional, aligns with the language's readability goals.

Hare: The C Replacement

Hare aims to be a direct, minimal replacement for C. Its design philosophy emphasizes simplicity and portability:

• Manual memory management
• Tagged unions
• Mandatory bounds checking and initializers
• Mandatory error handling or immediate termination
• Exhaustive switch and match statements
• Nullable pointers
• QBE backend for compactness

Hare's commitment to only supporting free platforms (excluding macOS and Windows) and its goal of fitting on a 3.5" floppy disk demonstrate its minimalist philosophy. The language improves on C's spatial memory safety while planning to add temporal safety through potential future borrow checking.

Vale: Generational References

Vale introduces a novel memory management technique called generational references, which combines aspects of reference counting with ownership analysis to minimize actual reference counting and allocation overhead. The language's goals of "fast, safe, easy" are reflected in features like:

• Automatic, very fast memory management
• Higher RAII (what exactly this means isn't entirely clear from the description)
• Single ownership without a borrow checker
• LLVM backend

Vale is in early alpha but shows promise with features like a planned Region Borrow Checker for even greater safety and performance.

Lobster: Game Development Focus

Lobster feels like the child of Python and Crystal, with a focus on game and graphics development:

• "Compile-time reference counting" for memory management
• Static typing with extensive type inference
• "Zero-cost" structs on the stack
• C++ backend
• Python-like indentation for scoping
• Ruby-like block syntax

The language's documentation quality is notably high, with comprehensive tutorials and language references. Its memory management system, while unconventional, appears well-suited to its target domain.

Austral: Linear Types and Safety

Austral takes a unique approach through linear types and type classes:

• Linear types for memory and resource management without garbage collection
• Type classes for polymorphism
• Capability-based security
• Sum types with unions
• Exhaustive case statements
• C backend

Austral's syntax resembles a mini-Ada, reflecting its focus on producing very safe programs with readable syntax. The use of linear types, which are stricter than Rust's affine types, provides even stronger guarantees about resource usage and memory safety.

Myrddin and V: Solid Contenders

Myrddin represents an earlier entrant in this space, featuring algebraic data types, pattern matching, traits, and closures. While its maintenance status is unclear, it remains usable.

V positions itself as a simpler alternative, borrowing good parts from Rust and Go:

• Garbage collection with minimal overhead for performance
• Simple syntax similar to Go
• Limited pattern matching
• Sum types and Result-based error handling
• C backend

V includes built-in JSON support and appears to be developing a comprehensive standard library with a package manager.

Bonus Languages: Cone and Compis

Cone presents an aspirational vision with impressive tooling including IDE support and a web playground, though the extent of implemented features versus planned features isn't entirely clear.

Compis offers an innovative concept: mixing Compis source files with C code, compiling to C or WASM, and enabling C project building. Its syntax resembles Rust but without a borrow checker, instead tracking memory through ownership.

The Older Generation: Established Alternatives

Before this new wave, developers had several garbage-collected alternatives for systems programming:

• Nim: GC or ARC, compiles to C or WASM, Modula-2 with Python-like whitespace
• Crystal: GC, Ruby-like syntax with powerful type inference and union types
• Go: GC with self-contained binaries and strong concurrency support
• D: GC or manual, multi-paradigm with "better C" support

These languages, while not direct competitors to the new wave, provided viable alternatives to C/C++ for systems development.

Ada: The Original Safe Systems Language

Ada deserves special mention as the original safe systems programming language. Despite being from 1980, it possesses many qualities now being rediscovered:

• Manual memory management with minimal heap allocation
• No explicit delete operation
• Extremely efficient code generation
• Generic programming
• Immutable function parameters by default
• Highly descriptive type system with variant types
• Contracts with pre and post conditions
• Non-nullable types
• Built-in concurrency support

Ada's Spark subset can even prove the absence of runtime errors, making it perhaps the most rigorously safe option available.

The Future of Systems Programming

The proliferation of these languages reflects both the difficulty of the problems they're trying to solve and the diversity of approaches to solving them. Each language makes different trade-offs between safety, performance, simplicity, and familiarity.

Some, like Rust and Zig, aim for broad adoption as C/C++ replacements. Others, like Odin and Lobster, target specific domains like game development. Languages like Austral and Vale experiment with novel memory management techniques. Still others, like Jakt and Hare, prioritize specific design philosophies like readability or minimalism.

The success of these languages will likely depend on their ability to deliver on their promises while building ecosystems and communities around them. Rust has already demonstrated that a new systems language can achieve widespread adoption, but the diversity of approaches in this space suggests there's room for multiple successful paradigms.

What's clear is that the era of accepting C and C++'s memory safety issues as an unavoidable cost of systems programming is coming to an end. The next decade will likely see continued innovation in this space, with the most successful languages being those that best balance the competing demands of safety, performance, and developer productivity.