UltraCpp
A new systems programming language that keeps C++'s familiar syntax but borrows Rust's memory-safety guarantees, compiling down to LLVM IR.
🔗 Visit UltraCpp
Description
Rust fixed a lot of C++'s classic memory bugs, but it did so with a syntax and mental model that feels foreign if you've spent years writing C++. UltraCpp is an attempt to have both: it looks and reads like C++, but the compiler enforces the same kind of ownership and lifetime discipline that makes Rust programs memory-safe, so you don't have to relearn an entire language to get those guarantees.
Technically, its most distinctive choice is splitting what Rust treats as one concept into two: who is responsible for disposing of a value (ownership) and who is allowed to modify it (a separate permission, controlled via mod() calls and a configurable #modlaw directive). It compiles through a standard pipeline — lexer/parser to AST, then semantic checking for ownership, lifetimes and threading, then LLVM IR generation — using move semantics by default and no garbage collector, with explicit shared/__thread keywords for cross-thread and thread-local data. It's a genuinely solo project today: Apache-2.0 licensed, around 4 GitHub stars, with a C99 host compiler in production and a Rust reference implementation, aiming eventually to self-host in UltraCpp itself.
💬 Our review
The short version: UltraCpp is a real, technically thought-out experiment in "C++ syntax, Rust safety" — worth a look if that specific combination interests you, but it's a one-person project today, not a language you'd bet production code on yet.
Against Rust itself, UltraCpp's pitch is adoption friction: a C++ team can, in theory, get memory-safety guarantees without abandoning familiar syntax, and its ownership/modification-rights split is arguably more granular than Rust's single borrow-checker model. Against plain C++, it obviously adds real safety Modern C++ (even with smart pointers) doesn't enforce at compile time. But at 4 stars, a single contributor, and two separate compiler implementations to keep in sync, this is pre-alpha territory — there's no ecosystem, no package manager story, and self-hosting (compiling UltraCpp with itself) hasn't happened yet. Worth exploring if you're personally curious about alternative approaches to memory safety in C-family languages, or want to contribute early to a niche language project; skip it for anything beyond a personal experiment — for production work, that's still Rust (for new projects) or modern C++ with sanitizers (for existing codebases).
💰 Pricing
📊 Global score
🤖 AI-enriched data
Gratuit, licence Apache 2.0.
Pros
Syntaxe familière pour les développeurs C++ qui veulent la sécurité mémoire de Rust
Séparation plus fine entre propriété et droits de modification que le modèle Rust unifié
Politiques de permission d'écriture configurables via #modlaw
Répond directement aux incompatibilités sémantiques entre C++ et Rust
Cons
Stade très précoce (~4 étoiles, un seul contributeur)
Deux implémentations de compilateur en parallèle (hôte C99 + référence Rust)
Pas encore auto-hébergé (dépend toujours du compilateur hôte C99)
Aucun écosystème ni gestionnaire de paquets