How to embed Dyon in a Rust application?

Use the dyon crate with macros like `dyon_fn!` to define custom functions, then load scripts dynamically using `load` and call them with `call`, as shown in the examples. This allows runtime execution within Rust projects.

Dyon vs Lua for Rust scripting: which is better?

Dyon offers better Rust integration and safety features like lifetime checking, but Lua has a more mature ecosystem and broader community. Choose Dyon for safety-critical Rust embedding, Lua for wider library support and stability.

Is Dyon good for game development?

Yes, with native 4D vector support, mathematical loops, and dynamic modules, Dyon is suitable for prototyping game logic. However, for production games, consider its performance limitations compared to compiled languages like Rust.

How to handle errors in Dyon?

Use the built-in Result and Option types with the ? operator to propagate errors efficiently. The `unwrap` function prints error traces, making debugging easier, similar to Rust's error handling patterns.

Does Dyon support multithreading?

Yes, through Go-like coroutines with the `go` keyword and in-types for cross-thread communication, enabling concurrent execution within scripts. This is useful for parallel tasks in embedded applications.

What are the performance implications of using Dyon?

Dyon is dynamically typed and interpreted, so it has overheads compared to Rust. It's optimized for rapid prototyping and the coding cycle, not for performance-critical paths where Rust would be preferred.

Open-Awesome

dyon

Apache-2.0Rustv0.36

A dynamically typed scripting language designed for seamless integration with Rust, featuring a lifetime checker and no garbage collector.

GitHub

1.9k stars56 forks0 contributors

What is dyon?

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.

Target Audience

Rust developers who need a safe, embeddable scripting language for prototyping, game development, or tools requiring runtime code execution.

Value Proposition

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.

Overview

A rusty dynamically typed scripting language

Use Cases

Best For

Embedding a scripting language within Rust applications
Prototyping game logic or simulations with 4D vector support
Writing scripts that require safe memory management without a garbage collector
Building tools with dynamic module loading and runtime code execution
Educational projects exploring language design and Rust integration
Scripting tasks that benefit from mathematical loops and concise syntax

Not Ideal For

Projects requiring maximum computational performance or low-level hardware access
Teams dependent on a vast ecosystem of third-party libraries and frameworks
Applications that need to interface with multiple programming languages besides Rust

Pros & Cons

Pros

Memory Safety Without GC

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)`.

Dynamic Code Organization

Supports dynamic module loading with `load` and runtime script execution via `call`, enabling flexible code updates without recompilation, a key feature for prototyping.

Expressive Mathematical Syntax

Includes mathematical loops like ∑ (sum) and ∃ (any) for concise iteration, making code more readable for mathematical operations, as highlighted in the feature list.

Seamless Rust Integration

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.

Ergonomic Error Handling

Built-in Option and Result types with the ? operator, similar to Rust, for straightforward error propagation, with `unwrap` providing error traces for debugging.

Cons

Limited Ecosystem

As a niche language, Dyon lacks the extensive libraries, tools, and community support found in more established scripting languages like Lua or Python.

Performance Trade-Offs

Optimized for the coding cycle over raw speed, with non-goals including Rust-equivalent performance, making it unsuitable for high-performance computing tasks.

Complex Embedding Setup

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.

Frequently Asked Questions

Related Projects

boa

Boa is an embeddable Javascript engine written in Rust.

Rhai - An embedded scripting language for Rust.

Stars5,659

Forks250