Rust Rule Engine v0.10.1 🦀⚡

A high-performance rule engine for Rust with RETE-UL algorithm (2-24x faster), CLIPS-inspired features, Plugin System, and GRL (Grule Rule Language) support. Designed for production use with ~97% Drools compatibility.

🔗 GitHub | Documentation | Crates.io

✨ What's New in v0.10.1

🚀 RETE Performance Optimization + Comprehensive Benchmarks!

⚡ RETE Fixed - Eliminated infinite loop issue, now blazing fast
📊 Benchmarked - Comprehensive comparison: Traditional vs RETE
🔥 2-24x Faster - RETE shows 2x speedup at 10 rules, 24x at 50+ rules
✅ Production Ready - Max iterations guard, optimized agenda management
📈 Scalability Proven - ~5µs per rule, scales linearly

See Benchmark Results →

Previous Updates (v0.10.0)

🔧 Function Calls in WHEN - Call AI/custom functions directly in rule conditions
📋 Template System - Type-safe schema definitions for structured facts
🌍 Defglobal - Global variables with thread-safe access
📈 Drools Compatibility - ~97% Drools parity

See Release Notes → | CLIPS Features Guide →

🚀 Key Features

Native Engine

GRL Support - Full Grule-compatible syntax
Function Calls in WHEN - Call functions directly in conditions (NEW in v0.10.0)
Plugin System - 44+ actions, 33+ functions
Knowledge Base - Centralized rule management
Type Safety - Rust's compile-time guarantees
Production Ready - REST API, monitoring, health checks

RETE-UL Engine (Recommended for 50+ rules)

🚀 2-24x Faster - Proven benchmarks vs traditional engine (v0.10.1)
🔥 RETE Algorithm - High-performance pattern matching (~97% Drools parity)
📋 Template System - Type-safe structured facts (v0.10.0)
🌍 Defglobal - Global variables across firings (v0.10.0)
⚡ Incremental Updates - Only re-evaluate affected rules
🧠 Working Memory - FactHandles with insert/update/retract
🎯 Advanced Agenda - Salience, activation groups, no-loop, max iterations guard
🔗 Variable Binding - Cross-pattern $var syntax
💾 Memoization - 99.99% cache hit rate

Choose Your Engine:

< 10 rules → Native Engine (simpler API, plugin support)
10-50 rules → Either (RETE ~2x faster)
50+ rules → RETE-UL Engine (2-24x faster, highly recommended)
Both needs → Hybrid approach

📊 Performance at 50 rules: Traditional 1.72ms vs RETE 70µs = 24.4x faster!

📖 Engine Comparison Guide → | Quick Start Guide →

📦 Installation

[dependencies]
rust-rule-engine = "0.10.1"

Optional Features

# Enable streaming support
rust-rule-engine = { version = "0.10.1", features = ["streaming"] }

🎯 Quick Start

Option 1: Native Engine (Simple & Plugin-rich)

use rust_rule_engine::{RustRuleEngine, Facts, Value};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create engine with plugins
    let mut engine = RustRuleEngine::new();
    engine.load_default_plugins()?;

    // Load rules from GRL file
    engine.load_rules_from_file("rules/discount.grl")?;

    // Add facts
    let mut facts = Facts::new();
    facts.set("customer.tier", Value::String("gold".to_string()));
    facts.set("order.amount", Value::Float(1500.0));

    // Execute rules
    engine.execute(&mut facts)?;

    // Get result
    println!("Discount: {}", facts.get("order.discount"));

    Ok(())
}

GRL Rule Example (rules/discount.grl):

rule "GoldCustomerDiscount" salience 10 {
    when
        customer.tier == "gold" && order.amount > 1000
    then
        order.discount = order.amount * 0.15;
        Log("Applied 15% gold customer discount");
}

Option 2: RETE-UL Engine (High Performance)

use rust_rule_engine::rete::{
    IncrementalEngine, GrlReteLoader, TypedFacts, FactValue,
    TemplateBuilder, FieldType
};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut engine = IncrementalEngine::new();

    // Optional: Define template for type safety
    let order_template = TemplateBuilder::new("Order")
        .required_string("order_id")
        .float_field("amount")
        .float_field("discount")
        .build();
    engine.templates_mut().register(order_template);

    // Load rules from GRL
    GrlReteLoader::load_from_file("rules/discount.grl", &mut engine)?;

    // Insert facts with validation
    let mut order = TypedFacts::new();
    order.set("order_id", FactValue::String("ORD-001".to_string()));
    order.set("amount", FactValue::Float(1500.0));

    let handle = engine.insert_with_template("Order", order)?;

    // Fire rules
    engine.reset();
    let fired = engine.fire_all();
    println!("Fired {} rules", fired.len());

    // Query results
    if let Some(order) = engine.working_memory().get(&handle) {
        println!("Discount: {:?}", order.data.get("discount"));
    }

    Ok(())
}

🔧 NEW: Function Calls in WHEN Clause

v0.10.0 introduces the ability to call functions directly in rule conditions!

✨ Before (Rule Chaining)

rule "Step1: Call AI" {
    when Customer.needsCheck == true
    then set(Customer.sentiment, aiSentiment(Customer.feedback));
}

rule "Step2: Check Result" {
    when Customer.sentiment == "negative"
    then Alert("Negative feedback detected!");
}

✨ After (Direct Function Calls)

rule "Check Sentiment" {
    when aiSentiment(Customer.feedback) == "negative"
    then Alert("Negative feedback detected!");
}

📖 Use Cases

AI/ML Integration:

rule "Fraud Detection" {
    when aiFraud(Transaction.amount, Transaction.userId) == true
    then set(Transaction.status, "blocked");
}

Business Logic:

rule "Credit Check" {
    when creditScore(Customer.id) > 750
    then set(Customer.tier, "premium");
}

Data Validation:

rule "Email Validation" {
    when validateEmail(User.email) == false
    then set(User.error, "Invalid email format");
}

See ai_functions_in_when.rs for complete examples!

📚 Documentation

📖 Getting Started

Quick Start Guide - Choose and use your engine
Engine Comparison - Native vs RETE-UL decision guide
Examples - 30+ working examples

🔧 Core Features

Features Guide - All engine features explained
Plugin System - Built-in plugins & custom creation
Advanced Usage - Complex patterns & workflows
AI Integration - ML models & LLM integration

🚀 RETE-UL Engine

RETE Guide - Complete RETE-UL documentation
CLIPS Features - Template System & Defglobal
CLIPS Analysis - Feature comparison & roadmap

🌐 Distributed & Production

Streaming Engine - Real-time stream processing
Distributed Setup - Getting started with distributed mode
Distributed Architecture - Cluster setup & scaling
Distributed Features - Complete distributed guide
Performance Guide - Benchmarks & optimization

📋 Reference

API Reference - Complete API documentation
GRL Syntax - Rule language reference
Roadmap - Future plans & upcoming features
Release Notes - What's new in v0.10.0
Changelog - Complete changelog

🖥️ VS Code Extension

Install GRL Syntax Highlighting for .grl files:

Features:

Syntax highlighting for GRL
Snippets for rules, actions, functions
Auto-detection of .grl files

Install: Search grl-syntax-highlighting in VS Code Extensions

🎯 Use Cases

1. Business Rules Engine

// Pricing, discounts, loyalty programs
rule "VIPDiscount" {
    when customer.points > 1000
    then order.discount = 0.20;
}

2. Fraud Detection

// Real-time fraud scoring
rule "HighRiskTransaction" {
    when transaction.amount > 10000 &&
         transaction.location != customer.usual_location
    then fraud.score = 0.85;
}

3. Workflow Automation

// Multi-step approval workflows
rule "ManagerApproval" agenda-group "approvals" {
    when request.amount > 5000
    then request.requires_manager = true;
}

4. Real-Time Systems

// IoT, monitoring, alerts
rule "TemperatureAlert" {
    when sensor.temp > 80
    then Alert.send("High temperature!");
}

More examples: examples/ directory

⚡ Performance

RETE-UL Engine Benchmarks

Pattern Matching: ~4µs per fact insertion (1000 facts)
Incremental Updates: 2x speedup (only affected rules)
Memoization: 99.99% cache hit rate
Template Validation: 1-2µs per fact
Global Variables: 120ns read, 180ns write

Native Engine Benchmarks

Rule Execution: ~10µs per rule (simple conditions)
Plugin Actions: ~2-5µs per action call
Facts Access: O(1) HashMap lookups

Comparison: Performance Guide

🗺️ Roadmap

v0.11.0 (Next Release - 2-3 weeks)

Deffacts - Initial fact definitions (CLIPS feature)
Test CE - Arbitrary conditions in patterns
Multi-field Variables - Array pattern matching
Target: ~98-99% Drools compatibility

v1.0.0 (Stable Release)

Full API stability guarantee
99% Drools compatibility
Performance optimizations
Comprehensive benchmarks
Production hardening

Future Features

Truth Maintenance System (TMS)
Module System for rule organization
Backward Chaining support
Interactive debugger
Visual rule builder UI

Full Roadmap →

📊 Comparison with Other Engines

Feature	Rust Engine	Drools	CLIPS
Performance	⚡ Excellent	Good	Excellent
Type Safety	✅ Compile-time	⚠️ Runtime	⚠️ Runtime
Memory Safety	✅ Guaranteed	❌ JVM	❌ Manual
RETE Algorithm	✅ RETE-UL	✅ Full RETE	✅ Full RETE
Pattern Matching	✅ Advanced	✅ Advanced	✅ Advanced
Plugin System	✅ Native	⚠️ Limited	❌ No
GRL Support	✅ Full	N/A	N/A
Template System	✅ v0.10.0	✅	✅
Defglobal	✅ v0.10.0	✅	✅
Drools Compatibility	~97%	100%	~60%
Learning Curve	Medium	High	High
Ecosystem	Growing	Mature	Mature

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Development Setup

# Clone repository
git clone https://github.com/KSD-CO/rust-rule-engine.git
cd rust-rule-engine

# Run tests
cargo test

# Run examples
cargo run --example rete_template_globals_demo

# Build documentation
cargo doc --open

📄 License

This project is licensed under the MIT License - see LICENSE file.

🙏 Acknowledgments

Inspired by:

Drools - JBoss Rule Engine
CLIPS - NASA C Language Integrated Production System
Grule - Go Rule Engine

Special Thanks:

Rust community for amazing tools and libraries
Contributors who helped improve the engine
Users providing valuable feedback

📞 Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Email: tonthatvu.hust@gmail.com

📈 Stats

Crates.io downloads

Made with ❤️ by Ton That Vu

⭐ Star us on GitHub | 📦 Download from Crates.io

rust-rule-engine 0.10.1