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
j-easy avatar

j-easy/easy-rules

0
View on GitHub↗
github.com/j-easy/easy-rules/wiki↗

Easy Rules

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 to trigger actions when conditions align, utilizing both priority-based sequential processing and iterative execution loops that fire rules until a stable state is reached. It manages these processes through a condition-action pattern and a composite rule hierarchy.

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

Features

  • Business Rules Engine - Provides a full engine for defining, managing, and executing conditional business logic and actions.
  • Java Frameworks - Provides a complete framework for defining and evaluating conditional business logic and actions within Java applications.
  • Business Rule Engines - Allows users to define operational logic using annotations, fluent interfaces, or external descriptors.
  • Fact-Based Rule Triggering - Compares registered rules against collections of data to trigger associated actions when conditions align.
  • Dynamic Expression Languages - Allows rule conditions and actions to be defined via a dynamic expression language for runtime evaluation.
  • Business Rule Composition - Enables combining multiple simple rules into composite structures to organize complex business logic hierarchies.
  • Complex Business Rule Composition - Combines multiple simple rules into composite structures to create sophisticated and layered business logic.
  • Composite Rule Hierarchies - Implements a hierarchy for grouping simple rules into nested composite structures to organize complex business logic.
  • Composite Rules Frameworks - Acts as a system for organizing simple logic units into complex hierarchies of grouped composite rules.
  • Condition-Action Patterns - Provides a condition-action pattern to trigger specific executable behaviors when a set of runtime facts is met.
  • Configuration-Driven Logic - Defines business rules using expression languages to change application behavior without requiring source code recompilation.
  • Expression Languages - Provides an engine for parsing and executing custom business logic defined as strings at runtime.
  • Fact-Based Matching - Matches registered rule predicates against runtime data to determine which actions should be executed.
  • Java-Based Rule Evaluation - Checks data against a set of predefined conditions to trigger specific actions within a Java application.
  • Rule Execution Engines - Implements an execution engine that repeatedly evaluates facts against rules until a stable state is reached.
  • Business Workflow Automation - Organizes nested and composite rules to manage layered logic hierarchies and sequential execution paths.
  • Iterative Fact Processing - Evaluates a set of data repeatedly until all applicable rules have been fired and no further conditions are met.
  • Iterative Rule Evaluation - Evaluates and fires applicable rules repeatedly until no more conditions are met, allowing actions to trigger further executions.
  • Iterative Rule Execution - Implements iterative execution loops that fire applicable rules repeatedly until a stable state is reached.
  • Priority-Based Rule Processing - Executes registered rules in a specific order based on assigned weights or priorities.
  • Sequential Rule Execution - Runs a set of registered rules against facts and triggers actions based on priority and condition matches.
  • General Purpose Orchestration - Simple rules engine for Java-based logic execution.
5,246 stars·1,102 forks·Java·MIT·46 views

Star history

Star history chart for j-easy/easy-rulesStar history chart for j-easy/easy-rules

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Projects sharing features with Easy Rules

These projects share indexed features with Easy Rules. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • venmo/business-rulesvenmo avatar

    venmo/business-rules

    989View on GitHub↗

    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

    Python
    View on GitHub↗989
  • oracle-samples/clara-rulesoracle-samples avatar

    oracle-samples/clara-rules

    1,231View on GitHub↗

    Clara Rules is a declarative logic programming library and business rules management system designed for Clojure and Java applications. It functions as a forward-chaining inference engine that evaluates business logic by matching data patterns against defined rules, allowing developers to derive new information and trigger automated actions based on the current state of a fact set. The engine utilizes a directed acyclic graph for pattern matching, which enables efficient evaluation across complex rule sets. It incorporates a truth maintenance system that tracks dependencies between facts and

    Clojure
    View on GitHub↗1,231
  • alibaba/qlexpressalibaba avatar

    alibaba/QLExpress

    5,597View on GitHub↗

    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

    Java
    View on GitHub↗5,597
  • apache/incubator-kie-droolsapache avatar

    apache/incubator-kie-drools

    6,269View on GitHub↗

    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

    Java
    View on GitHub↗6,269
Compare all 30 related projects→

Frequently asked questions

What does j-easy/easy-rules do?

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.

What are the main features of j-easy/easy-rules?

The main features of j-easy/easy-rules are: Business Rules Engine, Java Frameworks, Business Rule Engines, Fact-Based Rule Triggering, Dynamic Expression Languages, Business Rule Composition, Complex Business Rule Composition, Composite Rule Hierarchies.

Which projects share features with j-easy/easy-rules?

Projects with overlapping indexed features include: venmo/business-rules — This project is a Python-based business rules engine designed to decouple application logic from source code. It… oracle-samples/clara-rules — Clara Rules is a declarative logic programming library and business rules management system designed for Clojure and… alibaba/qlexpress — QLExpress is a dynamic scripting engine and expression language for the Java platform. It functions as a runtime… apache/incubator-kie-drools — This project is a business rules management system and rule engine designed to define, execute, and manage complex… flowable/flowable-engine — Flowable Engine is a business process management platform and workflow engine used to automate business processes and… cachecontrol/json-rules-engine — This project is a rule-based decision system that decouples complex business logic from application code by…