5 releases

Uses new Rust 2021

0.1.4 Nov 23, 2022
0.1.3 Nov 22, 2022
0.1.2 Nov 10, 2022
0.1.1 Nov 10, 2022
0.1.0 Oct 13, 2022

#134 in Embedded development

Download history 9/week @ 2022-10-07 15/week @ 2022-10-14 3/week @ 2022-10-21 27/week @ 2022-11-04 23/week @ 2022-11-11 106/week @ 2022-11-18 1188/week @ 2022-11-25 550/week @ 2022-12-02 602/week @ 2022-12-09 1177/week @ 2022-12-16 291/week @ 2022-12-23 1251/week @ 2022-12-30 1288/week @ 2023-01-06 1013/week @ 2023-01-13 1438/week @ 2023-01-20

5,000 downloads per month
Used in 4 crates (via vsmtp-rule-engine)


233 lines

Rhai Dylib

This crate exposes a simple API to load dylib Rust crates in a Rhai engine using Rhai modules.

🚧 This is a work in progress, the API is subject to change. Please do make recommendations on what you want it to be via issues, discussions or pull requests !


Loader is a trait that is used to build objects that load rhai modules from dynamic libraries in memory. A libloading implementation is available, which enables you to load modules via a cdylib or dylib rust crate.

Check the simple example for more details.

You can easily setup a dynamic library for Rhai by using cargo-generate and the rhai-dylib-template.

Module Resolver

This crate also expose a Rhai Module Resolver that loads dynamic libraries at the given path.

use rhai_dylib::DylibModuleResolver;

let mut engine = rhai::Engine::new();

// use `rhai::module_resolvers::ModuleResolversCollection` if you need to resolve using
// other resolvers.
// Check out https://docs.rs/rhai/latest/rhai/module_resolvers/struct.ModuleResolversCollection.html

import "/usr/lib/libmy" as my; // Import your dynamic library.

my::my_function(); // Use exported items !
"#).expect("failed to run script");

Check the module_resolver example for more details.


There are multiple limitations with this implementation.

TL;DR To use this crate, you need to:

  • Compile EVERYTHING, plugins and program that will load them, inside the SAME workspace or WITHOUT a workspace.
  • Use the rhai::config::hashing::set_ahash_seed function with the SAME four u64 array when building your plugins and the program that will load them. (i.e. rhai::config::hashing::set_ahash_seed(Some([1, 2, 3, 4])))


Rust TypeId is an object used to compare types at compile time. Rhai uses those to check which type a Dynamic object is. This is a problem for dynamic libraries because TypeIds sometime change between compilations.

That means that in certain situations, Rhai cannot compare two types, even tough they are the same, because the TypeId of said types is different between the plugin and the binary.

To fix this, you will need to compile your main binary AND plugins inside the SAME workspace, or compile everything OUTSIDE of a workspace. Compiling, for example, a binary in a workspace, and a plugin outside will probably result in TypeIds mismatch.

You can use

println!("{:?}", std::any::TypeId::of::<rhai::Map>());

In your binary & plugins to check the type id value.

If you have any idea of how the compiler generates those typeids between workspaces and single crates, please help us complete this readme !


Rhai uses the ahash crate under the hood to create identifiers for function calls. For each compilation of your code, a new seed is generated when hashing the types. Therefore, compiling your main program and your plugin different times will result in a hash mismatch, meaning that you won't be able to call the API of your plugin.

To bypass that, you need to use the rhai::config::hashing::set_ahash_seed function with an array of four u64.

Beware that the rhai::config::hashing::set_ahash_seed function is only available from the main branch of Rhai for the time being.

Rust ABI

You also can implement a plugin using the Rust ABI, which is unstable and will change between compiler versions.

This means that all of the plugins that you will use in your main program need to be compiled with the EXACT same compiler version.


~63K SLoC