Richard Feldman on Roc: A Fast, Friendly, Functional Programming Language

Roc: A Descendant of Elm

• 💡 Roc is a programming language directly inspired by and descended from Elm, aiming to provide a similar ergonomic and friendly developer experience.
• 🚀 While Elm focuses on front-end web development, Roc is designed for a broader range of domains, including servers, command-line apps, native GUI apps, and even esoteric applications like programming physical devices.
• 🎯 A core value inherited from Elm is a focus on compiler ergonomics and friendly error messages, aiming to make the development process as smooth as possible.

Language Design and Features

• 🧩 Roc has evolved significantly from Elm, adopting a more mainstream syntax that visually resembles languages like TypeScript, which can lower the barrier to entry for new developers.
• ⚡ Static dispatch is a key feature, enabling a simpler underlying mechanism for function calls compared to object-oriented languages, while still allowing for familiar syntax like method-style calls.
• 🛠️ This simple dispatch mechanism unlocks powerful features like custom equality and operator overloading by simply implementing named functions within a module, without complex trait systems.
• 🧠 The language emphasizes immutability and pure functions, with a unique purity inference system that uses thin arrows (->) for pure functions and thick arrows (=>) for effectful functions, enforced by the compiler.

Performance and Safety

• 🚀 Roc aims for extremely fast compiler performance, with the new compiler rewrite targeting speeds significantly faster than the old one, aiming for millions of lines of code per second parsing.
• 📈 While not aiming for the absolute peak performance of languages like Rust or C++, Roc targets runtime performance competitive with or exceeding Go, especially in its memory management and use of LLVM for optimizations.
• 🔒 Roc offers strong safety guarantees, particularly for trusting third-party code, and its platform concept allows for sandboxing scripts to prevent malicious actions.
• 🤝 The language avoids a heavy runtime or virtual machine, compiling down to efficient code similar to Rust's ARC, offering a garbage-collected feel without GC pauses.

Error Handling and Development Experience

• ✅ Roc handles the absence of null or maybe types by using a Result type (similar to Rust's) for operations that can fail, combined with powerful anonymous sum types.
• 💡 This allows for expressive error modeling where functions can return a union of all possible error types, which the compiler exhaustively checks, ensuring all potential failures are handled.
• 💬 The compiler follows a philosophy of "inform but don't block," providing warnings and errors but generally allowing programs to run even with some compile-time issues, facilitating a more flexible development workflow.
• 📦 Dependency management is URL-based with content hashes for security, and dependencies are cached globally, simplifying scripting and avoiding large local node_modules-like directories.

Downsides and Future

• ⚠️ Current downsides include the immaturity of the compiler and known bugs in areas like unboxed closures, with a major rewrite underway targeting a 0.1.0 release in 2026.
• 📚 While Roc has a growing community, it's still a niche language, meaning a learning curve and fewer readily available libraries compared to more established languages.
• ⚙️ The language intentionally omits first-class mutation for simplicity, which can make certain algorithms less ergonomic to write compared to languages with more imperative features.
• 🌐 The distribution story is robust, supporting compilation to binaries, dynamic libraries, and WebAssembly, with plans for more sophisticated versioning.