为什么值得关注

它挑战了必须将模型重写为 Rust 才能获得速度的假设，证明 Rust 的价值在于确定性执行和无停顿，拥有 70 纳秒的无锁传递和超过 1800 个测试。

适合谁使用

希望在 Python 中保持 ML 开发的同时获得低延迟执行的 Python 机器学习研究人员和量化交易者
寻求可靠、经过测试的算法交易框架的加密货币交易者
对高保证 Python-Rust 交互在延迟敏感系统中的应用感兴趣的开发者
研究交易系统架构的教育工作者和学生

典型使用场景

在 Hyperliquid 测试网上运行基于 ML 的策略（XGBoost、PyTorch）
使用与实盘相同的引擎进行回测，确保逐比特一致的特征计算
部署带有自动熔断和仓位限制的风险控制交易
学习交易系统中确定性无停顿执行的概念

项目优势

Python 和 Rust 之间 70 纳秒的无锁共享内存传递
逐比特一致的特征验证确保策略在研究和生产中行为相同
可预测的执行，无垃圾回收暂停；最坏情况接近平均值
全面的测试套件，共 1885 个测试（1196 Rust + 689 Python），并设计为交易所无关

使用前须知

仅在测试网上使用小型 ML 模型测试，尚未用于真实资金交易
目前仅支持 Hyperliquid 交易所（尽管树中已有 Binance 适配器）
需要仔细设置并理解架构，并非对所有用户即插即用

README 快速开始

Hyperliquid: Python ML → Rust Layer

Write your trading strategy in Python. Let Rust execute it.

You keep pandas, scikit-learn, XGBoost and PyTorch. You never rewrite a model in Rust. A Rust core takes your strategy's decisions and turns them into live orders — quickly, predictably, and identically every time.

Codename Axon: the wire that carries a signal from the Python brain to the Rust muscle.

The idea in one picture

flowchart LR
    subgraph PY ["🐍 PYTHON — the brain"]
        direction TB
        A["Market dataarrives"] --> B["Computefeatures"]
        B --> C["Run themodel"]
        C --> D["Decide:hold 0.5 BTC"]
    end

    subgraph RS ["🦀 RUST — the muscle"]
        direction TB
        E["Read thedecision"] --> F["Check therisk limits"]
        F --> G["Build theorder"]
        G --> H["Send it tothe exchange"]
    end

    V(("🏦Hyperliquid"))

    D -.->|"shared memory70 nanoseconds"| E
    H -->|"0.2 – 0.9 seconds"| V

    style PY fill:#e8f0fe,stroke:#4285f4,stroke-width:2px,color:#111
    style RS fill:#fdecea,stroke:#e8710a,stroke-width:2px,color:#111
    style V fill:#e6f4ea,stroke:#34a853,stroke-width:2px,color:#111

Python says what it wants. Rust works out how to get it, and deals with the exchange saying no. Nothing is shared between them that either side can corrupt — decisions cross as fixed-size records in a lock-free queue, one writer, one reader.

Where the time actually goes

This is the part almost everyone gets wrong. Measured on real hardware, not quoted from a blog:

 Python → Rust handoff        70 ns   ▏
 Rust core wake-up cycle     366 µs   ▎
 Exchange round-trip     0.2 – 0.9 s  ████████████████████████████████████████
                                      └─ the exchange is >99.8% of the wait

Put it on a human scale. Suppose the Python→Rust handoff took 1 second:

Then this step…	…would take
🐍→🦀 Handing the decision to Rust	1 second
⏱️ Rust noticing there is work to do	1.5 hours
🏦 The exchange confirming your order	1 to 5 months

The language boundary is not the bottleneck. It was never going to be. Making it ten times faster would change nothing you could measure.

So why use Rust at all?

Because the point isn't speed. It's never stalling.

An exchange order book is **first-come, firs

项目描述

Write your trading strategy in Python. Let Rust execute it. A venue-agnostic ML execution layer — Hyperliquid is the first adapter.

hyperliquid-python-ml-to-rust-layer