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
·
microsoft avatar

microsoft/RulesEngine

0
View on GitHub↗
4,299 stars·614 forks·C#·MIT·17 viewsmicrosoft.github.io/RulesEngine↗

RulesEngine

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 covers automated workflow orchestration, complex condition validation, and the evaluation of standalone logic expressions. It includes capabilities for parameter aliasing to simplify long rule definitions and triggers specific events or actions based on rule evaluation outcomes.

Features

  • Runtime .NET - Provides a .NET business logic evaluator for executing complex rule workflows and dynamic expressions.
  • Business Rule Evaluation - Computes results using predefined logic policies and input data to determine if specific conditions are met.
  • External Rule Management - Stores business rules as structured data in external files or databases to update policies at runtime.
  • Dynamic Logic Configuration - Updates application behavior and policy rules using JSON without needing to recompile or redeploy code.
  • Automated Workflow Orchestration - Orchestrates sequences of conditional rules to trigger specific events or actions based on input data.
  • Expression Evaluators - Provides an engine for processing mathematical and logical expressions against data at runtime.
  • Dynamic Logic Evaluators - Provides a tool for parsing and computing standalone logical expressions and data queries within a .NET environment.
  • General Purpose JSON Rule Engines - Provides a system for defining and storing logic policies in JSON format to change application behavior without recompiling.
  • Dynamic Rule Engines - Functions as a dynamic rule engine that evaluates custom logic and validations at runtime without requiring recompilation.
  • Externalized Logic Frameworks - Provides a framework for decoupling business rules from source code by loading policies from external files or databases.
  • Externalized Logic Schemas - Enables loading rule definitions from external sources to update policies without requiring a full application redeploy.
  • Externalized Policy Management - Decouples decision logic from source code by loading policies from external files or databases.
  • Rule Chain Workflows - Implements sequential rule execution where results trigger subsequent logic steps.
  • Workflow Orchestration - Executes a sequence of rules against input objects to determine which specific conditions are triggered.
  • Conditional Logic Evaluation - Evaluates multi-step logical requirements and data dependencies to verify business criteria.
  • Runtime Logic Parsing - Provides runtime parsing of string-based logic statements into executable operations against input data.
  • Fact-Based Rule Triggering - Triggers success or failure events by matching rule conditions against runtime data facts.
  • Rule-Driven Action Triggers - Automatically runs specific code or chains additional rules after a result is determined.
  • Rule Engine Type Injections - Allows registering custom classes or types to make their properties and methods available within rule expressions.
  • Evaluator Logic Extensions - Supports registering external classes and methods to perform complex evaluations that exceed standard expression capabilities.
  • JSON Policy Definitions - Allows specifying business logic and policies using a JSON data format that supports custom expressions and query operations.
  • Expression Parameter Aliasing - Simplifies complex data identifiers with named labels to enhance the maintainability of rule definitions.
  • Expression Simplifications - Provides the ability to break down large logical statements into smaller, reusable intermediate expressions within rule definitions.
  • Input Parameter Mapping - Allows assigning context-specific names to input data sources to replace generic identifiers with meaningful labels.
  • Reflection-Based Property Accessors - Uses reflection-based property accessors to expose external class properties and methods to the engine.
  • Rule Parameter Aliasing - Replaces complex expressions with global or local aliases to improve the maintainability of long rule definitions.

Star history

Star history chart for microsoft/rulesengineStar history chart for microsoft/rulesengine

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

Frequently asked questions

What does microsoft/rulesengine do?

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.

What are the main features of microsoft/rulesengine?

The main features of microsoft/rulesengine are: Runtime .NET, Business Rule Evaluation, External Rule Management, Dynamic Logic Configuration, Automated Workflow Orchestration, Expression Evaluators, Dynamic Logic Evaluators, General Purpose JSON Rule Engines.

What are some open-source alternatives to microsoft/rulesengine?

Open-source alternatives to microsoft/rulesengine include: knetic/govaluate — govaluate is a Go expression evaluator and runtime logic parser. It functions as a dynamic rule engine that converts… cachecontrol/json-rules-engine — This project is a rule-based decision system that decouples complex business logic from application code by… symfony/expression-language — The expression-language is a lightweight calculation component and parser tool that compiles and evaluates single-line… antonmedv/expr — Expr is a high-performance expression evaluation engine and language for Go applications. It functions as a dynamic… expr-lang/expr — Expr is a statically typed expression engine and domain-specific language for parsing and evaluating dynamic logic… killme2008/aviatorscript — Aviatorscript is a high-performance scripting language and expression evaluation engine designed for integration…

Open-source alternatives to RulesEngine

Similar open-source projects, ranked by how many features they share with RulesEngine.
  • knetic/govaluateKnetic avatar

    Knetic/govaluate

    3,940View on GitHub↗

    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

    Goevaluationexpressiongo
    View on GitHub↗3,940
  • cachecontrol/json-rules-engineCacheControl avatar

    CacheControl/json-rules-engine

    3,088View on GitHub↗

    This project is a rule-based decision system that decouples complex business logic from application code by representing rules as portable, structured data. It functions as a business logic engine that evaluates nested boolean conditions to determine application outcomes based on dynamic inputs. The engine distinguishes itself by supporting the asynchronous resolution of external data, allowing it to fetch and inject real-time facts into the evaluation process at runtime. It utilizes a recursive evaluation model to process hierarchical rule sets and triggers event-driven actions immediately u

    JavaScriptbusiness-rulesenginejson
    View on GitHub↗3,088
  • symfony/expression-languagesymfony avatar

    symfony/expression-language

    2,848View on GitHub↗

    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

    PHPcomponentphpsymfony
    View on GitHub↗2,848
  • antonmedv/exprantonmedv avatar

    antonmedv/expr

    7,905View on GitHub↗

    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

    Go
    View on GitHub↗7,905
See all 30 alternatives to RulesEngine→