A dynamically typed scripting language designed for seamless integration with Rust, featuring a lifetime checker and no garbage collector.
Dyon is a dynamically typed scripting language designed to integrate seamlessly with Rust. It provides a flexible scripting environment with safety features like a lifetime checker, eliminating the need for a garbage collector. The language supports dynamic modules, optional typing, and mathematical loops, making it suitable for embedding in Rust applications.
Rust developers who need a safe, embeddable scripting language for prototyping, game development, or tools requiring runtime code execution.
Developers choose Dyon for its unique combination of scripting flexibility and Rust-like safety features, such as lifetime checking and no garbage collector, along with built-in support for concurrency, vectors, and error handling.
A rusty dynamically typed scripting language
Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.
Uses a lifetime checker to eliminate garbage collection, ensuring safe memory management as described in the features list for functions like `fn foo(mut a, b: 'a)`.
Supports dynamic module loading with `load` and runtime script execution via `call`, enabling flexible code updates without recompilation, a key feature for prototyping.
Includes mathematical loops like ∑ (sum) and ∃ (any) for concise iteration, making code more readable for mathematical operations, as highlighted in the feature list.
Offers macros like `dyon_fn!` and custom Rust object support using `Arc<Mutex<Any>>`, allowing easy embedding within Rust applications as a primary design goal.
Built-in Option and Result types with the ? operator, similar to Rust, for straightforward error propagation, with `unwrap` providing error traces for debugging.
As a niche language, Dyon lacks the extensive libraries, tools, and community support found in more established scripting languages like Lua or Python.
Optimized for the coding cycle over raw speed, with non-goals including Rust-equivalent performance, making it unsuitable for high-performance computing tasks.
Requires manual integration using Rust macros and custom functions, which can be more cumbersome than drop-in scripting solutions, as evidenced by the need for `Module::add` calls.