# rhaiscript/rhai

**Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/rhaiscript-rhai).**

5,453 stars · 238 forks · Rust · Apache-2.0

## Links

- GitHub: https://github.com/rhaiscript/rhai
- Homepage: https://crates.io/crates/rhai
- awesome-repositories: https://awesome-repositories.com/repository/rhaiscript-rhai.md

## Topics

`embedded` `embedded-scripting-language` `no-std` `rhai` `scripting-engine` `scripting-language` `wasm` `webassembly`

## Description

Rhai is an embedded scripting engine and dynamically typed language designed for integration into Rust applications. It functions as an abstract syntax tree compiler and native interop layer, allowing developers to map Rust types and functions into a scripting environment for bidirectional communication.

The project serves as a framework for creating customizable domain-specific languages. It allows for the definition of custom operators, syntax, and restricted execution environments, enabling the creation of specialized languages with tailored functional sets.

The engine covers a broad range of capabilities including resource-capped sandboxing for secure execution, modular code organization, and comprehensive data processing for numeric, string, and binary types. It also provides tools for AST manipulation, execution state serialization, and runtime observability through call stack inspection and debugging interfaces.

The engine is designed for cross-platform deployment on any CPU or operating system supported by the native compiler.

## Tags

### Programming Languages & Runtimes

- [AST-Based Execution](https://awesome-repositories.com/f/programming-languages-runtimes/ast-based-execution.md) — Processes source code by transforming it into an abstract syntax tree for optimization and repeated execution.
- [Embedded Scripting Engines](https://awesome-repositories.com/f/programming-languages-runtimes/embedded-scripting-engines.md) — Implements a lightweight scripting engine that can be integrated into a host application for dynamic logic and data exchange. ([source](https://cdn.jsdelivr.net/gh/rhaiscript/rhai@main/README.md))
- [Embedded Scripting for Rust](https://awesome-repositories.com/f/programming-languages-runtimes/embedded-scripting-for-rust.md) — Integrates a dynamic scripting language into Rust applications to allow users to define custom logic and automation.
- [Parsed AST Caching](https://awesome-repositories.com/f/programming-languages-runtimes/abstract-syntax-tree-parsing/parsed-ast-caching.md) — Transforms source code into an abstract syntax tree and caches it to avoid redundant parsing during repeated execution. ([source](https://rhai.rs/book/engine/compile.html))
- [AST Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/ast-optimizations.md) — Simplifies the abstract syntax tree through optimization passes that eliminate dead code and pre-evaluate constant arguments. ([source](https://cdn.jsdelivr.net/gh/rhaiscript/rhai@main/README.md))
- [Native Module Registration](https://awesome-repositories.com/f/programming-languages-runtimes/c-based-scripting-engines/native-module-registration.md) — Uses procedural macros to expose host functions, constants, and type aliases as native modules in the engine. ([source](https://rhai.rs/book/plugins))
- [Primitive Data Types](https://awesome-repositories.com/f/programming-languages-runtimes/control-flow-basics/primitive-data-types.md) — Supports a comprehensive set of primitive data types including integers, floats, decimals, booleans, strings, arrays, and maps. ([source](https://rhai.rs/book/language/values-and-types.html))
- [Domain Specific Languages](https://awesome-repositories.com/f/programming-languages-runtimes/domain-specific-languages.md) — Provides a framework for designing specialized languages with custom syntax, operators, and restricted feature sets.
- [Dynamic Object Maps](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-object-maps.md) — Provides hash dictionaries for storing and retrieving key-value pairs to modify properties dynamically at runtime. ([source](https://rhai.rs/book/language/object-maps.html))
- [Dynamic Script Execution](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-script-execution.md) — Evaluates and runs strings of code at runtime to modify application logic and state without recompilation. ([source](https://rhai.rs/book/language/eval.html))
- [Embedded Scripting Languages](https://awesome-repositories.com/f/programming-languages-runtimes/embedded-scripting-languages.md) — Implements a dynamically typed language designed for integration into Rust applications for custom logic.
- [Expression Evaluators](https://awesome-repositories.com/f/programming-languages-runtimes/expression-evaluators.md) — Computes the result of a script expression and returns the resulting value back to the host application. ([source](https://rhai.rs/book/engine/hello-world.html))
- [External Variable Mapping](https://awesome-repositories.com/f/programming-languages-runtimes/external-variable-mapping.md) — Allows the host application to map external Rust values and objects into the script's execution context. ([source](https://rhai.rs/book/language/variables.html))
- [Foreign Function Bindings](https://awesome-repositories.com/f/programming-languages-runtimes/foreign-function-bindings.md) — Maps native host functions and closures into the scripting environment via a registration system for bidirectional communication.
- [Function-Pointer Callbacks](https://awesome-repositories.com/f/programming-languages-runtimes/function-pointer-callbacks.md) — Provides mechanisms to map script-defined functions to native memory addresses so the host application can trigger runtime logic. ([source](https://rhai.rs/book/language/fn-ptr.html))
- [Host Function Exposure](https://awesome-repositories.com/f/programming-languages-runtimes/host-function-exposure.md) — Provides mechanisms for registering native Rust functions to be callable from within the scripting environment. ([source](https://rhai.rs/book/rust/functions.html))
- [Host-to-Script Data Passing](https://awesome-repositories.com/f/programming-languages-runtimes/host-to-script-data-passing.md) — Shares host values with scripts as variables or constants via an external scope. ([source](https://cdn.jsdelivr.net/gh/rhaiscript/rhai@main/README.md))
- [Host-to-Script Function Invocations](https://awesome-repositories.com/f/programming-languages-runtimes/host-to-script-function-invocations.md) — Executes specific functions defined within a script from the host language with custom arguments and scope management. ([source](https://rhai.rs/book/engine/call-fn.html))
- [Host Type Exposure](https://awesome-repositories.com/f/programming-languages-runtimes/host-type-exposure.md) — Maps host data types into the scripting environment using custom display names, methods, and indexers. ([source](https://rhai.rs/book/rust/custom-types.html))
- [Interface Value Wrapping](https://awesome-repositories.com/f/programming-languages-runtimes/interface-value-wrapping.md) — Wraps native Rust data in dynamic containers to enable seamless interoperability and runtime type switching between host and script.
- [Language Extension APIs](https://awesome-repositories.com/f/programming-languages-runtimes/language-extension-apis.md) — Provides APIs and a plugin system powered by procedural macros to add custom functionality to the language. ([source](https://cdn.jsdelivr.net/gh/rhaiscript/rhai@main/README.md))
- [Feature Restrictions](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/feature-restrictions.md) — Disables specific keywords, operators, or expression types to constrain the capabilities of the script. ([source](https://rhai.rs/book/engine/disable-keywords.html))
- [Module Organization](https://awesome-repositories.com/f/programming-languages-runtimes/module-organization.md) — Groups related functions and types into named namespaces to manage scope and code splitting. ([source](https://cdn.jsdelivr.net/gh/rhaiscript/rhai@main/README.md))
- [Script Module Resolution](https://awesome-repositories.com/f/programming-languages-runtimes/module-path-resolution/import-path-resolution/module-search-path-configurations/script-module-resolution.md) — Implements mechanisms for discovering and importing external script files based on configurable search paths. ([source](https://rhai.rs/book/rust/modules/resolvers.html))
- [Native Function Pointer Invocations](https://awesome-repositories.com/f/programming-languages-runtimes/native-function-pointer-invocations.md) — Provides mechanisms for calling native functions via memory addresses mapped to script-accessible pointers. ([source](https://rhai.rs/book/language/fn-ptr.html))
- [Native Interoperability Layers](https://awesome-repositories.com/f/programming-languages-runtimes/native-interoperability-layers.md) — Provides a system for mapping Rust types and functions into a scripting environment for seamless communication.
- [Native-to-Script Function Invocations](https://awesome-repositories.com/f/programming-languages-runtimes/native-to-script-function-invocations.md) — Executes script-defined functions from within a native host function by passing function pointers as parameters. ([source](https://rhai.rs/book/language/fn-ptr.html))
- [Domain Specific Languages](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/domain-specific-languages.md) — Provides a flexible framework for creating specialized languages with custom operators, syntax, and restricted environments.
- [Script Variable Management](https://awesome-repositories.com/f/programming-languages-runtimes/programming-language-varieties/domain-specific-languages/automation-scripting/script-variable-management.md) — Implements mechanisms for defining, storing, and overriding variables within the scripting environment. ([source](https://rhai.rs/book/language/variables.html))
- [Sandboxed Code Execution Environments](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-execution-environments/runtime-environments/runtimes/sandboxed-code-execution-environments.md) — Provides a restricted execution environment with resource limits to securely run untrusted code.
- [Runtime Stability Guards](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-stability-guards.md) — Prevents stack overflows and runaway execution to ensure host stability when running untrusted code. ([source](https://rhai.rs/book/about/features.html))
- [Runtime Type Identification](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-type-identification.md) — Provides utilities to determine the data type of a value during script execution. ([source](https://rhai.rs/book/language/dynamic.html))
- [Runtime Type Inspection](https://awesome-repositories.com/f/programming-languages-runtimes/runtime-type-inspection.md) — Provides utilities to determine the underlying data type of a dynamic value during runtime execution. ([source](https://rhai.rs/book/language/dynamic.html))
- [Source Code Modularization](https://awesome-repositories.com/f/programming-languages-runtimes/source-code-modularization.md) — Organizes script logic into dynamically loadable modules to manage large codebases. ([source](https://rhai.rs/book/about/features.html))
- [Dynamic Variable Assignments](https://awesome-repositories.com/f/programming-languages-runtimes/type-assignments/dynamic-variable-assignments.md) — Supports a dynamically typed environment where variables can change types during execution. ([source](https://rhai.rs/book/language/dynamic.html))
- [Variable Assignments](https://awesome-repositories.com/f/programming-languages-runtimes/variable-assignments.md) — Provides core language primitives for binding values to identifiers via assignment operators. ([source](https://rhai.rs/book/language/assignment.html))
- [Anonymous Functions](https://awesome-repositories.com/f/programming-languages-runtimes/anonymous-functions.md) — Supports the definition of anonymous functions that capture surrounding scope to persist state. ([source](https://rhai.rs/book/language/fn-anon.html))
- [Binary Blob Management](https://awesome-repositories.com/f/programming-languages-runtimes/binary-blob-management.md) — Provides utilities for creating and manipulating raw binary blob objects that grow and shrink dynamically. ([source](https://rhai.rs/book/language/blobs.html))
- [Binary Data Conversions](https://awesome-repositories.com/f/programming-languages-runtimes/binary-data-conversions.md) — Transforms raw byte arrays into integer arrays or UTF-8 strings for further processing. ([source](https://rhai.rs/book/language/blobs.html))
- [Binary Data Writing](https://awesome-repositories.com/f/programming-languages-runtimes/binary-data-writing.md) — Encodes strings as byte streams and writes integers in specific endian orders into binary positions. ([source](https://rhai.rs/book/language/blobs.html))
- [Binary Size Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/binary-size-optimizations.md) — Prunes unused types and language features during compilation to reduce the final executable binary size. ([source](https://rhai.rs/book/start/builds/minimal.html))
- [Byte Sequence Handling](https://awesome-repositories.com/f/programming-languages-runtimes/byte-sequence-handling.md) — Provides low-level manipulation of raw byte arrays, including padding, truncating, and concatenation. ([source](https://rhai.rs/book/language/blobs.html))
- [Byte Stream Manipulations](https://awesome-repositories.com/f/programming-languages-runtimes/byte-stream-manipulations.md) — Implements operations on binary objects including slicing, padding, reversing, and draining bytes. ([source](https://rhai.rs/book/language/blobs.html))
- [Constant-Folding Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-constants/constant-folding-optimizations.md) — Implements compiler optimizations that evaluate expressions with constant operands at compile time to simplify the AST.
- [Constant Folding Prevention](https://awesome-repositories.com/f/programming-languages-runtimes/compile-time-constants/constant-folding-prevention.md) — Allows marking native functions as volatile to prevent constant folding during compilation. ([source](https://rhai.rs/book/engine/optimize/volatility.html))
- [Dead Code Elimination Engines](https://awesome-repositories.com/f/programming-languages-runtimes/compiler-interpreter-internals/compiler-toolchains/optimization-frameworks/static-analysis-optimizers/dead-code-elimination-engines.md) — Removes expressions and statements without side effects during compilation to reduce script size and overhead. ([source](https://rhai.rs/book/engine/optimize/dead-code.html))
- [Custom Operator Implementations](https://awesome-repositories.com/f/programming-languages-runtimes/custom-operator-implementations.md) — Maps host functions to symbols or overloaded names to provide language-level operator overloading for custom types. ([source](https://rhai.rs/book/plugins))
- [Operator Binding Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/custom-operator-implementations/operator-binding-definitions.md) — Assigns custom symbols to operations with specific binding strengths to control how expressions are parsed. ([source](https://rhai.rs/book/engine/custom-op.html))
- [Evaluatable Syntax Extensions](https://awesome-repositories.com/f/programming-languages-runtimes/custom-syntax-handlers/evaluatable-syntax-extensions.md) — Registers new expression patterns and statement types that are parsed and evaluated via a callback. ([source](https://rhai.rs/book/engine/dsl.html))
- [String Deduplication](https://awesome-repositories.com/f/programming-languages-runtimes/dynamic-strings/memory-management/string-storage-strategies/string-deduplication.md) — Stores unique strings only once to reduce memory consumption when handling high volumes of text data. ([source](https://rhai.rs/book/engine/raw.html))
- [Execution Context Management](https://awesome-repositories.com/f/programming-languages-runtimes/expression-evaluators/runtime-context-evaluators/execution-context-management.md) — Modifies the current execution context, including variable scopes and call depth, during script evaluation. ([source](https://rhai.rs/book/engine/eval-context.html))
- [Explicit This Binding Techniques](https://awesome-repositories.com/f/programming-languages-runtimes/function-context-binding/explicit-this-binding-techniques.md) — Allows associating a specific object with a function call to serve as the internal this context. ([source](https://rhai.rs/book/language/fn-ptr.html))
- [Function Metadata Inspection](https://awesome-repositories.com/f/programming-languages-runtimes/function-metadata-inspection.md) — Provides utilities to analyze high-level properties of functions, including parameters and documentation. ([source](https://rhai.rs/book/language/fn-metadata.html))
- [Host-Linked Property Definitions](https://awesome-repositories.com/f/programming-languages-runtimes/host-linked-property-definitions.md) — Maps script property access to specific host functions to handle the retrieval and modification of data. ([source](https://rhai.rs/book/rust/getters-setters.html))
- [Host-Script Scope Sharing](https://awesome-repositories.com/f/programming-languages-runtimes/host-script-scope-sharing.md) — Passes host values into scripts as variables or constants without requiring specialized trait implementations. ([source](https://rhai.rs/book/about/features.html))
- [Scope Constant Injections](https://awesome-repositories.com/f/programming-languages-runtimes/immutable-constant-definitions/scope-constant-injections.md) — Adds predefined values or custom types into a script execution environment as immutable references. ([source](https://rhai.rs/book/language/constants.html))
- [Volatile Function Declarations](https://awesome-repositories.com/f/programming-languages-runtimes/immutable-constant-definitions/volatile-function-declarations.md) — Prevents the optimizer from evaluating functions with unstable return values during the compilation process. ([source](https://rhai.rs/book/plugins))
- [Language Feature Restrictions](https://awesome-repositories.com/f/programming-languages-runtimes/language-feature-restrictions.md) — Limits scripts to expressions or removes keywords to prevent the use of dangerous language features. ([source](https://rhai.rs/book/engine/dsl.html))
- [Ownership Transfer](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/ownership-borrowing/ownership-transfer.md) — Transfers data ownership during assignment to avoid the cost of cloning large objects. ([source](https://rhai.rs/book/language/assignment.html))
- [Looping Restrictions](https://awesome-repositories.com/f/programming-languages-runtimes/looping-constructs/looping-restrictions.md) — Enables the blocking of loop and while constructs to guarantee that scripts terminate. ([source](https://rhai.rs/book/engine/disable-looping.html))
- [Mixed-Type Arrays](https://awesome-repositories.com/f/programming-languages-runtimes/mixed-type-arrays.md) — Provides support for ordered lists of mixed types with built-in methods to grow, shrink, and access elements. ([source](https://rhai.rs/book/language/arrays.html))
- [Operator Overloading](https://awesome-repositories.com/f/programming-languages-runtimes/operator-overloading.md) — Allows replacing built-in arithmetic or comparison operations by registering host functions under operator names. ([source](https://rhai.rs/book/rust/operators.html))
- [Parser Service Exposure](https://awesome-repositories.com/f/programming-languages-runtimes/parser-service-exposure.md) — Exposes the tokenizer and parser as services to allow the definition of custom syntax and operators at runtime. ([source](https://rhai.rs/book/about/non-design.html))
- [Pure Functions](https://awesome-repositories.com/f/programming-languages-runtimes/pure-functions.md) — Allows marking methods as pure to enable operations on constant values without triggering mutation errors. ([source](https://rhai.rs/book/plugins))
- [Reference-Based Data Access](https://awesome-repositories.com/f/programming-languages-runtimes/reference-based-data-access.md) — Allows the host to obtain references to internal script data to avoid ownership transfer of dynamic values. ([source](https://rhai.rs/book/language/dynamic-rust.html))
- [Script Execution Termination](https://awesome-repositories.com/f/programming-languages-runtimes/script-execution-termination.md) — Allows the host application to manually terminate long-running scripts to ensure system stability. ([source](https://rhai.rs/book/about/features.html))
- [Script Unit Composition](https://awesome-repositories.com/f/programming-languages-runtimes/script-unit-composition.md) — Allows grouping multiple functions and scripts into a single unified execution unit via AST merging. ([source](https://rhai.rs/book/language/modules))
- [Strict Variable Checking](https://awesome-repositories.com/f/programming-languages-runtimes/strict-variable-checking.md) — Validates that all variables are defined during compilation to prevent runtime errors from missing definitions. ([source](https://rhai.rs/book/language/variables.html))
- [Syntax and Variable Error Detection](https://awesome-repositories.com/f/programming-languages-runtimes/undefined-behavior-detection/memory-and-concurrency-error-detection/syntax-and-variable-error-detection.md) — Detects undefined variables and missing imports during compilation to prevent runtime failures. ([source](https://rhai.rs/book/engine/strict-var.html))
- [Assignment Optimizations](https://awesome-repositories.com/f/programming-languages-runtimes/variable-assignments/assignment-optimizations.md) — Rewrites simple assignment expressions into compound assignments to reduce memory cloning and increase speed. ([source](https://rhai.rs/book/engine/optimize/rewrite.html))

### Data & Databases

- [Native Type Mappings](https://awesome-repositories.com/f/data-databases/type-mapping-frameworks/script-to-native-type-mappings/native-type-mappings.md) — Transforms native Rust data types, including primitives and collections, into a dynamic format compatible with the script engine. ([source](https://rhai.rs/book/language/dynamic-rust.html))
- [Data Serialization](https://awesome-repositories.com/f/data-databases/data-processing-pipelines/data-serialization.md) — Provides mechanisms for encoding and parsing script data types into external formats using standardized frameworks. ([source](https://cdn.jsdelivr.net/gh/rhaiscript/rhai@main/README.md))
- [Binary Object Storage](https://awesome-repositories.com/f/data-databases/object-storage-services/binary-object-chunkers/binary-object-storage.md) — Handles packed arrays of bytes as large binary objects for efficient raw data storage. ([source](https://rhai.rs/book/language/blobs.html))

### Development Tools & Productivity

- [Global Function Registrations](https://awesome-repositories.com/f/development-tools-productivity/debugging-profiling-testing/debugging-diagnostics/debugging-inspection-tools/debugging-and-inspection-tools/runtime-debugging/global-function-registrations.md) — Registers native functions into a shared global namespace for direct access within scripts without requiring imports. ([source](https://rhai.rs/book/language/fn-namespaces.html))
- [Stripped-Down Engine Configurations](https://awesome-repositories.com/f/development-tools-productivity/application-installers/installation-footprint-reducers/runtime-footprint-reducers/minimal-runtime-footprints/minimal-runtime-environments/stripped-down-engine-configurations.md) — Allows creation of a minimal engine environment with basic arithmetic and logic to reduce binary footprint. ([source](https://rhai.rs/book/engine/raw.html))
- [Runtime Behavior Configuration](https://awesome-repositories.com/f/development-tools-productivity/configuration-parsers/runtime-behavior-configuration.md) — Allows modifying application behavior at runtime by executing script-based rules without recompiling the binary.
- [Custom Language Definitions](https://awesome-repositories.com/f/development-tools-productivity/custom-language-definitions.md) — Provides a framework for defining new language parsers and symbol recognition rules for domain-specific languages. ([source](https://rhai.rs/book/engine/custom-syntax-arbitrary-text.html))
- [Custom Parser Definitions](https://awesome-repositories.com/f/development-tools-productivity/custom-parser-definitions.md) — Provides specifications for recognizing language objects and handling non-standard constructs using user-defined state. ([source](https://rhai.rs/book/engine/custom-syntax-parsers.html))
- [Syntax Parser Interceptions](https://awesome-repositories.com/f/development-tools-productivity/custom-parser-definitions/syntax-parser-interceptions.md) — Allows the engine to register mini-parsers that handle non-standard syntax and custom operators.
- [AST Code Pruning](https://awesome-repositories.com/f/development-tools-productivity/dependency-analysis-tools/code-dependency-analysis/unused-code-identification/ast-code-pruning.md) — Removes unreachable code blocks and propagates constants within the compiled AST before evaluation. ([source](https://rhai.rs/book/engine/optimize/reoptimize.html))

### Operating Systems & Systems Programming

- [Native Type Bridges](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/system-programming-primitives/system-abstractions/native-interoperability-bindings/native-system-integrations/native-api-bridges/native-type-bridges.md) — Provides a dynamic layer and bridge for any native type that supports cloning to be used in scripts. ([source](https://rhai.rs/book/about/non-design.html))
- [Dynamic Library Loading](https://awesome-repositories.com/f/operating-systems-systems-programming/dynamic-library-loading.md) — Provides the ability to load shared libraries at runtime to extend the engine's functionality. ([source](https://rhai.rs/book/engine/dynamic-lib.html))

### Security & Cryptography

- [Execution Sandboxes](https://awesome-repositories.com/f/security-cryptography/execution-sandboxes.md) — Implements an isolated runtime environment that restricts scripts from mutating the host or causing stack overflows. ([source](https://cdn.jsdelivr.net/gh/rhaiscript/rhai@main/README.md))

### Software Engineering & Architecture

- [AST Optimization Compilers](https://awesome-repositories.com/f/software-engineering-architecture/abstract-syntax-tree-parsing/ast-optimization-compilers.md) — Transforms script source code into an optimized abstract syntax tree for efficient repeated execution.
- [Native Function Bindings](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/design-patterns/functional-design-patterns/functional-programming/closures/function-to-closure-coercions/native-function-closures/native-function-bindings.md) — Creates script-accessible function pointers that trigger native host functions or closures. ([source](https://rhai.rs/book/language/fn-ptr.html))
- [Custom Scripting Functions](https://awesome-repositories.com/f/software-engineering-architecture/custom-scripting-engines/custom-scripting-functions.md) — Triggers functions defined within a script from the host application to execute custom logic. ([source](https://cdn.jsdelivr.net/gh/rhaiscript/rhai@main/README.md))
- [Custom Type Method Registration](https://awesome-repositories.com/f/software-engineering-architecture/custom-type-method-registration.md) — Enables host functions to be registered as methods on custom types, allowing scripts to manipulate native state. ([source](https://rhai.rs/book/rust/methods.html))
- [Sandbox Resource Caps](https://awesome-repositories.com/f/software-engineering-architecture/resource-usage-caps/sandbox-resource-caps.md) — Prevents resource exhaustion and stack overflows by tracking execution progress and capping operation counts in a sandbox.
- [Keyword and Operator Restrictions](https://awesome-repositories.com/f/software-engineering-architecture/syntax-tree-analysis/language-syntax-parsers/keyword-and-operator-restrictions.md) — Provides the ability to disable specific keywords or operators to create constrained, domain-specific language surfaces. ([source](https://rhai.rs/book/about/features.html))
- [Dynamic Typing](https://awesome-repositories.com/f/software-engineering-architecture/typed-value-systems/dynamic-typing.md) — Implements a dynamic typing system allowing variables to hold various built-in datatypes interchangeably at runtime. ([source](https://rhai.rs/book/language/dynamic.html))
- [Script-to-Native Closure Wrappers](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/design-patterns/functional-design-patterns/functional-programming/closures/function-to-closure-coercions/script-to-native-closure-wrappers.md) — Wraps scripted functions into native closures to be used as callbacks within the host application. ([source](https://rhai.rs/book/engine/func.html))
- [Execution State Serializers](https://awesome-repositories.com/f/software-engineering-architecture/configuration-serializers/execution-state-serializers.md) — Converts global variables and constants into a serializable format to save and restore the execution environment. ([source](https://rhai.rs/book/engine/scope.html))
- [Engine Behavior Configuration](https://awesome-repositories.com/f/software-engineering-architecture/engine-behavior-configuration.md) — Provides interfaces to modify how the engine handles property access and state tags during runtime evaluation. ([source](https://rhai.rs/book/engine/options.html))
- [Runtime Engine Extensions](https://awesome-repositories.com/f/software-engineering-architecture/extensibility-patterns/protocol-extensions/capability-extensions/runtime-engine-extensions.md) — Allows loading sets of functions and modules into engine instances to share configurations. ([source](https://rhai.rs/book/engine/raw.html))
- [Evaluation Environment Restrictions](https://awesome-repositories.com/f/software-engineering-architecture/function-execution-engines/immutable-function-restrictions/evaluation-environment-restrictions.md) — Enables the creation of restricted evaluation environments with selective functional packages and operators. ([source](https://rhai.rs/book/start/builds/minimal.html))
- [Module Scope Isolation](https://awesome-repositories.com/f/software-engineering-architecture/higher-order-function-wrapping/module-scope-isolation.md) — Encapsulates functions and variables within named modules to isolate scope and prevent naming collisions. ([source](https://rhai.rs/book/language/fn-namespaces.html))
- [Modular Plugin Architectures](https://awesome-repositories.com/f/software-engineering-architecture/modular-plugin-architectures.md) — Enables the creation of extensible software where third parties can add functionality via external scripts and modular code.
- [Dynamic Value Casting](https://awesome-repositories.com/f/software-engineering-architecture/native-bridges/native-script-execution-environments/script-value-exports/dynamic-value-casting.md) — Converts dynamic script values into specific native types using safe or panicking methods. ([source](https://rhai.rs/book/language/dynamic-rust.html))

### System Administration & Monitoring

- [Execution Resource Limiters](https://awesome-repositories.com/f/system-administration-monitoring/request-timeouts/per-attempt-timeouts/execution-resource-limiters.md) — Caps maximum operations, function calls, and memory use to prevent resource exhaustion in the engine. ([source](https://rhai.rs/book/engine/options.html))
- [Script Evaluation Monitoring](https://awesome-repositories.com/f/system-administration-monitoring/activity-monitors/activity-progress-monitors/task-progress-monitors/script-evaluation-monitoring.md) — Tracks the evaluation progress of running scripts and allows the host to terminate execution. ([source](https://cdn.jsdelivr.net/gh/rhaiscript/rhai@main/README.md))
- [Custom Debugging Implementations](https://awesome-repositories.com/f/system-administration-monitoring/custom-debugging-implementations.md) — Implements a debugging interface that hooks custom callbacks to track steps and manage breakpoints. ([source](https://rhai.rs/book/engine/debugging/debugger.html))
- [Stack Trace Inspections](https://awesome-repositories.com/f/system-administration-monitoring/stack-trace-inspections.md) — Provides utilities for retrieving and analyzing runtime call stacks to diagnose execution flow. ([source](https://rhai.rs/book/engine/debugging/index.html))

### Game Development

- [Script Object State Serializations](https://awesome-repositories.com/f/game-development/game-logic-scripting/script-object-state-serializations.md) — Persists the current set of variables and constants to allow saving and restoring the script environment. ([source](https://rhai.rs/book/engine/scope.html))
- [Script State Persistence](https://awesome-repositories.com/f/game-development/game-logic-scripting/script-object-state-serializations/cross-script-state-persistence/script-state-persistence.md) — Stores variables and constants in a dedicated state container to maintain data across multiple script evaluations. ([source](https://rhai.rs/book/engine/scope.html))

### Scientific & Mathematical Computing

- [Arithmetic Operations](https://awesome-repositories.com/f/scientific-mathematical-computing/numerical-mathematical-foundations/arithmetic-number-types/arithmetic-operations.md) — Executes fundamental mathematical operations including addition, subtraction, multiplication, and division. ([source](https://rhai.rs/book/engine/builtin.html))

### Web Development

- [Shared State Captures](https://awesome-repositories.com/f/web-development/host-environment-integration/shared-state-captures.md) — Captures external variables or shared state within closures to let scripts modify data in the host environment. ([source](https://rhai.rs/book/rust/functions.html))