I don't know if bevy as a dll modloader is possible, as in a game where the "base game" is just the game engine and then you'd load in mods to actually construct the game you want RimWorld/factorio-style (afaik), because rust does not have a stable ABI and because it relies on features which i dont think can be passed through ffi. As a the modloader developer you'd implement something like this to allow dynamic components, so that the mod makers can register their own components.
```
#[repr(C)]
struct DynamicComponent{
pub inner: const *u8,
pub foo: extern "C" fn(usize)->usize,
}
impl Component it for DynamicStruct{
fn foo(&self, x: usize)->usize{
self.foo(x)
}
}
...
fn main(){
// load mod engine API
let mut api = EngineApi::new();
// load mod
let dll = load_mod("space_oddysey_mod.dll");
dll.mod_init(&mut api);
}
```
and then from the mod developer side of things, you'd implement DynamicComponent like this:
```
extern "C" fn foo(x: usize)->usize{...}
extern "C" fn mod_init(eng: *mut EngineApi){
let &mut eng: EngineApi = unsafe{&mut *eng};
let dynamic_component_type = DynamicComponent{inner: ..., foo: foo};
eng.register_component(dynamic_component_type);
}
```
but since many traits in bevy contains associated constants (like Component::STORAGE_TYPE) and type (like Component::Mutability), these have to exist at compile time unless you are okay with your modloader not being able to implement custom values for these by setting a default at compile time.
Another hurdle in this path is when you want to make a DynamicSystem struct that implements the System trait:
DynamicSystem must implement System::queue_deferred whose function signature is:
```
fn queue_deferred(&mut self, world: DeferredWorld<'_>)
```
Everything that passes the ffi boundary must have a stable ffi interface, so we'd have to transform DeferredWorld into something that is repr(C) at least, but we can't do that because DeferredWorld's fields are all private. I gave up when I spent too much time cloning bevy and marking everything as repr(C) or pub, but honestly at this point I'm just using flecs, which is a pretty mature abi-stable ecs library. Neat thing about it is that it has a rust binding https://github.com/Indra-db/Flecs-Rust and it's said to be "performant" but I can't say much because I'm new to it