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

Tested against adversarial and edge-case scenarios. Zero tolerance for crashes — all malformed inputs are rejected gracefully.

Category	Tests	Result
Fuzz (malformed rule sources)	45	PASS
Bytecode tampering	17	PASS
Input injection (SQLi / XSS / CRLF)	37	PASS
Memory stability (sequential)	500	PASS
Rule complexity limits	30	PASS
Locale determinism	7	PASS
C API misuse (NULL / NaN / overflow)	48	PASS
Multi-thread stress (8 threads)	800,000	PASS
Total	800,684	ALL PASS

79,000+ Evaluations/sec

800K concurrent evaluations across 8 threads with zero errors. Memory flat after warm-up, returns below baseline after cleanup. No leak, no degradation.

Thread-Safe by Design

Per-thread compiler pattern for full parallelism. Shared compiler misuse detected at runtime with AX_ERR_CONCURRENT_COMPILER_USE — no crash, no data corruption.

Identical Bytecode Across Locales

Compiled output verified identical across 7 OS locales including Turkish, German, and French. No decimal-separator drift, no collation variance.

Tampered Bytecode Detected

All 17 tampering vectors — flipped bits, truncation, wrong magic, 1 MB garbage — correctly detected and rejected with structured error codes.

Deterministic rules.
Embedded in your app.