Building on Rust: Why Developers Prefer Rust for New Languages and the Top 10 Rust-Powered Programming Languages and Tools

Rust has emerged as a popular choice for building new programming languages. Its combination of safety, performance, and modern tooling makes it an attractive foundation for language development.

Here, we explore the top 10 languages built over Rust and provide a comparison to highlight their unique features and advantages.

Top 10 Languages Built Over Rust

1. Koto

Koto is a lightweight scripting language designed specifically for embedding into Rust projects. It offers a fast startup time and a small binary size, making it an ideal choice for applications that require a lightweight scripting layer.

Features:

• Fast Startup Time: Quick initialization for immediate use.
• Small Binary Size: Minimal overhead, keeping applications lean.
• Easy Embedding: Seamless integration with Rust projects, enabling flexible scripting capabilities.
• Simple and Clean Syntax: Designed to minimize syntax noise and make code easier to read and write.
• Easy Integration with Rust: Koto is implemented in Rust and can be seamlessly integrated into Rust applications. Custom value types can be added by implementing the KotoObject trait.
• Fast Compilation: Optimized for rapid iteration, allowing scripts to compile quickly.
• Rich Iterator Support: Extensive support for iterators, including a wide range of iterator generators, adaptors, and consumers.
• Built-in Testing: First-class support for automated testing, making it easy to write and run tests alongside your code.
• Tooling Support: Plugins available for various editors, including Visual Studio Code, Vim/Neovim, and Sublime Text. Additionally, there are Tree-sitter and Language Server Protocol (LSP) implementations for enhanced editor integration.
• REPL: Interactive Read-Eval-Print Loop for dynamic scripting and testing.

Use Cases

Suitable for applications that require a lightweight scripting layer.

GitHub - koto-lang/koto: A simple, expressive, embeddable programming language, made with Rust

A simple, expressive, embeddable programming language, made with Rust - koto-lang/koto

GitHubkoto-lang

2- Mun

Mun is a programming language for fast, interoperable development. It Features a Hot-reloading, memory safety, and tight integration with Rust. It is an Ideal option for game development and other interactive applications.

Features

• Hot-Reloading: Allows code changes to be instantly reflected without restarting the application.
• Memory Safety: Ensures safe memory management, preventing common programming errors.
• Tight Integration with Rust: Seamless interoperability with Rust for enhanced performance and flexibility.
• Fast Development: Optimized for quick iteration and development cycles.
• Concurrency Support: Built-in features for handling concurrent tasks.
• Strong Type System: Ensures code reliability and correctness.
• Efficient Performance: Designed for high-performance applications.
• Easy Debugging: Tools and features that simplify the debugging process.
• Cross-Platform Support: Compatible with multiple platforms for versatile development.
• Extensible: Easily extendable with additional functionalities and libraries.

3- Gleam

Gleam is minimal yet a feature-rich type-safe language for building reliable systems. Its features include a strong type system, compilation to JavaScript and Erlang, and emphasis on simplicity.

Gleam is an ideal solution for building Backend services and full-stack development.

Exploring Gleam: A New Language for Robust and Scalable Systems

Gleam is a statically typed language for building reliable and maintainable systems, designed to work seamlessly with the Erlang Virtual Machine (BEAM). Its strong type system and excellent interoperability with Erlang and Elixir make it a compelling choice for developers seeking performance and safety. Why Choose Gleam? * Type Safety: Gleam’s

MEDevel.com: Open-source for Healthcare, and EducationHazem Abbas

3- Lisp.rs

Lisp.rs is a modern implementation of the Lisp family of languages, built with Rust. It offers advanced features like macros and functional programming, along with seamless interoperability with Rust.

Features:

• Macros: Powerful macro system for code transformation.
• Functional Programming: Emphasis on functional programming paradigms.
• Rust Interoperability: Easy integration with Rust for enhanced performance.
• REPL: Interactive Read-Eval-Print Loop for dynamic coding.
• Minimalist Syntax: Simple and expressive syntax, true to Lisp's roots.

Because its nature its primary Use Cases are Academic research, rapid prototyping, and DSLs.

4. Rune

Rune is an embeddable language designed for scripting Rust applications. It focuses on safe execution, maintaining a small footprint, and providing an extensive standard library.

Features:

• Efficient Stack-Based Virtual Machine: Runs a compact representation of the language on a highly efficient virtual machine.
• Clean Rust Integration: Seamless interoperability with Rust projects.
• Multithreaded Execution: Supports concurrent execution across multiple threads.
• Hot Reloading: Allows code to be updated and reloaded without restarting the application.
• Memory Safe: Utilizes reference counting to ensure memory safety.
• Awesome Macros and Template Literals: Advanced macro system and support for template literals.
• Try Operators and Pattern Matching: Simplifies error handling and enhances code readability.
• Structs and Enums: Supports data structures with associated data and functions.
• Dynamic Containers: Includes vectors, objects, and tuples with out-of-the-box Serde support.
• First-Class Async Support: Comprehensive support for asynchronous programming with generators.
• Dynamic Instance Functions: Allows for dynamic function calls on instances.
• Stack Isolation: Ensures stack isolation between function calls for enhanced security and stability.Safe Execution: Ensures scripts run securely within Rust applications.
• Small Footprint: Minimal resource usage for efficient performance.
• Extensive Standard Library: Rich set of built-in functions and utilities.
• Concurrency Support: Built-in features for handling concurrent tasks.
• Error Handling: Robust mechanisms for managing errors and exceptions.
• Type Safety: Strong typing to prevent common programming errors.
• Interoperability: Seamless integration with existing Rust code.

Rune is a good choice for Game scripting, configuration, and automation.

GitHub - rune-rs/rune: An embeddable dynamic programming language for Rust.

An embeddable dynamic programming language for Rust. - rune-rs/rune

GitHubrune-rs

5. Pikelet

Pikelet is a dependently-typed programming language inspired by Idris. It features a strong type system, pattern matching, and type inference, making it suitable for formal verification, theorem proving, and educational purposes.

Features:

• Strong Type System: Ensures high reliability and correctness in code.
• Pattern Matching: Simplifies code structure and enhances readability.
• Type Inference: Automatically deduces types, reducing boilerplate code.
• Dependent Types: Allows types to depend on values, providing more expressive power.
• Interactive Development: REPL and tooling for interactive coding.
• Extensibility: Easily extendable with custom types and functions.
• Documentation: Comprehensive and accessible documentation for learning and reference.

GitHub - pikelet-lang/pikelet: A friendly little systems language with first-class types. Very WIP! 🚧 🚧 🚧

A friendly little systems language with first-class types. Very WIP! 🚧 🚧 🚧 - pikelet-lang/pikelet

GitHubpikelet-lang

6- Gluon

Gluon is a statically-typed language that emphasizes type inference, making it small and easily embeddable. It follows a functional programming paradigm and integrates seamlessly with Rust.

Features:

• Small and Embeddable: Compact design for easy embedding in applications.
• Functional Programming: Emphasis on functional programming principles.
• Type Inference: Automatically infers types to simplify code.
• Rust Integration: Seamless interoperability with Rust projects.
• Concurrency Support: Built-in support for concurrent programming.
• Extensible Libraries: Rich library ecosystem for various tasks.
• Robust Error Handling: Advanced mechanisms for managing errors.

7. Rhai: A Tiny and Fast Embedded Scripting Language

Rhai is a lightweight, fast embedded scripting language that is easy to integrate, type-safe, and supports custom operators.

Features:

• Easy Embedding: Simplified integration into applications.
• Type-Safe: Ensures reliable and error-free scripting.
• Custom Operators: Supports creation of user-defined operators.
• Minimal Footprint: Low resource usage for efficient performance.
• Script Execution: Fast execution of scripts.
• Extensible: Easily extendable with new functionalities.
• Secure: Built-in security features for safe scripting.

GitHub - rhaiscript/rhai: Rhai - An embedded scripting language for Rust.

Rhai - An embedded scripting language for Rust. Contribute to rhaiscript/rhai development by creating an account on GitHub.

GitHubrhaiscript

8. Dyon: A Rusty Dynamically-Typed Scripting Language

Dyon is a dynamically-typed scripting language with tight integration with Rust, supporting concurrency and dynamic typing.

Features:

• Rust Integration: Seamless interoperability with Rust.
• Concurrency Support: In-built features for concurrent programming.
• Dynamic Typing: Flexible typing for rapid development.
• Memory Safety: Ensures safe memory management.
• Easy-to-Use: Simple syntax and ease of use.
• REPL: Interactive Read-Eval-Print Loop for testing.
• Extensible: Supports extension with Rust libraries.

GitHub - PistonDevelopers/dyon: A rusty dynamically typed scripting language

A rusty dynamically typed scripting language. Contribute to PistonDevelopers/dyon development by creating an account on GitHub.

GitHubPistonDevelopers

9. Nickel: A Contract-Based Configuration Language

Nickel is a configuration language based on contracts, featuring strong static typing and integration with Rust.

Features:

• Strong Static Typing: Ensures code reliability and correctness.
• Contracts for Validation: Uses contracts for data validation.
• Rust Integration: Easy integration with Rust projects.
• Declarative Syntax: Simplifies configuration management.
• Type Inference: Automatically infers types to reduce boilerplate.
• Error Handling: Robust mechanisms for managing errors.
• Extensibility: Easily extendable with custom functions and types.

GitHub - tweag/nickel: Better configuration for less

Better configuration for less. Contribute to tweag/nickel development by creating an account on GitHub.

GitHubtweag

Comparison Table

Conclusion

Rust's robust performance and memory safety, combined with its modern tooling, make it an excellent foundation for developing new programming languages. The diverse range of languages built on Rust showcases its versatility and the growing trend of leveraging Rust for language design.

For more detailed information, visit the Languages Built on Rust repository.