Projects sharing features with QLExpress

Easy-rules is a Java business rules engine designed for defining and evaluating conditional logic and actions. It serves as a framework for organizing simple logic units into complex hierarchies of composite rules and acting as an iterative rule processor. The system functions as an expression language rules engine, allowing rule conditions and actions to be defined via dynamic expressions rather than static compiled code. This enables the configuration of business logic that can change application behavior without requiring source code recompilation. The engine supports fact-based matching

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.

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

Wren is a bytecode-compiled, class-based scripting language designed as an embeddable programming language. It provides a lightweight runtime and interface for executing dynamic scripts directly within host software applications. The engine utilizes a single-pass compiler to transform source code into compact bytecode and a virtual machine to process those instructions. It supports concurrent task execution through a system of lightweight fibers and coroutines. The language implements a class-based object model with dynamic message dispatch for organizing code into reusable components. It al

This project is a Python-based business rules engine designed to decouple application logic from source code. It provides a framework for defining and executing dynamic conditional logic, allowing system behavior to be determined by data criteria rather than hard-coded instructions. The system distinguishes itself by offering a declarative policy framework that utilizes a domain-specific language to manage complex rules. By mapping internal object attributes to dynamic variables and registering executable actions, the engine enables the creation of automated decision-making workflows that can

cel-go is a Go implementation of the Common Expression Language, providing a type-safe engine for the evaluation of non-Turing complete, side-effect-free expressions. It functions as an embedded expression engine that converts human-readable strings into type-checked abstract syntax trees to ensure safe execution. The system utilizes a compile-once evaluate-many model, parsing and validating expressions into cached programs for repeated execution across different datasets. It further distinguishes itself as a partial state evaluator, using commutative logic to compute results and return resid

vm2 is a Node.js JavaScript sandbox and runtime virtualizer designed to execute untrusted code. It functions as a secure code evaluator and module isolator that protects the host process by creating an isolated execution environment with restricted access to the Node.js runtime. The system distinguishes itself through a security framework that utilizes object proxying and deep freezing to prevent sandboxed scripts from modifying the host global context or shared objects. It implements strict module access control using allow-lists and path restrictions to govern which built-in or external dep

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

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

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

Arize Phoenix is an LLM observability platform and evaluation framework designed to capture execution traces and monitor large language model applications. It serves as a prompt management system for versioning and testing templates, and as a self-hosted AI operations infrastructure for managing telemetry and experiments. The platform differentiates itself through a specialized embedding visualization tool used to detect data drift and optimize vector search. It provides a comprehensive evaluation suite that utilizes judge-based evaluators and ground-truth datasets to score model outputs, and

Luau is a high-performance programming language evolved from Lua 5.1. It consists of a bytecode virtual machine, an embeddable scripting engine, and a static code analyzer designed to provide a secure, sandboxed execution environment for host applications. The project is distinguished by its gradual typing system, which combines automatic type inference with optional manual annotations to detect bugs without requiring full static typing. It also features native vector mathematics for high-performance operations and a specialized debugging system that uses bytecode patching to minimize executi

This project is a comprehensive Lisp AI implementation library that provides reference implementations for various artificial intelligence paradigms and symbolic algorithms. It functions as a multi-purpose toolkit containing a logic programming engine, a natural language processing suite, and a symbolic mathematics toolkit. The library is distinguished by its diverse architectural frameworks, including a Prolog-style execution engine that uses unification and goal-driven backtracking, and a system for simulating human decision-making through expert system shells and certainty factors. It also

This project is a business rules management system and rule engine designed to define, execute, and manage complex business logic decoupled from application source code. It provides a business logic compiler that transforms human-readable rule definitions into executable models for high-performance runtime evaluation. The system includes a complex event processing engine for analyzing real-time data streams to identify temporal patterns and a decision model and notation executor that processes structured logic based on industry standards for deterministic results. It utilizes an inference eng

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

This project is a business rules and complex event processing engine designed to manage logical decision-making and stateful workflows. It functions as a computational framework that evaluates incoming data streams and facts against conditional logic to derive new conclusions and trigger automated actions. The engine distinguishes itself through a combination of forward-chaining inference and deterministic state machine orchestration. It uses salience-based conflict resolution to prioritize rule execution and supports persistent contextual state tracking to manage long-running business proces

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

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

Flowable Engine is a business process management platform and workflow engine used to automate business processes and orchestrate human and system activities. It provides a suite for modeling, deploying, and executing complex workflows and decision rules across distributed environments, including a dedicated case management system for unstructured processes and ad-hoc activities. The platform is a Kubernetes native workflow orchestrator that can be deployed as a containerized service using manifests and Helm charts. It supports an embedded runtime model, allowing the engine to integrate as a

Expr is a statically typed expression engine and domain-specific language for parsing and evaluating dynamic logic strings within Go applications. It functions as a bytecode expression evaluator that executes compiled logic with guaranteed termination and memory safety. The engine utilizes a specialized compiler and virtual machine to achieve high-performance execution. It employs static type validation during the compilation phase to ensure operand compatibility and prevent runtime crashes. The project provides a data transformation engine capable of mapping, filtering, and aggregating coll

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

V8 is a high-performance JavaScript and WebAssembly engine designed to compile and execute code within host applications. It functions as an embeddable scripting engine and just-in-time compiler, providing a portable library for integrating dynamic script execution into native software environments. The engine incorporates a WebAssembly runtime to execute compiled binary code for a stack-based virtual machine at near-native speeds. It enables native application scripting by allowing a JavaScript execution environment to be embedded directly into a native program to handle dynamic logic. The

ChakraCore is an embeddable JavaScript engine and high-performance scripting runtime. It provides a just-in-time compiler that converts JavaScript source code into optimized machine code during runtime to increase execution speed and throughput. The engine utilizes a multi-tiered compilation pipeline and tiered machine code generation to balance startup time with execution speed. Memory is managed via a concurrent garbage collector that reclaims unreachable objects on background threads to minimize application pauses. The project provides capabilities for embedded JavaScript execution and au

imove is a visual workflow engine and low-code logic designer that allows for the creation of executable business rules via flowcharts. It functions as an event-driven process orchestrator, triggering specific logical sequences based on user interface interactions or external network signals. The platform operates as a node-based automation system where data is processed through a chain of discrete, parameterizable code modules. It converts graphical flowchart representations into executable logic steps for both server and client-side processing. The system supports modular logic engineering

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

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

Aviatorscript is a high-performance scripting language and expression evaluation engine designed for integration within Java applications. It enables the dynamic execution of mathematical and logical formulas by compiling script instructions directly into Java bytecode at runtime. The engine distinguishes itself by transforming dynamic logic into machine-readable instructions, allowing for near-native execution speeds. It includes a built-in caching mechanism that stores compiled bytecode to eliminate redundant parsing and compilation overhead during repeated formula execution. This library