English | 简体中文 | Contributing | 贡献指南

Load, link, and rewrite ELF in Rust and no_std environments.

Relink is a Rust ELF loading and runtime linking library. It can load .so files, executables, and object files from disk or memory, then resolve dependencies, apply relocations, and look up symbols.

• Load plugins, JIT artifacts, or hot-reload modules at runtime.
• Control DT_NEEDED dependencies, symbol scopes, or relocation handling yourself.
• Load ELF from memory, or plug in your own mmap or memory-management backend.
• Scan dependencies and sections first, then reorder layout, pack hot code, use huge pages, or run custom handling.
• Load relocatable ELF files such as .o / .ko.
• Keep ELF loading available in no_std, kernels, embedded systems, or non-standard runtimes.

• Shared objects / dynamic libraries (ET_DYN)
• Executables and PIE-style images (ET_EXEC, plus executable-style ET_DYN)
• Relocatable object files (ET_REL, for example .o / .ko) when the object feature is enabled

The default feature set is suitable for loading dynamic libraries, executables, and handling TLS:

[dependencies]
elf_loader = "0.15.1"

To enable the common advanced features in one bundle:

[dependencies]
elf_loader = { version = "0.15.1", features = ["full"] }

use elf_loader::{
    Result,
    input::PathBuf,
    linker::{LinkContext, Linker, SearchPathResolver},
};

fn main() -> Result<()> {
    let root = PathBuf::from("path/to/plugin.so");
    let mut context: LinkContext<PathBuf, ()> = LinkContext::new();

    let loaded = Linker::new()
        .resolver(SearchPathResolver::new())
        .load(&mut context, root)?;

    let run = unsafe {
        loaded
            .get::<extern "C" fn() -> i32>("run")
            .expect("symbol `run` not found")
    };
    let _ = run();

    Ok(())
}

The table below is a GitHub Actions performance snapshot. Use it only as a reference for the current test suite. Full environment details are in actions/runs/25632675040/job/75239090388. The fixture is the repository's libc -> libb -> liba test chain, not the system C library.

Lower is better for loading. scan_first includes dependency scanning and section planning, so it is not a direct dlopen replacement.

Symbol lookup was measured after both loaders had already loaded the fixture chain:

Notes:

• The default features are tls + libc.
• tls only provides the default resolver; custom TLS resolvers do not need this feature.
• load_object() is feature-gated. cargo run --example load_object will fail under the default feature set unless you add --features object.

Legend: ✅ supported, 🟡 basic support, ⏳ pending. Complex section-reorder repair and .o / ET_REL support are currently centered on x86_64 and riscv64 relocation handling; contributions for the other architectures are welcome.

Issues and pull requests are welcome. Star the project if it is useful in your work.

This project is dual-licensed under either of the following:

• MIT License
• Apache License 2.0