How do I call a Rust function from a Rune script?

Register Rust functions in the Context using modules, then call them from scripts via the Vm. The README shows an example with `vm.call`, and the book details binding techniques for seamless integration.

Does Rune support asynchronous programming?

Yes, Rune has first-class async/await and generators, allowing asynchronous scripts that integrate with Rust's async runtime, as mentioned in the features list for flexible concurrency.

Rune vs Rhai: which is better for Rust scripting?

Rune offers advanced features like hot reloading and a richer type system, while Rhai is simpler and more lightweight. Choose Rune for complex, async-heavy scripts; Rhai for basic, performance-critical tasks.

How to enable hot reloading in Rune?

Hot reloading is built-in; modify script files while the application runs, and Rune reloads them automatically. Use the Vm with dynamic sources or the CLI tool, as described in the documentation for runtime updates.

What's the memory management model in Rune?

Rune uses reference counting for memory safety, preventing leaks and ensuring safe data access between Rust and scripts, similar to Rust's Rc/Arc but integrated into the VM.

Can I use Rune for game development modding?

Yes, Rune is well-suited for game modding due to hot reloading, safety features, and clean Rust integration. It allows players to write and test mods without recompiling, as highlighted in the value proposition.

Open-Awesome

rune

Apache-2.0Rust0.14.2

An embeddable dynamic programming language for Rust, designed for scripting and runtime extensibility.

Visit Website GitHub

2.3k stars113 forks0 contributors

What is rune?

Rune is an embeddable dynamic programming language designed specifically for Rust. It allows developers to add scripting capabilities to Rust applications, enabling runtime configuration, modding, and user-extensible behavior without requiring recompilation of the main application.

Target Audience

Rust developers who need to add scripting, modding, or runtime configuration to their applications, such as game developers, tool builders, or anyone creating extensible systems.

Value Proposition

Rune provides a memory-safe, performant scripting language that integrates cleanly with Rust's type system and ecosystem, offering features like hot reloading and async support that are uncommon in embedded languages.

Overview

An embeddable dynamic programming language for Rust.

Use Cases

Best For

Adding modding support to Rust-based games
Creating configurable CLI tools with user scripts
Building plugin systems for Rust applications
Implementing runtime configuration without recompilation
Prototyping game logic or application behavior
Extending static Rust programs with dynamic behavior

Not Ideal For

High-performance applications where scripting overhead must be minimized, as Rune's VM introduces runtime costs compared to native Rust.
Projects requiring extensive third-party libraries or cross-language integration, due to Rune's Rust-centric design and limited ecosystem.
Teams prioritizing quick adoption with minimal setup, as Rune's integration requires verbose boilerplate and understanding of Rust's type system.

Pros & Cons

Pros

Efficient Virtual Machine

Rune runs on a stack-based VM with compact bytecode, ensuring good performance for embedded scripting, as highlighted in the README's focus on efficiency.

Seamless Rust Integration

The language allows easy calling of Rust functions and types from scripts, with built-in serde support and clean binding, making it ideal for extending Rust applications.

Memory Safety

Uses reference counting to prevent common memory errors, enhancing safety when running dynamic scripts within Rust, as noted in the features list.

Hot Reloading Support

Scripts can be modified at runtime without restarting the application, enabling rapid iteration and modding, a key feature emphasized in the README.

Cons

Complex Initial Setup

Integrating Rune requires verbose boilerplate code, as shown in the README example with Diagnostics and context building, which can be daunting for simple use cases.

Limited Library Ecosystem

As a niche language, Rune lacks the extensive third-party libraries found in established scripting languages like Lua, restricting out-of-the-box functionality.

Performance Overhead

Being a dynamic language on a VM, Rune introduces runtime overhead compared to native Rust, which may not suit CPU-intensive tasks despite its efficiency claims.

Frequently Asked Questions

Related Projects

boa

Boa is an embeddable Javascript engine written in Rust.

Stars7,292

Forks631

Last commit2 days ago

rhai

Rhai - An embedded scripting language for Rust.

Stars5,416

Forks237

Last commit8 days ago

gluon

A static, type inferred and embeddable language written in Rust.

Stars3,403

Forks152

Last commit1 year ago

kcl

KCL Programming Language Core and API (CNCF Sandbox Project). https://kcl-lang.io

Stars2,367

Forks167

Last commit5 days ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub