Open-source alternatives to Aviatorscript

govaluate is a Go expression evaluator and runtime logic parser. It functions as a dynamic rule engine that converts string-based expressions into executable operations, allowing for the calculation of mathematical and logical expressions at runtime. The library enables the execution of business rules and custom formulas without recompiling source code. It supports extending evaluation behavior through the injection of external parameters and the execution of user-defined custom functions. The system provides capabilities for dynamic data validation, including regular expression matching and

The expression-language is a lightweight calculation component and parser tool that compiles and evaluates single-line string expressions against runtime variables. It functions as an expression engine that parses logical expressions into executable code or evaluates them directly against provided variables and functions to power dynamic rule evaluation and configuration. The engine features a complete architecture covering lexical tokenisation, intermediate code generation, and execution caching. It parses expression strings into hierarchical abstract syntax trees to enable programmatic insp

Expr is a high-performance expression evaluation engine and language for Go applications. It functions as a dynamic rule engine that parses and executes custom logic and data validations at runtime without requiring the application to be recompiled. The system utilizes a sandboxed logic executor to run expressions without side effects. It ensures program termination by employing instruction-level loop detection to prevent infinite loops and isolates the evaluation process from the host system. The engine employs a bytecode-based virtual machine and abstract syntax tree analysis to achieve ex

RulesEngine is a business logic evaluator for .NET that executes complex rule workflows and dynamic expressions against input data. It functions as a dynamic expression evaluator and an externalized logic framework, allowing the definition and management of business rules in JSON format to change application behavior without recompiling code. The project decouples decision logic from source code by loading policies from external files or databases. It supports the registration of custom classes and methods to extend standard expression capabilities through type injection. The framework cover

Liteflow is a component-based rule engine and workflow orchestrator used to define business logic through a chain of reusable components. It utilizes a structured data language to map logic paths, functioning as a dynamic workflow engine for managing sequences of synchronous and asynchronous tasks. The project is distinguished by its support for hot deployment, allowing rule definitions and execution logic to be updated in real time without restarting the application. It also features a multi-language scripting engine that embeds external scripts into business rules to enable flexible logic c

HCL is a configuration language implementation designed for parsing, evaluating, and encoding structured settings through the use of blocks and attributes. It functions as a configuration AST parser and a schema-based decoder that maps attributes and blocks to internal data structures using predefined rules. The project includes an expression evaluation engine that resolves dynamic values and cross-references through multi-phase processing of variables and functions. It also provides a configuration file formatter to standardize the layout and indentation of source code for consistent visual

LuaJIT is a high-performance Lua language implementation and just-in-time compiler. It functions as an embedded scripting engine and dynamic binary translator that converts portable bytecode into native machine code during execution. The project focuses on high-performance scripting by translating bytecode into architecture-specific instructions to achieve execution speeds close to compiled C code. It utilizes a lightweight runtime environment designed for minimal memory overhead. The system supports binary data processing via bitwise operations and enables asynchronous task management throu

QLExpress is a dynamic scripting engine and expression language for the Java platform. It functions as a runtime expression evaluator and business rule engine, allowing applications to execute scripts and evaluate business logic without requiring system recompilation. The engine distinguishes itself through a secure scripting sandbox that enforces security policies via class whitelisting and execution timeouts. It supports high-precision mathematics to prevent rounding errors and provides language alias support to create domain-specific languages that resemble natural language. Additional cap

Dhall is a type-safe configuration language designed to create programmable configuration files that are guaranteed to terminate. It is a non-Turing-complete language that uses a strict type system to ensure correctness and prevent infinite loops during evaluation. The project functions as a deterministic configuration engine and marshalling tool, converting programmable expressions into static formats such as JSON, YAML, and Bash. It distinguishes itself through a focus on security and integrity, using semantic hashing to pin remote imports and enforcing origin policies to prevent data exfil

This project is a Lisp interpreter implementation guide and framework designed to teach the core principles of programming language design. It provides a structured, step-by-step technical framework for building a functional Lisp language from scratch, featuring a specialized interpreter engine and an S-expression parser that converts syntax into abstract syntax trees. The project emphasizes a code-as-data metaprogramming framework, enabling the implementation of macros, quoting, and quasiquoting to transform expressions during evaluation. It is designed with host language agnosticism, allowi

The Common Expression Language specification is a formal standard for a non-Turing-complete expression language designed for safe, portable, and fast logic evaluation. It serves as a cross-language logic standard and a declarative policy language, providing a consistent semantic framework for executing boolean expressions and data transformations across different programming environments. This specification acts as an embedded expression engine that allows applications to integrate portable logic for evaluating user-defined configurations. It is specifically designed to enable safe user-defin

Tengo is a dynamic, embeddable scripting language for Go applications that allows for the execution of custom scripts without requiring the host binary to be recompiled. It operates as a bytecode-compiled virtual machine, transforming source code into a compact intermediate representation for execution on a stack-based engine. The system is designed as a secure scripting sandbox, enforcing strict limits on memory allocation and execution time to safely run untrusted code. It supports concurrent script execution by cloning compiled bytecode and using recursive immutability conversion to share

Byte Buddy is a runtime code generation and bytecode manipulation library for Java. It provides a fluent API for creating and modifying Java classes during execution, enabling developers to define class structures, methods, and fields programmatically without requiring a compiler or direct bytecode assembly. The library supports agent-based class transformation, allowing loaded classes to be modified during JVM startup or runtime through a Java agent that intercepts class loading. It offers bytecode-level method interception for fine-grained control over method behavior, annotation-based code

Oils is a Unix shell interpreter and scripting language runtime that combines a modern shell language with POSIX and Bash compatibility. It functions as a structured data shell, integrating JSON and J8 formats to manage complex data without relying on string parsing. The system is distinguished by a C++ transpiled interpreter that converts a subset of Python source code into strongly typed C++ for high-performance execution. It features a garbage-collected typed runtime that supports prototype-based polymorphism, lexical closures, and reference-based variable mutation. To decouple shell logic

Scriban is a .NET text templating engine and embedded scripting language used for dynamic text generation. It functions as an abstract syntax tree manipulation tool and a template parser, allowing for the conversion of scripts into visitable trees for analysis, modification, and rendering. The engine is specifically designed for Native AOT compatibility, utilizing a reflection-free API to execute templates in trimmed environments. It also provides a dedicated parser and conversion system for Liquid templates, enabling the migration and execution of Liquid scripts within .NET. The project cov

Power-Fx is a declarative logic framework and low-code formula language based on Excel formulas. It functions as an expression parser and evaluator that transforms formula strings into an abstract syntax tree to execute logical operations and resolve values. The project provides a standardized integration layer to connect formula-based logic to external data sources for querying and pushing records. This allows for the definition of business rules and calculations that can be shared as consistent logic across different applications and platforms.

Elsa Core is a workflow engine framework designed for defining, executing, and managing long-running business processes. It functions as a distributed workflow orchestrator and event-driven trigger system, capable of operating as a multi-tenant platform with secure data isolation. The project distinguishes itself through a flexible approach to workflow definitions, supporting a visual drag-and-drop designer, programmatic C# definitions, and portable JSON specifications. It provides a highly extensible architecture allowing for the development of custom activities and the use of a dynamic expr

Frege is a purely functional programming language that compiles to JVM bytecode, providing Haskell-like semantics for the Java platform. It is built around a Haskell-inspired compiler that implements non-strict evaluation and a static type inference system to ensure data immutability and prevent side effects. The project distinguishes itself through a sophisticated type system featuring rank polymorphism, type-class based dispatch, and static purity enforcement. It includes a JVM language bridge and a foreign function interface that map Java classes and interfaces into functional types, allow

Scala 3 is an open-source, statically typed programming language that compiles to JVM bytecode, combining object-oriented and functional programming paradigms. Its core identity is defined by a sophisticated type system that includes traits, generics, union types, and a dependent object type system where types can depend on runtime values through path-dependent and singleton types. The language distinguishes itself through several advanced type-level and metaprogramming capabilities. It features a contextual abstraction mechanism using given instances and using clauses for compile-time implic

Luvit is an event-driven runtime for Lua that integrates libuv to provide non-blocking I/O and asynchronous system operations. It functions as an asynchronous network framework and execution environment that leverages Just-In-Time compilation for high-performance script processing. The platform enables the distribution of network traffic across multiple CPU cores through a TCP cluster manager that shares socket handles among child processes. It provides specialized capabilities for building HTTP servers by decoding incoming request streams and encoding responses via a stream processor. The r

sccache is a compiler cache wrapper and distributed compilation cache designed to store and reuse compilation results. It functions as a specialized caching solution for the Rust compiler, as well as a general tool to avoid redundant build cycles and reduce total build time. The project distinguishes itself through a cloud-backed build cache and remote storage backends. It enables the synchronization of build artifacts across multiple machines or team members using distributed memory caches or cloud object storage. Supported storage backends include local file systems, WebDAV, and a wide arr

HyperDbg is a hardware-assisted kernel-mode debugging platform that leverages virtualization to monitor and control system execution. By utilizing hypervisor-level primitives, it enables deep system analysis and instrumentation without relying on standard operating system debugging interfaces. The framework provides a comprehensive environment for inspecting both kernel and user-mode processes, allowing for granular control over execution flow and system state. The project distinguishes itself through a transparent debugging layer designed to remain invisible to the target environment. It emp

babel-loader is a webpack plugin that integrates the Babel compiler into a module bundling workflow. It serves as a bridge that allows modern JavaScript to be transpiled into backward-compatible versions during the build process. The project optimizes bundle sizes by replacing duplicated helper functions with references to a shared external runtime. To accelerate subsequent compilation cycles, it utilizes a filesystem-based cache to store processed files and avoid redundant transpilation. The loader supports environment-specific configuration mapping and target configurations to apply differ

ArrayFire is a hardware-agnostic compute framework and JIT-compiled tensor engine designed for high-performance numerical computing. It serves as a GPU numerical computing library and parallel signal processing toolkit that abstracts hardware backends, allowing the same codebase to execute across various GPU architectures and CPUs. The project distinguishes itself through a JIT engine that uses expression compilation to fuse operations and minimize memory overhead. It employs a deferred execution graph to optimize computation chains and provides interoperability primitives to share data and e

Less.js is a CSS preprocessor and compilation engine that transforms a dynamic stylesheet language into standard CSS for web browser rendering. It functions as a tool to compile extended styling syntax, providing variables, mixins, and functions to create maintainable stylesheets. The project includes a source map generator that creates mapping files to link compiled CSS output back to the original source code for debugging. It allows for the integration of custom plugins and functions to automate the generation of final stylesheets within a build process. The engine supports the compilation

Rhino is a Java-based JavaScript engine that implements an ECMAScript compatibility layer for execution inside a Java virtual machine. It serves as an embedded scripting engine and a scripting bridge, allowing JavaScript code to be integrated and executed within Java applications. The project facilitates direct inter-language communication by mapping Java classes and objects into a JavaScript environment. This integration enables scripts to interact with internal system services and native host objects through a dedicated mapping mechanism. The engine optimizes performance by compiling JavaS