awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
rusterlium avatar

rusterlium/rustler

0
View on GitHub↗
docs.rs/crate/rustler↗

Rustler

Rustler is a native function wrapper and foreign function interface that enables the development of high-performance extensions for the BEAM virtual machine. It serves as a bridge for writing native functions in Rust that can be called from Erlang environments.

The project focuses on maintaining memory safety to prevent system crashes and memory corruption when executing compiled code. It achieves this by wrapping native calls in safe abstractions and applying Rust's ownership and borrowing rules to the management of external memory and structured data objects.

The library provides mechanisms for data conversion between language types and the management of resource objects. These capabilities allow for the passing of references to structured data into external code with automatic memory release via the runtime garbage collector.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • Native Function Invocations - Provides the primary capability to invoke high-performance native Rust functions from a managed Erlang runtime.
  • Trait-Based Term Conversions - Uses Rust traits to provide a shared interface for encoding and decoding data types between Rust and the Erlang Term Format.
  • Language Interoperability Converters - Encodes and decodes values between Rust and Erlang types to ensure data compatibility across the FFI bridge.
  • BEAM NIF Bridges - Serves as a specialized bridge for integrating native Rust functions into the BEAM virtual machine environment.
  • Erlang NIF Development - Provides the essential tooling and safety abstractions for developing Native Implemented Functions for the Erlang VM using Rust.
  • Native Function Dispatchers - Implements a high-performance NIF-based dispatch mechanism to execute native Rust functions within the BEAM virtual machine.
  • Native Runtime Wrappers - Acts as a safety layer handling memory management and data conversion for native Rust code in Erlang environments.
  • Rust-Erlang Integration - Facilitates the exchange and conversion of data types to combine Rust's systems programming with Erlang's actor model.
  • Rust Native Extensions - Enables the creation of high-performance native extensions for the BEAM VM while preventing memory corruption.
  • Safe Pointer Abstractions - Encapsulates unsafe native calls in safe Rust abstractions to prevent memory corruption and segmentation faults.
  • Reference-Counting Garbage Collectors - Uses reference counting to track external memory allocations and ensure automatic cleanup by the runtime garbage collector.
  • Native Memory Lifecycle Management - Implements automated memory management for native objects shared between Rust and Erlang processes.
  • Resource Handles - Manages resource objects by passing references to structured data into external code with automatic memory release.
  • Foreign Function Interface - Bridge for creating Erlang NIF functions in Rust.
4,806 stars·243 forks·Rust·Apache-2.0·23 views

Star history

Star history chart for rusterlium/rustlerStar history chart for rusterlium/rustler

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Frequently asked questions

What does rusterlium/rustler do?

Rustler is a native function wrapper and foreign function interface that enables the development of high-performance extensions for the BEAM virtual machine. It serves as a bridge for writing native functions in Rust that can be called from Erlang environments.

What are the main features of rusterlium/rustler?

The main features of rusterlium/rustler are: Native Function Invocations, Trait-Based Term Conversions, Language Interoperability Converters, BEAM NIF Bridges, Erlang NIF Development, Native Function Dispatchers, Native Runtime Wrappers, Rust-Erlang Integration.

Which projects share features with rusterlium/rustler?

Projects with overlapping indexed features include: hansihe/rustler — Rustler is a toolkit and interface for building safe, high-performance native extensions that integrate Rust code with… java-native-access/jna — JNA is a foreign function interface and native memory mapper that allows Java applications to call functions in shared… marcuswestin/webviewjavascriptbridge — WebViewJavascriptBridge is a communication layer for sending bidirectional messages between native Objective-C code… flutter-team-archive/plugins — This project is a collection of official plugin packages and a native integration library designed to provide a… janet-lang/janet — Janet is a Lisp-based dynamic programming language featuring a register-based bytecode virtual machine and an… byt3bl33d3r/offensivenim — OffensiveNim is a red teaming framework and post-exploitation toolkit developed in Nim. It provides a collection of…

Projects sharing features with Rustler

These projects share indexed features with Rustler. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • hansihe/rustlerhansihe avatar

    hansihe/Rustler

    4,806View on GitHub↗

    Rustler is a toolkit and interface for building safe, high-performance native extensions that integrate Rust code with the BEAM virtual machine. It provides a bridge for writing native functions in Rust that integrate with Erlang and Elixir. The project focuses on preventing virtual machine crashes by catching Rust panics during the execution of native functions. It utilizes a safe interface to encapsulate raw pointers and provide type-safe abstractions for native extensions. The toolkit covers cross-language data marshalling through trait-based term conversion and manages the lifecycle of m

    Rust
    View on GitHub↗4,806
  • java-native-access/jnajava-native-access avatar

    java-native-access/jna

    8,916View on GitHub↗

    JNA is a foreign function interface and native memory mapper that allows Java applications to call functions in shared native libraries without writing custom JNI wrapper code. It serves as a JNI alternative framework for invoking C functions and mapping native data structures using high-level interfaces. The library distinguishes itself through its ability to translate Java objects and primitives into C-style structs, unions, and pointers for cross-platform memory exchange. On Windows, it provides a dedicated toolkit for interacting with Component Object Model objects using both early and la

    Java
    View on GitHub↗8,916
  • flutter-team-archive/pluginsflutter-team-archive avatar

    flutter-team-archive/plugins

    17,710View on GitHub↗

    This project is a collection of official plugin packages and a native integration library designed to provide a consistent interface for accessing hardware and software functionality across different mobile and desktop platforms. It serves as a native platform bridge, enabling cross-platform applications to invoke native code and manage operating system dependencies. The project utilizes a federated plugin architecture, splitting plugins into common interfaces and separate platform implementations to allow for independent development and extension. It further supports native integration throu

    Dartandroiddartflutter
    View on GitHub↗17,710
  • janet-lang/janetjanet-lang avatar

    janet-lang/janet

    4,308View on GitHub↗

    Janet is a Lisp-based dynamic programming language featuring a register-based bytecode virtual machine and an embeddable scripting engine. It functions as a fiber-based concurrency runtime and includes a parsing engine based on Parsing Expression Grammars. The project is distinguished by its ability to be integrated into C or C++ applications via a minimal header interface. It utilizes a Lisp-style macro system for compile-time code transformation and employs prototype-based table inheritance for object-oriented behavior. The runtime covers a broad set of capabilities, including asynchronous

    Ccfunctional-languageimperative-language
    View on GitHub↗4,308
Compare all 30 related projects→