Open-source alternatives to Expression Language

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

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 rang

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

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

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

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

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

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

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

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

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.

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

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

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

Flecs is a high-performance entity component system framework and data-oriented programming library. It serves as a simulation engine core and game engine architecture tool, decoupling state from behavior by separating entities, components, and systems. The framework features a runtime reflection layer for dynamic data inspection and a built-in scripting system for defining entity behavior without recompilation. It also includes a network interface and REST API for remote simulation administration and state querying. The library covers a broad surface of simulation capabilities, including ar

Mapshaper is a tool for processing, simplifying, and converting geographic vector data, available as a command-line interface, a web browser tool, and a Node.js library. It functions as a coordinate projector, vector data converter, and web map asset optimizer designed to transform spatial datasets between different coordinate reference systems and file formats. The project is distinguished by its topology-preserving geometry simplification, which reduces vertex counts while maintaining shared boundaries to prevent gaps and overlaps. It further optimizes assets for the web through coordinate

TFLint is a static analysis tool and infrastructure-as-code validator designed to identify errors and enforce best practices within Terraform configuration files. It functions as a quality gate for automated workflows and a language server that provides real-time diagnostics and linting errors directly within supported text editors. The project utilizes a gRPC plugin framework that allows for the integration of custom provider-specific validation rules via independent binaries and a dedicated SDK. This architecture separates core linting logic from cloud-specific validation, supporting the au

tfsec is a static analysis tool and security scanner for Terraform configuration files. It functions as an infrastructure as code security scanner and compliance linter designed to detect misconfigurations and vulnerabilities across multiple cloud providers before resources are deployed. The tool identifies security risks by analyzing infrastructure code and variable files to evaluate the final state of the environment. It supports custom policy enforcement and allows for the suppression of specific security warnings through inline comments. Its capabilities cover cloud security posture mana

Alice is a PHP test data generator and fixture library used to automate the creation of large sets of fake objects and entities. It functions as an object hydrator and random data provider, allowing users to define the structure and attributes of dummy test data in markup or arrays to simulate specific application states. The library distinguishes itself through a template-based system that supports fixture inheritance to reduce data duplication. It utilizes a flexible instantiation model that allows for custom factory integration, method invocation, and property hydration via reflection or c

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

rgthree-comfy is a collection of custom nodes and interface enhancements designed to automate and organize generative AI workflows within ComfyUI. It provides a specialized toolset for node-based automation, dynamic data routing, and graph management. The project distinguishes itself through a dynamic data router and workflow management tools that enable bulk muting, bypassing, and navigation of complex node graphs via bookmarks and visual labels. It also includes logic and math nodes for evaluating expressions and image processing utilities for side-by-side comparisons and precise cropping.

gojq is a JSON query engine and transformation tool implemented in Go. It serves as a Go language port of the jq command, providing a library for embedding JSON and YAML manipulation capabilities directly into Go applications. The tool functions as an arbitrary-precision JSON processor, performing mathematical operations on large integers to prevent precision loss or numeric overflow during data transformations. Its broader capabilities include filtering and reshaping structured data using a specialized query language, converting between YAML and JSON formats, and formatting date and time st

Blade-build is a multi-language build system and software orchestrator designed to automate the compilation, linking, and testing of complex codebases. It functions as an incremental build engine that models project structures as directed acyclic graphs, ensuring that only affected modules are recompiled when source code or header files change. By utilizing declarative build specifications, the system provides a unified approach to managing dependencies and toolchains across diverse programming environments. The system distinguishes itself through a focus on hermetic build environments and re

next-mdx-remote is a rendering library for Next.js that serializes and renders MDX content from remote sources. It functions as a secure MDX compiler and remote content serializer, transforming MDX strings from external APIs or databases into a format compatible with client-side hydration. The library distinguishes itself through a secure compilation process that restricts JavaScript execution and global variable access to prevent remote code execution. It utilizes a custom component mapper to replace standard HTML elements in markdown with specific React components, allowing for dynamic cont