v0.1.0 Released

Ordo: Ultra-Performance
Rust Rule Engine

Designed for high-concurrency business, providing 1.63µs ultra-low latency and 500,000+ QPS throughput. Built-in visual editor with real-time WASM execution.

Try Playground Now View on GitHub

1.63µs Avg Latency

500K+ Executions / sec

600x Faster than 1ms target

100% Built with Rust

Benchmark Results

Single-thread tests on Apple Silicon (M-series) show Ordo's exceptional performance far exceeding industry standards.

Execution Latency Comparison (µs)

lower is better

Traditional Engine (Typical) ~1,000 µs

Ordo Rule Engine 1.63 µs

* ~600x performance boost, making real-time business decisions invisible.

Coming Soon

Coming Soon: Schema-Aware JIT

Another leap in performance by compiling rules into machine code. 30x faster than existing VM in complex scenarios.

Evaluation Latency ~26 ns

Peak Throughput 76M ops/s

Performance Boost 30x faster

Multi-tier Execution Architecture

From development debugging to extreme performance needs, Ordo covers all scenarios.

Level 1

AST Tree-walk

Direct interpretation, perfect for development and one-off rules.

~1.5 µs

Level 2

Bytecode VM

High-efficiency bytecode, default for production, balances flexibility and speed.

~830 ns

Level 3

Vectorized Execution

Columnar batch processing, massive throughput for large-scale data validation.

Batch Optimization

Level 4

Schema-Aware JIT

Compiles to native machine code, compressing latency to nanoseconds.

~26 ns

79-211 ns

Expression Eval Time

54,000+ QPS

HTTP API Single-thread QPS

3.9 ms

HTTP API P99 Latency

0 Alloc

Hot Path Heap Allocations

Core Features

Ordo is more than just a rule engine; it's a complete rule life cycle management platform.

Visual Rule Editor

Dual modes of drag-and-drop Flow and structured Form editing to lower maintenance barriers.

Ultra-Performance Engine

Built with Rust, supports millions of QPS with 1.63µs latency, perfect for financial payments.

Real-time WASM Execution

Preview rules instantly in browser via WebAssembly with execution tracing and debugging.

Versioning & Audit

Built-in version management with one-click rollback. Full audit logs for compliance requirements.

Multi-tenancy & Isolation

Namespace-level rule isolation and per-tenant QPS limits to easily support SaaS business.

Comprehensive Integration

Provides HTTP REST, gRPC interfaces, and SDKs for Go, Java, Python, and more.

Use Cases

Financial Risk Control

Real-time anti-fraud and credit strategy evaluation with millisecond response to massive requests.

E-commerce Marketing

Dynamic coupon issuance and flash sale logic for flexible promotion strategies.

Smart Routing

Payment channel selection and dynamic traffic distribution based on real-time data.

Deployment & Connectivity

Ordo supports all scenarios from cloud microservices to browser edge nodes.

Cloud Service

Deploy via Docker/K8s/Nomad, serving rules via HTTP/gRPC.

DockerK8sNomad

Edge & Client-side

Execute directly in browser or edge nodes via WASM, zero latency.

WASMBrowserEdge

Native Embedded

Compile directly into your Rust application for zero-overhead integration.

Rust CratesLibrary

Flexible Invocation Protocols

Standardized protocols ensuring rapid response across any technology stack.

HTTP REST

JSON / OpenAPI

gRPC

Protobuf / Streaming

WASM API

TypeScript Bindings

IPC / UDS

Local Unix Socket

Multi-language SDK Support

Rust Stable

TypeScript / JS Stable

Go Coming Soon

Python Coming Soon

Easy to Define, Seconds to Execute

Ordo uses intuitive JSON/YAML formats. Supports rich expression syntax including math, logic, and built-in functions. Get decision results and detailed trace in microseconds via simple API calls.

Structured Rule Definition

Define step flow and decision logic

High-Performance Evaluation

Optimized evaluation engine

Visual Tracing

Detailed execution path tracing

rule_definition.json

{
  "config": {
    "name": "discount-check",
    "version": "1.0.0",
    "entry_step": "check_vip"
  },
  "steps": {
    "check_vip": {
      "id": "check_vip",
      "name": "Check VIP Status",
      "type": "decision",
      "branches": [
        { 
          "condition": "user.vip == true", 
          "next_step": "vip_discount" 
        }
      ],
      "default_next": "normal_discount"
    },
    "vip_discount": {
      "id": "vip_discount",
      "type": "terminal",
      "result": { "discount": 0.2 }
    },
    "normal_discount": {
      "id": "normal_discount",
      "type": "terminal",
      "result": { "discount": 0.05 }
    }
  }
}

execution_result.json 1.63 µs

{
  "rule": "discount-check",
  "result": { "discount": 0.2 },
  "trace": [
    { "step": "check_vip", "branch": 0, "condition": "user.vip == true (true)" },
    { "step": "vip_discount", "type": "terminal" }
  ],
  "duration_us": 1.63
}

Intuitive Visual Editor

Design complex decision flows without writing code. Ordo provides a powerful visual editor with real-time preview and debugging.

ordo-playground.app

Decision Steps

Decision Node

Terminal Node

Jump Node

Rule Config

Try in Live Playground

Multi-view Switching

Seamlessly switch between Flow and Form views to fit different editing habits.

Real-time Execution

Get identical results to server-side execution instantly in browser using WASM.

Execution Path Tracing

Visually trace every node in rule execution to make debugging effortless.

Ready to boost your business decisions?

Join us and experience the revolution of development efficiency with performance and visual editing. Ordo is open sourced on GitHub.

Get Started Playground Demo

Ordo: Ultra-Performance Rust Rule Engine