RuleDSL — Deterministic Rule Engine SDK

Deterministic by Contract

Same engine + same bytecode + same inputs = same output. Always. No hidden time sources, no locale drift, no randomness. Auditable and reproducible.

Zero Dependencies

In-process library. No database, no message broker, no sidecar. Link .dll or .so into your app and call the C API. Sub-millisecond evaluation.

Stable ABI

Forward-compatible struct design with struct_size + reserved fields. Upgrade the engine without recompiling your application. Error codes are frozen.

Language Bindings

C API at the core, with ready-made Python and C# wrappers. No C expertise required. More languages coming based on demand.

Self-Service Errors

12 stable error codes with actionable diagnostic messages. Troubleshooting guide covers every scenario. Designed for minimal vendor support.

Update Rules Without Redeploying

Write rules in RuleDSL, compile to bytecode, load at runtime. Change business logic without touching application code or restarting services.

How It Works

Write

Define rules in RuleDSL — a simple, readable DSL for business decisions

Compile

Compile to bytecode with the CLI compiler. Deterministic output, every time.

Verify

Verify bytecode integrity and compatibility before loading into production.

Evaluate

Call the API with your data. Get a decision. ALLOW, DECLINE, REVIEW, or LIMIT.

rules.rule

rule high_risk {
  when amount > 1000
       and currency == "USD";
  then risk_score = 90,
       reason = "high_amount",
       decline;
}

evaluate.py

from ruledsl import RuleDSL

engine = RuleDSL("ruledsl_capi.dll")
rules = open("rules.rule").read()
bc = engine.compile(rules)

decision = engine.evaluate(bc, {
  "amount": 1200.0,
  "currency": "USD"
})
# decision.action == "DECLINE"

Use Cases

Transaction Risk Score and gate transactions in real-time. Decline, review, or apply limits based on amount, currency, geography.

Spending Limits Enforce velocity limits: "max 3 transactions per hour" or "max $5000 per day per customer."

Compliance Gates Deterministic compliance checks for regulated industries. Audit-ready with replay proof.

Offer Eligibility Real-time pricing rules, promotion eligibility, and feature gating without redeployment.

Engine Robustness

Built to fail safe: malformed inputs are rejected gracefully with structured error codes, never with a crash. The parser and bytecode loader are exercised on every change by CI-gated, coverage-guided fuzzing (libFuzzer under AddressSanitizer + UndefinedBehaviorSanitizer), seeded with an adversarial corpus (maintained in the engine repository) — which has caught and fixed bugs before release.

Continuous Fuzzing in CI

Parser and bytecode loader fuzzed on every change under ASan/UBSan, seeded with an adversarial corpus (maintained in the engine repository). This has caught and fixed bugs before release.

Thread-Safe by Design

Per-thread compiler pattern for full parallelism; concurrent and long-running (soak) execution is exercised on every release in CI under ASan/UBSan. Shared-compiler misuse is detected at runtime with AX_ERR_CONCURRENT_COMPILER_USE — no crash, no corruption.

Locale Independence

Evaluation does not use locale, timezone, or wall-clock as inputs (determinism contract, DET-002); cross-locale equivalence is exercised in CI. No decimal-separator drift, no collation variance.

Malformed & Tampered Input Rejected

Malformed rule sources, injection-style strings, and tampered bytecode (flipped bits, truncation, wrong magic, oversized payloads) are detected and rejected with structured error codes. C-API misuse (NULL, NaN/Infinity, bad struct sizes) returns proper error codes.

Deterministic rules.
Embedded in your app.