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
hyperjumptech avatar

hyperjumptech/grule-rule-engine

0
View on GitHub↗
2,505 stars·372 forks·Go·29 views

Grule Rule Engine

Grule is a business rule engine for Go that decouples complex decision-making logic from core application code. It provides a framework for defining, versioning, and executing business rules through a domain-specific language, allowing logic to be managed independently of the underlying software implementation.

The engine distinguishes itself by utilizing a formal grammar-based parser and a Rete-inspired pattern matching algorithm to evaluate logic against data facts efficiently. It supports dynamic system modeling by enabling runtime updates to policies and providing thread-safe knowledge base containers, which allow for concurrent rule execution across multiple application threads.

The platform includes comprehensive tools for fact injection, which maps application data structures into the evaluation context, and execution monitoring, which allows for real-time tracing of rule processing and state changes. By incorporating cycle detection and automated rule lifecycle management, the engine ensures that complex, interdependent logic chains remain stable and performant during evaluation.

Features

  • Business Rules Engine - Decouples complex business logic from application code by evaluating data facts against rules defined in a domain-specific language.
  • Rule Evaluation Engines - Executes business rules against data facts to determine outcomes without requiring hard-coded conditional branching logic.
  • Domain Specific Languages - Provides a domain-specific language for defining and executing custom business logic.
  • Rete Algorithm Implementations - Organizes rule conditions into a directed graph to efficiently evaluate logic against data facts.
  • Logic Decoupling - Enables the separation of business logic from core application code, allowing independent management of decision-making processes.
  • Algorithmic Efficiency Optimizers - Applies cycle detection and algorithmic shortcuts to ensure fast and efficient rule evaluation.
  • Rule Knowledge Bases - Organizes and versions collections of business rules to support dynamic systems.
  • Complex Event Processing Engines - Evaluates incoming data streams against predefined logic patterns to trigger automated actions.
  • Rule Definition Languages - Provides a domain-specific language for constructing business rules, enabling logic definition independent of the underlying software implementation.
  • Rule Definition Loaders - Imports business logic from various sources including raw strings, local files, and remote repositories.
  • Dynamic Rule Management - Enables runtime updates to rule sets to adapt to changing business requirements.
  • Domain Specific Language Parsers - Provides a parser for custom logic structures that allow non-developers to manage business requirements.
  • Fact Injection - Maps application data structures into the evaluation context for rule processing.
  • Rule Lifecycle Management - Provides automated lifecycle management for versioned rule libraries to ensure stable and performant execution of complex business logic.
  • Cycle Detection Algorithms - Monitors rule activation sequences to prevent infinite loops during complex logic evaluation.
  • Dynamic Rule Engines - Manages complex interactions between variables and state changes in dynamic environments.
  • Thread-Safe State Containers - Encapsulates rule sets into isolated, thread-safe containers for concurrent execution.
  • Formal Grammar Parser Generators - Generates parsers from formal grammar definitions to translate rule syntax into executable logic.
  • Parser Generators - Generates language-specific parser and visitor source files from grammar definitions.
  • Fact Injection Interfaces - Maps application data structures and JSON objects into the evaluation context for rule execution.

Star history

Star history chart for hyperjumptech/grule-rule-engineStar history chart for hyperjumptech/grule-rule-engine

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.

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

Projects sharing features with Grule Rule Engine

These projects share indexed features with Grule Rule Engine. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • 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
  • pegjs/pegjspegjs avatar

    pegjs/pegjs

    4,908View on GitHub↗

    PegJS is a parsing expression grammar tool and JavaScript parser generator. It functions as a grammar compiler that transforms formal grammar specifications into executable JavaScript code for analyzing structured text and processing complex input strings. The system generates deterministic parsers that avoid the ambiguity of context-free grammars. It utilizes a packrat parsing model with memoization to ensure linear time complexity and employs recursive descent parsing to process input in a top-down hierarchical manner. The toolset supports the implementation of domain-specific languages an

    JavaScript
    View on GitHub↗4,908
  • 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
  • holistics/dbmlholistics avatar

    holistics/dbml

    3,520View on GitHub↗

    DBML is a domain-specific language and schema definition language used for documenting database architecture and design. It provides a human-readable text format for defining database tables, columns, and relationships in a standardized way. The project functions as a relational schema parser and SQL schema generator. It transforms declarative design specifications into an abstract syntax tree for programmatic manipulation and converts these definitions into executable SQL statements across various database dialects. The system covers relational data modeling, database schema design, and arc

    JavaScriptdatabase-schemadbmldbx
    View on GitHub↗3,520
Compare all 30 related projects→

Frequently asked questions

What does hyperjumptech/grule-rule-engine do?

Curated searches featuring Grule Rule Engine

Hand-picked collections where Grule Rule Engine appears.
  • Inference engine
  • Attribute-Based Access Control Libraries

Grule is a business rule engine for Go that decouples complex decision-making logic from core application code. It provides a framework for defining, versioning, and executing business rules through a domain-specific language, allowing logic to be managed independently of the underlying software implementation.

What are the main features of hyperjumptech/grule-rule-engine?

The main features of hyperjumptech/grule-rule-engine are: Business Rules Engine, Rule Evaluation Engines, Domain Specific Languages, Rete Algorithm Implementations, Logic Decoupling, Algorithmic Efficiency Optimizers, Rule Knowledge Bases, Complex Event Processing Engines.

Which projects share features with hyperjumptech/grule-rule-engine?

Projects with overlapping indexed features include: apache/incubator-kie-drools — This project is a business rules management system and rule engine designed to define, execute, and manage complex… pegjs/pegjs — PegJS is a parsing expression grammar tool and JavaScript parser generator. It functions as a grammar compiler that… cachecontrol/json-rules-engine — This project is a rule-based decision system that decouples complex business logic from application code by… holistics/dbml — DBML is a domain-specific language and schema definition language used for documenting database architecture and… antlr/antlr4 — ANTLR is a grammar-based code generator and multi-language parser generator used to design and implement custom… kach/nearley — Nearley is a JavaScript parser toolkit and context-free grammar compiler. It functions as an Earley parser generator…

a declarative automation engine for infrastructure