nautechsystems/nautilus_traderPublic

Production-grade Rust-native trading engine with deterministic event-driven architecture

AI summary: A highly deterministic, Rust-native algorithmic trading engine for multiple asset classes.

Stars
31.7K
+125 today
Forks
4.3K
Watchers
230
Open issues
107
Open PRs
19
Contributors
~236
Commits
22.6K
Branches
4
Views (30d)
3

RustLGPL-3.0Created Jun 25, 2018Last push 1d agoLatest release v1.231.0+208 stars this week+1.3K this month

Quick answers

What is nautilus_trader?
A highly deterministic, Rust-native algorithmic trading engine for multiple asset classes.
What does nautilus_trader do?
NautilusTrader is a robust execution engine built for developing and deploying automated trading strategies. Written natively in Rust for extreme performance, it employs a strict event-driven architecture to guarantee deterministic behavior. This ensures that backtesting results accurately reflect live trading conditions without lookahead bias. The platform supports equities, forex, crypto, and futures, providing Python bindings for ease of strategy development. Its unified architecture ensures researchers can transition algorithms from simulation to live execution without porting code or introducing deployment risks.
Who is nautilus_trader for?
NautilusTrader is built for quantitative researchers, algorithmic traders, and software engineers in finance. It requires knowledge of Python or Rust and a solid understanding of market microstructure.
How do I get started with nautilus_trader?
pip install nautilus_trader
How popular is nautilus_trader on GitHub?
nautechsystems/nautilus_trader has 31,686 stars and 4,311 forks on GitHub, and gained 208 stars in the last 7 days.
What license does nautilus_trader use?
nautechsystems/nautilus_trader is released under the LGPL-3.0 license.

Star history

since Jul 29, 2026
010K20K30KJul 2026Sep 2026Oct 2026Nov 2026
31.7K stars as of Nov 19, 2026. Measured daily since Jul 29, 2026; GitHub no longer exposes earlier star timestamps.

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-23: 8 commits2025-11-24: 11 commits2025-11-25: 7 commits2025-11-26: 5 commits2025-11-27: 16 commits2025-11-28: 13 commits2025-11-29: 14 commits2025-11-30: 9 commits2025-12-01: 19 commits2025-12-02: 19 commits2025-12-03: 8 commits2025-12-04: 13 commits2025-12-05: 5 commits2025-12-06: 12 commits2025-12-07: 16 commits2025-12-08: 15 commits2025-12-09: 15 commits2025-12-10: 10 commits2025-12-11: 12 commits2025-12-12: 11 commits2025-12-13: 8 commits2025-12-14: 7 commits2025-12-15: 10 commits2025-12-16: 8 commits2025-12-17: 6 commits2025-12-18: 4 commits2025-12-19: 9 commits2025-12-20: 9 commits2025-12-21: 6 commits2025-12-22: 8 commits2025-12-23: 5 commits2025-12-24: 5 commits2025-12-25: 4 commits2025-12-26: 2 commits2025-12-27: 6 commits2025-12-28: 10 commits2025-12-29: 15 commits2025-12-30: 13 commits2025-12-31: 13 commits2026-01-01: 14 commits2026-01-02: 6 commits2026-01-03: 15 commits2026-01-04: 14 commits2026-01-05: 7 commits2026-01-06: 9 commits2026-01-07: 16 commits2026-01-08: 14 commits2026-01-09: 16 commits2026-01-10: 9 commits2026-01-11: 15 commits2026-01-12: 15 commits2026-01-13: 7 commits2026-01-14: 10 commits2026-01-15: 12 commits2026-01-16: 6 commits2026-01-17: 11 commits2026-01-18: 11 commits2026-01-19: 14 commits2026-01-20: 4 commits2026-01-21: 7 commits2026-01-22: 11 commits2026-01-23: 21 commits2026-01-24: 9 commits2026-01-25: 6 commits2026-01-26: 10 commits2026-01-27: 10 commits2026-01-28: 9 commits2026-01-29: 8 commits2026-01-30: 6 commits2026-01-31: 6 commits2026-02-01: 12 commits2026-02-02: 10 commits2026-02-03: 15 commits2026-02-04: 14 commits2026-02-05: 11 commits2026-02-06: 13 commits2026-02-07: 17 commits2026-02-08: 14 commits2026-02-09: 14 commits2026-02-10: 10 commits2026-02-11: 7 commits2026-02-12: 6 commits2026-02-13: 10 commits2026-02-14: 7 commits2026-02-15: 3 commits2026-02-16: 4 commits2026-02-17: 5 commits2026-02-18: 17 commits2026-02-19: 19 commits2026-02-20: 17 commits2026-02-21: 8 commits2026-02-22: 9 commits2026-02-23: 15 commits2026-02-24: 11 commits2026-02-25: 12 commits2026-02-26: 14 commits2026-02-27: 19 commits2026-02-28: 14 commits2026-03-01: 10 commits2026-03-02: 13 commits2026-03-03: 8 commits2026-03-04: 12 commits2026-03-05: 7 commits2026-03-06: 10 commits2026-03-07: 20 commits2026-03-08: 17 commits2026-03-09: 12 commits2026-03-10: 13 commits2026-03-11: 7 commits2026-03-12: 11 commits2026-03-13: 2 commits2026-03-14: 11 commits2026-03-15: 11 commits2026-03-16: 14 commits2026-03-17: 10 commits2026-03-18: 13 commits2026-03-19: 8 commits2026-03-20: 13 commits2026-03-21: 12 commits2026-03-22: 16 commits2026-03-23: 21 commits2026-03-24: 10 commits2026-03-25: 12 commits2026-03-26: 13 commits2026-03-27: 15 commits2026-03-28: 13 commits2026-03-29: 17 commits2026-03-30: 18 commits2026-03-31: 12 commits2026-04-01: 14 commits2026-04-02: 14 commits2026-04-03: 15 commits2026-04-04: 12 commits2026-04-05: 17 commits2026-04-06: 10 commits2026-04-07: 13 commits2026-04-08: 6 commits2026-04-09: 15 commits2026-04-10: 10 commits2026-04-11: 16 commits2026-04-12: 17 commits2026-04-13: 10 commits2026-04-14: 14 commits2026-04-15: 12 commits2026-04-16: 8 commits2026-04-17: 19 commits2026-04-18: 17 commits2026-04-19: 22 commits2026-04-20: 17 commits2026-04-21: 11 commits2026-04-22: 11 commits2026-04-23: 20 commits2026-04-24: 11 commits2026-04-25: 9 commits2026-04-26: 14 commits2026-04-27: 22 commits2026-04-28: 14 commits2026-04-29: 8 commits2026-04-30: 11 commits2026-05-01: 21 commits2026-05-02: 12 commits2026-05-03: 21 commits2026-05-04: 22 commits2026-05-05: 24 commits2026-05-06: 18 commits2026-05-07: 21 commits2026-05-08: 12 commits2026-05-09: 12 commits2026-05-10: 14 commits2026-05-11: 18 commits2026-05-12: 5 commits2026-05-13: 14 commits2026-05-14: 26 commits2026-05-15: 12 commits2026-05-16: 15 commits2026-05-17: 22 commits2026-05-18: 11 commits2026-05-19: 19 commits2026-05-20: 13 commits2026-05-21: 19 commits2026-05-22: 24 commits2026-05-23: 20 commits2026-05-24: 18 commits2026-05-25: 15 commits2026-05-26: 24 commits2026-05-27: 25 commits2026-05-28: 24 commits2026-05-29: 23 commits2026-05-30: 21 commits2026-05-31: 29 commits2026-06-01: 30 commits2026-06-02: 24 commits2026-06-03: 23 commits2026-06-04: 18 commits2026-06-05: 1 commit2026-06-06: 13 commits2026-06-07: 10 commits2026-06-08: 11 commits2026-06-09: 31 commits2026-06-10: 33 commits2026-06-11: 33 commits2026-06-12: 19 commits2026-06-13: 19 commits2026-06-14: 35 commits2026-06-15: 19 commits2026-06-16: 23 commits2026-06-17: 16 commits2026-06-18: 15 commits2026-06-19: 27 commits2026-06-20: 27 commits2026-06-21: 42 commits2026-06-22: 25 commits2026-06-23: 18 commits2026-06-24: 11 commits2026-06-25: 16 commits2026-06-26: 23 commits2026-06-27: 14 commits2026-06-28: 17 commits2026-06-29: 14 commits2026-06-30: 5 commits2026-07-01: 6 commits2026-07-02: 10 commits2026-07-03: 11 commits2026-07-04: 18 commits2026-07-05: 16 commits2026-07-06: 5 commits2026-07-07: 13 commits2026-07-08: 17 commits2026-07-09: 10 commits2026-07-10: 14 commits2026-07-11: 15 commits2026-07-12: 16 commits2026-07-13: 10 commits2026-07-14: 27 commits2026-07-15: 18 commits2026-07-16: 9 commits2026-07-17: 14 commits2026-07-18: 7 commits2026-07-19: 6 commits2026-07-20: 21 commits2026-07-21: 24 commits2026-07-22: 34 commits2026-07-23: 27 commits2026-07-24: 18 commits2026-07-25: 33 commits2026-07-26: 25 commits2026-07-27: 24 commits2026-07-28: 32 commits2026-07-29: 20 commits2026-07-30: 26 commits2026-07-31: 23 commits2026-08-01: 22 commits2026-08-02: 17 commits2026-08-03: 4 commits2026-08-04: 19 commits2026-08-05: 31 commits2026-08-06: 29 commits2026-08-07: 23 commits2026-08-08: 30 commits2026-08-09: 21 commits2026-08-10: 24 commits2026-08-11: 24 commits2026-08-12: 28 commits2026-08-13: 30 commits2026-08-14: 27 commits2026-08-15: 43 commits2026-08-16: 27 commits2026-08-17: 32 commits2026-08-18: 33 commits2026-08-19: 19 commits2026-08-20: 12 commits2026-08-21: 2 commits2026-08-22: 8 commits2026-08-23: 17 commits2026-08-24: 23 commits2026-08-25: 27 commits2026-08-26: 21 commits2026-08-27: 24 commits2026-08-28: 22 commits2026-08-29: 21 commits2026-08-30: 24 commits2026-08-31: 11 commits2026-09-01: 30 commits2026-09-02: 11 commits2026-09-03: 14 commits2026-09-04: 19 commits2026-09-05: 19 commits2026-09-06: 28 commits2026-09-07: 21 commits2026-09-08: 25 commits2026-09-09: 22 commits2026-09-10: 17 commits2026-09-11: 16 commits2026-09-12: 28 commits2026-09-13: 19 commits2026-09-14: 18 commits2026-09-15: 17 commits2026-09-16: 15 commits2026-09-17: 15 commits2026-09-18: 13 commits2026-09-19: 16 commits2026-09-20: 28 commits2026-09-21: 13 commits2026-09-22: 12 commits2026-09-23: 27 commits2026-09-24: 23 commits2026-09-25: 17 commits2026-09-26: 22 commits2026-09-27: 12 commits2026-09-28: 14 commits2026-09-29: 19 commits2026-09-30: 11 commits2026-10-01: 32 commits2026-10-02: 22 commits2026-10-03: 21 commits2026-10-04: 18 commits2026-10-05: 10 commits2026-10-06: 12 commits2026-10-07: 24 commits2026-10-08: 11 commits2026-10-09: 17 commits2026-10-10: 24 commits2026-10-11: 27 commits2026-10-12: 25 commits2026-10-13: 25 commits2026-10-14: 23 commits2026-10-15: 10 commits2026-10-16: 16 commits2026-10-17: 28 commits2026-10-18: 26 commits2026-10-19: 12 commits2026-10-20: 20 commits2026-10-21: 29 commits2026-10-22: 21 commits2026-10-23: 10 commits2026-10-24: 24 commits2026-10-25: 23 commits2026-10-26: 33 commits2026-10-27: 26 commits2026-10-28: 3 commits2026-10-29: 20 commits2026-10-30: 22 commits2026-10-31: 24 commits2026-11-01: 37 commits2026-11-02: 20 commits2026-11-03: 33 commits2026-11-04: 37 commits2026-11-05: 35 commits2026-11-06: 29 commits2026-11-07: 19 commits2026-11-08: 27 commits2026-11-09: 20 commits2026-11-10: 12 commits2026-11-11: 24 commits2026-11-12: 27 commits2026-11-13: 12 commits2026-11-14: 15 commits2026-11-15: 1 commit2026-11-16: 15 commits2026-11-17: 14 commits2026-11-18: 29 commits2026-11-19: 21 commits2026-11-20: 0 commits2026-11-21: 0 commits
5,887 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Widely adopted

    31,686 stars

  • Battle-tested

    8 years of history

  • Very active

    5,887 commits in 52 weeks

  • Community-driven

    ~236 contributors

  • Well documented

    High community health score

  • Continuous integration

    Automated checks passing

  • Repeat trending

    5 trending appearances

What nautilus_trader does

NautilusTrader is a robust execution engine built for developing and deploying automated trading strategies. Written natively in Rust for extreme performance, it employs a strict event-driven architecture to guarantee deterministic behavior. This ensures that backtesting results accurately reflect live trading conditions without lookahead bias. The platform supports equities, forex, crypto, and futures, providing Python bindings for ease of strategy development. Its unified architecture ensures researchers can transition algorithms from simulation to live execution without porting code or introducing deployment risks.

NautilusTrader is built for quantitative researchers, algorithmic traders, and software engineers in finance. It requires knowledge of Python or Rust and a solid understanding of market microstructure.

  • Rust core performance: Utilizes Rust for the core engine to achieve sub-millisecond execution speeds.
  • Deterministic event loop: Ensures perfect consistency between historical backtesting and live market execution.
  • Python integration: Exposes a rich Python API, allowing quantitative researchers to build strategies using familiar tools.
  • Multi-asset support: Natively handles trading across crypto, equities, forex, and futures markets.
  • Institutional grade architecture: Designed to handle high-throughput market data and complex portfolio management.
  • Modular venue adapters: Supports diverse trading environments including centralized exchanges, decentralized markets, and traditional brokerages.

Where teams use it

High-frequency strategy deployment

Enables quant teams to run latency-sensitive trading algorithms with confidence in execution speed.

Accurate backtesting

Provides researchers with a framework where historical tests perfectly mirror real-world order routing and slippage.

Cross-exchange arbitrage

Facilitates strategies that require simultaneous connection and execution across multiple cryptocurrency or traditional exchanges.

Proprietary trading operations

Acts as the foundational infrastructure for small to medium prop shops building custom trading systems.

Getting started: pip install nautilus_trader

README

develop branch

NautilusTrader

rustc crates.io codspeed pythons pypi-version Downloads Discord

Branch Version Status
master version build
nightly version build
develop version build
Platform Rust Python
Linux (x86_64) 1.100.0 3.13-3.15
Linux (ARM64) 1.100.0 3.13-3.15
macOS (ARM64) 1.100.0 3.13-3.15
Windows (x86_64) 1.100.0 3.13-3.15

Introduction

NautilusTrader is an open-source, production-grade, Rust-native engine for multi-asset, multi-venue trading systems.

The system spans research, deterministic simulation, and live execution within a single event-driven architecture, with Python serving as the control plane for strategy logic, configuration, and orchestration.

This separation provides the performance and safety of a compiled trading engine with the flexibility of Python for system composition and strategy development. Trading systems can also be written entirely in Rust for mission-critical workloads.

The same strategy and execution-algorithm code can run across backtest and live systems, reducing deployment divergence. Live execution still introduces venue, transport, timing, persistence, external-activity, and reconciliation behavior that a simulation may not reproduce. See Backtest and live differences.

NautilusTrader is asset-class-agnostic. Any venue with a REST API or WebSocket feed can be integrated through modular adapters. Current integrations span crypto exchanges (CEX and DEX), traditional markets (FX, equities, futures, options), and betting exchanges.

nautilus-trader

Features

  • Fast: Rust core with the mimalloc allocator and asynchronous networking using tokio.
  • Reliable: Type- and thread-safety backed by Rust, with optional Redis-backed state persistence.
  • Portable: Runs on Linux, macOS, and Windows. Deploy using Docker.
  • Flexible: Modular adapters integrate any REST API or WebSocket feed.
  • Advanced: Time in force IOC, FOK, GTC, GTD, DAY, AT_THE_OPEN, AT_THE_CLOSE, advanced order types and conditional triggers. Execution instructions post-only, reduce-only, and icebergs. Contingency orders including OCO, OUO, OTO.
  • Customizable: User-defined components, or assemble entire systems from scratch using the cache and message bus.
  • Backtesting: Multiple venues, instruments, and strategies simultaneously using historical quote tick, trade tick, bar, order book, and custom data with nanosecond resolution.
  • Live: Identical strategy implementations between research and live deployment.
  • Multi-venue: Run market-making and cross-venue strategies across multiple venues simultaneously.
  • AI Training: Engine fast enough to train AI trading agents (RL/ES).

nautilus

nautilus - from ancient Greek 'sailor' and naus 'ship'.

The nautilus shell consists of modular chambers with a growth factor which approximates a logarithmic spiral. The idea is that this can be translated to the aesthetics of design and architecture.

Why NautilusTrader?

Trading strategy research is often conducted in Python using vectorized approaches, while production trading systems are implemented separately using event-driven architectures in compiled languages.

NautilusTrader removes this separation.

A Rust-native core provides a deterministic event-driven runtime for both research and live execution, while Python serves as the control plane. The same architecture, execution semantics, and time model operate across both environments, allowing strategies to move from research to production without reimplementation.

Python bindings are provided via PyO3 for the Rust-native v2 runtime. During the v2 transition, v1 receives only critical security backports on the develop_v1 branch. See the v2 migration guide for migration steps and compatibility details. No Rust toolchain is required to install prebuilt wheels.

This project makes the Soundness Pledge:

"The intent of this project is to be free of soundness bugs. The developers will do their best to avoid them, and welcome help in analyzing and fixing them."

Note

MSRV: NautilusTrader relies heavily on improvements in the Rust language and compiler. As a result, the Minimum Supported Rust Version (MSRV) is generally equal to the latest stable release of Rust.

Integrations

NautilusTrader is modularly designed to work with adapters, enabling connectivity to trading venues and data providers by translating their raw APIs into a unified interface and normalized domain model.

The following integrations are available or planned; see docs/integrations/ for details:

Name ID Type Status Docs
AX Exchange AX Derivatives Exchange status Guide
Betfair BETFAIR Sports Betting Exchange status Guide
Binance BINANCE Crypto Exchange (CEX) status Guide
Blockchain BLOCKCHAIN DeFi Data Provider status Guide
Bybit BYBIT Crypto Exchange (CEX) status Guide
CoinAPI COINAPI Data Provider status Guide
Coinbase COINBASE Crypto Exchange (CEX) status Guide
Databento DATABENTO Data Provider status Guide
Deribit DERIBIT Crypto Exchange (CEX) status Guide
Derive DERIVE Crypto Exchange (DEX) status Guide
dYdX DYDX Crypto Exchange (DEX) status Guide
FinFeed FINFEED Data Provider status Guide
Hyperliquid HYPERLIQUID Crypto Exchange (DEX) status Guide
Interactive Brokers INTERACTIVE_BROKERS Brokerage (multi-venue) status Guide
Kalshi KALSHI Prediction Market (CEX) status Guide
Kraken KRAKEN Crypto Exchange (CEX) status Guide
Lighter LIGHTER Crypto Exchange (DEX) status Guide
Lighter on Robinhood LIGHTER_ROBINHOOD Crypto Exchange (DEX) status Guide
OKX OKX Crypto Exchange (CEX) status Guide
Polymarket POLYMARKET Prediction Market (DEX) status Guide
Tardis TARDIS Crypto Data Provider status Guide
  • ID: The default client ID for the integrations adapter clients.
  • Type: The type of integration (often the venue type).

For Lighter on Robinhood, LIGHTER_ROBINHOOD is the venue and explicit client ID to register. The shared Lighter factory keeps LIGHTER as its compatibility default.

Status

  • planned: Planned for future development.
  • building: Under construction and likely not in a usable state.
  • beta: Completed to a minimally working state and in a beta testing phase.
  • stable: Stabilized feature set and API, the integration has been tested by both developers and users to a reasonable level (some bugs may still remain).

See the Integrations documentation for further details.

Roadmap

The Roadmap outlines NautilusTrader's strategic direction. Current priorities include stabilizing the Rust-native core, improving documentation, and enhancing code ergonomics.

The open-source project focuses on single-node backtesting and live trading for individual and small-team quantitative traders. UI dashboards, distributed orchestration, and built-in AI/ML tooling are out of scope to maintain focus on the core engine and ecosystem sustainability. Additional external integrations (such as databases, cloud services, and monitoring tools) are also out of scope unless explicitly listed in the open-source scope.

New integration proposals within the open-source scope should start with an RFC issue to discuss suitability before submitting a PR. See Community-contributed integrations for guidelines.

Security

OpenSSF Scorecard

Security is a priority for the NautilusTrader project. We apply security controls across dependency selection, development, builds, and releases.

  • Rust dependencies come only from crates.io; lock files pin dependencies with cryptographic checksums.
  • New dependency and tooling versions observe a publication cooldown before adoption.
  • Third-party Python packages install from wheels only.
  • cargo-vet audits Rust dependency provenance.
  • cargo-deny enforces a license allow list compatible with LGPL-3.0-only.
  • TLS and most runtime cryptography use AWS-LC through Rust's aws-lc-rs.
  • Ed25519 signing uses ed25519-dalek.
  • Gitleaks screens for secrets and Zizmor audits GitHub Actions at pre-commit.
  • CODEOWNERS require review of critical infrastructure, dependency manifests, and lock files.
  • Protected branches require signed commits and passing CI.
  • CodeQL runs on release PRs to master and pushes to nightly.
  • Audit-relevant PRs and daily audits run cargo-audit, cargo-deny, and cargo-vet.
  • OSV Scanner and pip-audit also run on audit-relevant PRs and daily.
  • cargo-fuzz targets cover selected adapter and signing surfaces.
  • GitHub Actions are pinned to commit SHAs; hardened CI runners restrict network egress to an allow list.
  • Python artifacts carry SLSA build provenance.
  • Container images are Sigstore-signed with attested SPDX SBOMs.
  • PyPI and crates.io use OIDC Trusted Publishing through a protected release environment.
  • The release environment never runs PR or fork code.
  • Release tags are immutable.

OpenSSF Scorecard provides an automated repository-health signal alongside manual review, CI hardening, and security audits.

Reporting a vulnerability

Report privately through GitHub Security Advisories or email [email protected] (PGP key available on request).

  • We acknowledge reports within 48 hours and patch critical vulnerabilities within 30 days.
  • We thank and credit reporters in the relevant advisory and release notes unless they prefer anonymity.

See the following for details:

Versioning and releases

Warning

NautilusTrader is still under active development. Some features may be incomplete, and while the API is becoming more stable, breaking changes can occur between releases. We strive to document these changes in the release notes on a best-effort basis.

We aim to follow a bi-weekly release schedule, though experimental or larger features may cause delays.

Branches

We aim to maintain a stable, passing build across all branches.

  • master: Reflects the source code for the latest released version; recommended for production use.
  • nightly: Daily snapshots of the develop branch for early testing; merged at 14:00 UTC and as required.
  • develop: Active development branch for contributors and feature work.

Note

The v2 release-candidate line is the transition toward a stable API for version 2.x. Once this milestone is reached, we plan to implement a formal deprecation process for any API changes. This approach allows us to maintain a rapid development pace for now.

Precision mode

NautilusTrader supports two precision modes for its core value types (Price, Quantity, Money), which differ in their internal bit-width and maximum decimal precision.

  • High-precision: 128-bit integers with up to 16 decimals of precision, and a larger value range.
  • Standard-precision: 64-bit integers with up to 9 decimals of precision, and a smaller value range.

Note

By default, the official Python wheels ship in high-precision (128-bit) mode on all supported platforms.

For pure Rust crates, high-precision works on all platforms (including Windows) since Rust handles i128/u128 via software emulation. The default is standard-precision unless you explicitly enable the high-precision feature flag.

See the Installation Guide for further details.

Rust feature flag: To enable high-precision mode in Rust, add the high-precision feature to your Cargo.toml:

[dependencies]
nautilus-model = { version = "*", features = ["high-precision"] }

Installation

For PyPI binary wheels, use Python 3.13-3.15. Install nautilus_trader in a virtual environment to isolate dependencies.

There are two supported ways to install:

  1. Pre-built binary wheel from PyPI or the Nautech Systems package index.
  2. Build from source.

Tip

We highly recommend installing using the uv package manager with a "vanilla" CPython.

Conda and other Python distributions may work but aren't officially supported.

From PyPI

This repository and the documentation cover v2. To install the v2 release-candidate wheels from PyPI using Python's pip package manager:

pip install -U nautilus_trader --pre

The v2 release-candidate wheels use 2.0.0rcN versions and are intended for community testing before the final 2.0.0 release. We do not recommend using release candidates in production environments, such as live trading controlling real capital.

The --pre flag is required until 2.0.0 is released. Without it, pip installs the latest stable v1 wheel, whose Python API differs from the v2 documentation:

# Installs the latest stable v1 wheel, which cannot run the v2 documentation
pip install -U nautilus_trader

Install optional dependencies for interactive tearsheets and charts with the visualization extra:

pip install -U "nautilus_trader[visualization]" --pre

See the Installation Guide for details.

From the Nautech Systems package index

The Nautech Systems package index (packages.nautechsystems.io) complies with PEP-503 and hosts both stable and development binary wheels for nautilus_trader. This enables users to install either the latest stable release or pre-release versions for testing.

Stable wheels

Stable wheels correspond to official releases of nautilus_trader on PyPI, and use standard versioning. As on PyPI, the latest stable release is still on the 1.x line, whose Python API differs from these v2 docs. This index also hosts development wheels, so --pre allows those versions too. To install a specific 2.x release candidate, pin its version (nautilus_trader==2.0.0rcN).

To install the latest stable release:

pip install -U nautilus_trader --index-url=https://packages.nautechsystems.io/simple

Tip

Use --extra-index-url instead of --index-url to search both PyPI and the Nautech Systems package index. Pip selects the best matching version across both indexes without giving either index priority.

Development wheels

The main package index publishes v2 development wheels from both the nightly and develop branches, allowing users to test features and fixes ahead of stable releases.

This process also helps preserve compute resources and provides easy access to the exact binaries tested in CI pipelines, while adhering to PEP-440 versioning standards:

  • develop wheels use the version suffix .devYYYYMMDD+run.
  • nightly wheels use .devYYYYMMDD when the base version is already a pre-release, and aYYYYMMDD otherwise.
Platform Develop Nightly
Linux (x86_64) ✓ ✓
Linux (ARM64) - ✓
macOS (ARM64) - ✓
Windows (x86_64) - ✓

Warning

We do not recommend using development wheels in production environments, such as live trading controlling real capital.

Installation commands

By default, pip will install the latest stable release. Adding the --pre flag ensures that pre-release versions, including development wheels, are considered.

To install the latest available pre-release (including development wheels):

pip install -U nautilus_trader --pre --index-url=https://packages.nautechsystems.io/simple
Available versions

You can view all available versions of nautilus_trader on the package index.

To programmatically fetch and list available versions:

curl -s https://packages.nautechsystems.io/simple/nautilus-trader/index.html | sed -n 's/.*<a href="\([^"]*\)".*/\1/p' | awk -F'#' '{print $1}' | sort

Important

On Linux, confirm your glibc version with ldd --version and ensure it reports 2.35 or newer before installing binary wheels.

Branch updates
  • develop branch wheels (.devYYYYMMDD+run): Build and publish continuously with every merged commit.
  • nightly branch wheels (.devYYYYMMDD or aYYYYMMDD): Build and publish daily when we automatically merge the develop branch at 14:00 UTC (if there are changes).
Retention policies
  • develop branch wheels: We retain only the most recent wheel build.
  • nightly branch wheels: We retain only the 30 most recent publication dates per platform.
Verifying build provenance

All release artifacts published by the project carry cryptographic attestations generated by the CI/CD pipeline:

  • Python wheels and source distribution (PyPI, GitHub Releases, Nautech Systems package index): SLSA build provenance.
  • Docker images (ghcr.io/nautechsystems/nautilus_trader, ghcr.io/nautechsystems/jupyterlab): keyless cosign signatures plus SPDX SBOM attestations.

Both are issued via Sigstore and bound to a specific commit SHA, so verification ensures the artifact was produced by the official NautilusTrader GitHub Actions workflow and has not been tampered with since.

For step-by-step verification commands, see Verifying releases in SECURITY.md.

Important

Verification requires the GitHub CLI (gh) for Python artifacts and cosign for Docker images. Development wheels from develop and nightly branches are also attested.

From source

It's possible to install from source using pip if you first install the build dependencies as specified in the pyproject.toml.

  1. Install rustup (the Rust toolchain installer):

    • Linux and macOS:

      curl https://sh.rustup.rs -sSf | sh
    • Windows:

    • Verify (any system): from a terminal session run: rustc --version

  2. Enable cargo in the current shell:

    • Linux and macOS:

      source $HOME/.cargo/env
    • Windows:

      • Start a new PowerShell
  3. Install clang (a C language frontend for LLVM):

    • Linux (also installs lld, used as the Rust linker for faster builds):

      sudo apt-get install clang lld
    • macOS:

      xcode-select --install
    • Windows:

      1. Add Clang to your Build Tools for Visual Studio 2022:

        • Start | Visual Studio Installer | Modify | C++ Clang tools for Windows (latest) = checked | Modify
      2. Enable clang in the current shell:

        [System.Environment]::SetEnvironmentVariable('path', "C:\Program Files\Microsoft Visual Studio\2022\BuildTools\VC\Tools\Llvm\x64\bin\;" + $env:Path,"User")
    • Verify (any system): from a terminal session run: clang --version

  4. Install uv (see the uv installation guide for more details):

    • Linux and macOS:

      curl -LsSf https://astral.sh/uv/install.sh | sh
    • Windows (PowerShell):

      irm https://astral.sh/uv/install.ps1 | iex
  5. Clone the source with git, then sync its dependencies from the project root:

    git clone --branch develop --depth 1 https://github.com/nautechsystems/nautilus_trader
    cd nautilus_trader
    make sync

Note

The --depth 1 flag fetches just the latest commit for a faster, lightweight clone.

  1. Use the uv project environment.

    The uv project environment lives at python/.venv, beside python/pyproject.toml. Run direct uv project commands from python/ or pass --project python from the repository root.

    For PyO3 compilation on Linux and macOS, run these commands from the repository root after make sync in Bash or Zsh. For Fish commands, see the developer guide's environment setup. Set PYO3_PYTHON in each shell to this checkout's python/.venv/bin/python; replace any saved export that still points to the root .venv/bin/python.

    # Set the Python executable path for PyO3
    export PYO3_PYTHON="$PWD/python/.venv/bin/python"
    
    # Linux only: Set the library path for the uv-managed Python runtime
    PYTHON_LIB_DIR="$("$PYO3_PYTHON" -c 'import sysconfig; print(sysconfig.get_config_var("LIBDIR"))')"
    export LD_LIBRARY_PATH="$PYTHON_LIB_DIR${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
    
    # Required for Rust tests when using uv-installed Python
    export PYTHONHOME="$("$PYO3_PYTHON" -c 'import sys; print(sys.base_prefix)')"

Note

The LD_LIBRARY_PATH export is Linux-specific and not needed on macOS.

The PYTHONHOME variable is required when running make cargo-test with a uv-installed Python. Without it, tests that depend on PyO3 may fail to locate the Python runtime.

  1. Build and install NautilusTrader in release mode:

    make build

See the Installation Guide for other options and further details.

Redis

Using Redis with NautilusTrader is optional and only required if configured as the backend for a cache database or message bus. See the Redis section of the Installation Guide for further details.

Makefile

A Makefile is provided to automate most installation and build tasks for development. Some of the targets include:

  • make install: Installs in release build mode with all dependency groups and extras.
  • make install-debug: Same as make install but with debug build mode.
  • make sync: Installs Python dependencies without building the package.
  • make build: Builds and installs the package in release mode (default).
  • make build-debug: Builds and installs the package in debug mode.
  • make build-wheel: Builds a wheel in release mode.
  • make cargo-test: Runs all Rust crate tests using cargo-nextest.
  • make clean: Deletes build artifacts, caches, and build directories.
  • make distclean: CAUTION Removes all artifacts not in the git index when run with FORCE=1. This includes source files which have not been git added.
  • make docs: Builds the Python documentation with Sphinx and the Rust documentation with Cargo.
  • make pre-commit: Runs the pre-commit checks over all files.
  • make ruff: Runs Ruff over all files using python/pyproject.toml (with autofix).
  • make pytest: Runs all tests with pytest.
  • make cargo-ci-benches: Builds the Rust benchmarks used by CI.
  • make cargo-codspeed-build: Builds the Rust benchmark subset used for CodSpeed comparisons.

Tip

Run make help for documentation on all available make targets.

Tip

See the crates/infrastructure/TESTS.md file for running the infrastructure integration tests.

Examples

Indicators and strategies can be developed in Python or Rust. For performance and latency-sensitive applications, we recommend Rust. Below are some examples:

Docker

Docker containers are built with the following variant tags:

  • nautilus_trader:latest has the latest release version installed.
  • nautilus_trader:nightly has the head of the nightly branch installed.
  • jupyterlab:latest has the latest release version installed along with jupyterlab and an example backtest notebook with accompanying data.
  • jupyterlab:nightly has the head of the nightly branch installed along with jupyterlab and an example backtest notebook with accompanying data.

You can pull the container images as follows:

docker pull ghcr.io/nautechsystems/<image_variant_tag> --platform linux/amd64

You can launch the backtest example container by running:

docker pull ghcr.io/nautechsystems/jupyterlab:nightly --platform linux/amd64
docker run -p 8888:8888 ghcr.io/nautechsystems/jupyterlab:nightly

Then open your browser at the following address:

http://127.0.0.1:8888/lab

Warning

Examples use log_level="ERROR" because Nautilus logging exceeds Jupyter's stdout rate limit, causing notebooks to hang at lower log levels.

Development

We aim to provide the most pleasant developer experience possible for this hybrid Rust and Python codebase. See the Developer Guide for helpful information.

Nautilus Engineering maintains the engineering standards, lint configuration, pre-commit definitions, tool pins, and repository checks shared across Nautilus projects. This repository vendors selected files at the revision recorded in .nautilus-engineering.lock; project-specific policy and CI wiring remain local.

Tip

Run make build-debug to compile after Rust changes for the most efficient development workflow.

After changes to PyO3 bindings, stub annotations, or wrapped Rust docs, regenerate the generated Python artifacts from the repository root:

make py-stubs

Commit the generated .pyi files and PyO3 wrapper doc comments changed by this target. See Generated Python artifacts for details.

Testing with Rust

cargo-nextest is the standard Rust test runner for NautilusTrader. Its key benefit is isolating each test in its own process, ensuring test reliability by avoiding interference. See the Rust testing guidance for details about full-suite support and the limits of plain cargo test.

You can install cargo-nextest by running:

cargo install cargo-nextest

Tip

Run Rust tests with make cargo-test, which uses cargo-nextest with an efficient profile.

Contributing

Thank you for considering a contribution to NautilusTrader. We welcome high-quality work that improves the project. Before starting a substantial change, open an issue to discuss the problem and approach with the team. Small, self-contained fixes do not require prior agreement.

Before getting started, be sure to review the open-source scope outlined in the project's roadmap to understand what's in and out of scope.

Once you're ready to start working on your contribution, make sure to follow the guidelines outlined in the CONTRIBUTING.md file. This includes signing a Contributor License Agreement (CLA) to ensure that your contributions can be included in the project.

Note

Pull requests should target the develop branch (the default branch). This is where new features and improvements are integrated before release.

Thank you again for your interest in NautilusTrader! We look forward to reviewing your contributions and working with you to improve the project.

Community

Join our community of users and contributors on Discord to chat and stay up-to-date with the latest announcements and features of NautilusTrader. Whether you're a developer looking to contribute or just want to learn more about the platform, all are welcome on our Discord server.

Features and integrations excluded by the open-source scope are also out of scope for discussion across official NautilusTrader channels, including GitHub and Discord. This includes "Show & Tell" posts about downstream implementations, even when no contribution is offered and no support or upstream inclusion is requested. Correctness and performance reports about the core trading engine remain welcome. Keep those reports focused on the core behavior.

Warning

NautilusTrader does not issue, promote, or endorse any cryptocurrency tokens. Any claims or communications suggesting otherwise are unauthorized and false.

All official updates and communications from NautilusTrader will be shared exclusively through https://nautilustrader.io, our GitHub, our Discord server, or our verified X (Twitter) account: @NautilusTrader.

If you encounter any suspicious activity, please report it to the appropriate platform and contact us at [email protected].

License

The source code for NautilusTrader is available on GitHub under the GNU Lesser General Public License v3.0. Contributions to the project are welcome and require the completion of a standard Contributor License Agreement (CLA).


NautilusTrader™ is developed and maintained by Nautech Systems, a technology company specializing in the development of high-performance trading systems. For more information, visit https://nautilustrader.io.

Use of this software is subject to the Disclaimer.

© 2015-2026 Nautech Systems Pty Ltd. All rights reserved.

Recent activity

commits and pull requests

Releases and announcements

145 total
  1. NautilusTrader 2.0.0rc9v2.0.0rc9Nov 10, 2026pre-release397 downloads

    # NautilusTrader 2.0.0rc9 Released on 10th November 2026 (UTC). > [!NOTE] > This release adds support for Python 3.15. ### Enhancements - Added Kalshi initial adapter with market data, limit-order execution, and account reconciliation - Added FinFeedAPI prediction market data adapter with REST access, paginated historical requests, and polling - Added bracket exit reduce-only options (#5563), thanks @programskillforverification - Added indexed, count, and presence accessors for cached prices and funding rates (#5560), thanks @dxwil - Added Python Parquet funding rate write and query methods (#5555), thanks @chaneyka1 - Added `WebSocketClient::send_bytes_on_connection` (#5539), thanks @madebymlai - Added warnings for bounded startup fills without position coverage (#5541), thanks @zhaow-de - Added checked `StrikeRange::atm_percent` and `StrikeRange::delta` constructors - Added `BacktestNodeBuilder` with custom catalog factories for instrument loading and replay - Added `Cache` lazy instrument and synthetic loads, saved component-state deletion, and explicit heartbeat writes - Added `DataEngine` processing and managed books for external data clients (#5520), thanks @nicezic - Add

  2. NautilusTrader 2.0.0rc8v2.0.0rc8Oct 29, 2026pre-release398 downloads

    # NautilusTrader 2.0.0rc8 Released on 28th October 2026 (UTC). ### Enhancements - Added gzip support to buffered HTTP requests (#5420), thanks @cryptolenny3 - Added `ReplaySource` and `DataIterator::add_source` for fallible replay with pending frontiers - Added batched data subscriptions and unsubscriptions, thanks @faysou - Added batched historical instrument, quote, and trade requests, thanks @faysou - Added `on_data_response` hooks for historical completion and partial failures, thanks @faysou - Added `DataActor::request_group` for grouped historical request completion - Added Python historical request callbacks, `request_join`, and pending inspection for actors and strategies - Added historical request catalog write-back with confirmed source coverage, thanks @faysou - Added native external MessageBus data requests and replies for JSON and MessagePack - Added `LiveNode::add_python_exec_algorithm_from_config` for embedded Python execution algorithms - Added `LiveNode::add_python_strategy_from_config` for embedded Python strategies - Added `nautilus_pyo3::register_embedded_module` for embedded Python - Added `Money::from_decimal_exact` and `Money::from_str_ex

  3. NautilusTrader 2.0.0rc7v2.0.0rc7Oct 15, 2026pre-release445 downloads

    # NautilusTrader 2.0.0rc7 Released on 15th October 2026 (UTC). > [!NOTE] > This release removes support for Python 3.12 and supports Python 3.13 and 3.14 (#4676). ### Enhancements - Added negative price support for futures, except inverse futures (#5190), thanks @DeLuke84 - Added `Clock.set_timer_zoned` and `CalendarSchedule` for local calendar recurrence, thanks @faysou - Added `time_bars_time_zone` and `time_zone` overrides for local calendar bars, thanks @faysou - Added `BacktestDataConfig.batch_deltas` for batched book delta replay (#5215), thanks for reporting @nicezic - Added candidate option IDs for supported CME Globex and OSI equity/index contracts, thanks @faysou - Added reference instruments to `OptionSeriesId` with compatible derived-reference serialization, thanks @faysou - Added `OptionSideFilter` and `StrikeSearchProfile` model types for option selection, thanks @faysou - Added tick scheme registration, thanks @faysou - Added WebSocket peer-close callbacks to control automatic reconnection - Added Rust `QuoteTick::has_same_bid_ask` to compare prices and sizes independently of instrument IDs and timestamps - Added `YieldCurve` custom data for catalog storage and b

  4. NautilusTrader 2.0.0rc6v2.0.0rc6Oct 5, 2026pre-release1.1K downloads

    # NautilusTrader 2.0.0rc6 Released on 4th October 2026 (UTC). ### Enhancements - Added `WebSocketConfig.max_message_size_bytes` and `max_frame_size_bytes` configurable inbound size limits - Added configurable `writer_capacity` limits for socket and WebSocket clients, defaulting to 1,024 messages - Added `NAUTILUS_HTTP2_ADAPTIVE_WINDOW` env var to restore adaptive HTTP/2 flow-control windows - Added same-venue execution client registration with explicit venue or default routing - Added Rust `Cache::account_id_for_client` to resolve execution client accounts independent of issuers - Added Rust `Cache::client_id_for_venue` to resolve the execution client that venue or default routing selects - Added Python `Cache.top_of_book()` without cloning the resident book (#5011), thanks @youayouly - Added `RateOfChangeMode` for configurable ROC output units (#5144), thanks @faysou - Added MACD `signal` and `histogram` outputs (#5144), thanks @faysou - Added Bollinger Bands `stddev` output (#5144), thanks @faysou - Added independent VIDYA `cmo_period` configuration (#5144), thanks @faysou - Added Ichimoku per-line readiness flags (#5144), thanks @faysou - Added fallible Rust moving-average co

  5. NautilusTrader 2.0.0rc5v2.0.0rc5Sep 15, 2026pre-release573 downloads

    # NautilusTrader 2.0.0rc5 Released on 15th September 2026 (UTC). ### Enhancements - Added `client_id` and `endpoint` filters to actor `subscribe_socket_state` - Added a `channel` filter to actor `subscribe_queue_state` - Added `HttpClient::get_stream` and `HttpResponseStream` for HTTP bodies consumed without full buffering - Added `publish_message(...)`, `subscribe_topic(...)`, and `unsubscribe_topic(...)` for Python `DataActor`, `Strategy`, and `ExecutionAlgorithm` - Added `Cache` APIs and Redis/PostgreSQL persistence for `InstrumentClose` data - Added `avg_px` and report window fields to persisted execution reports - Added optional `BinaryOption.event_id` with Python and Arrow support - Added a `causation_id` property to every order event, and a `protection_price` property to `OrderUpdated` - Added `due_post_only` to the `OrderRejected` constructor, defaulting to `false` - Added remote resolution for `TestDataProvider` CSV loaders so they work from an installed wheel - Added user-defined portfolio statistics via `Portfolio.register_statistic()` and Python `PortfolioStatistic` - Added rolling `ZScore` indicator for Rust and Python (#4868), thanks @graceyangfan - Added named tas

Commits per week

last 52 weeks
2100Week of 2025-11-23: 74 commitsWeek of 2025-11-30: 85 commitsWeek of 2025-12-07: 87 commitsWeek of 2025-12-14: 53 commitsWeek of 2025-12-21: 36 commitsWeek of 2025-12-28: 86 commitsWeek of 2026-01-04: 85 commitsWeek of 2026-01-11: 76 commitsWeek of 2026-01-18: 77 commitsWeek of 2026-01-25: 55 commitsWeek of 2026-02-01: 92 commitsWeek of 2026-02-08: 68 commitsWeek of 2026-02-15: 73 commitsWeek of 2026-02-22: 94 commitsWeek of 2026-03-01: 80 commitsWeek of 2026-03-08: 73 commitsWeek of 2026-03-15: 81 commitsWeek of 2026-03-22: 100 commitsWeek of 2026-03-29: 102 commitsWeek of 2026-04-05: 87 commitsWeek of 2026-04-12: 97 commitsWeek of 2026-04-19: 101 commitsWeek of 2026-04-26: 102 commitsWeek of 2026-05-03: 130 commitsWeek of 2026-05-10: 104 commitsWeek of 2026-05-17: 128 commitsWeek of 2026-05-24: 150 commitsWeek of 2026-05-31: 138 commitsWeek of 2026-06-07: 156 commitsWeek of 2026-06-14: 162 commitsWeek of 2026-06-21: 149 commitsWeek of 2026-06-28: 81 commitsWeek of 2026-07-05: 90 commitsWeek of 2026-07-12: 101 commitsWeek of 2026-07-19: 163 commitsWeek of 2026-07-26: 172 commitsWeek of 2026-08-02: 153 commitsWeek of 2026-08-09: 197 commitsWeek of 2026-08-16: 133 commitsWeek of 2026-08-23: 155 commitsWeek of 2026-08-30: 128 commitsWeek of 2026-09-06: 157 commitsWeek of 2026-09-13: 113 commitsWeek of 2026-09-20: 142 commitsWeek of 2026-09-27: 131 commitsWeek of 2026-10-04: 116 commitsWeek of 2026-10-11: 154 commitsWeek of 2026-10-18: 142 commitsWeek of 2026-10-25: 151 commitsWeek of 2026-11-01: 210 commitsWeek of 2026-11-08: 137 commitsWeek of 2026-11-15: 80 commitsNov 23, 2025Nov 15, 2026
5.9K commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 54 commitsSun 1:00 — 30 commitsSun 2:00 — 20 commitsSun 3:00 — 11 commitsSun 4:00 — 21 commitsSun 5:00 — 30 commitsSun 6:00 — 59 commitsSun 7:00 — 172 commitsSun 8:00 — 322 commitsSun 9:00 — 311 commitsSun 10:00 — 298 commitsSun 11:00 — 241 commitsSun 12:00 — 190 commitsSun 13:00 — 174 commitsSun 14:00 — 200 commitsSun 15:00 — 228 commitsSun 16:00 — 261 commitsSun 17:00 — 265 commitsSun 18:00 — 238 commitsSun 19:00 — 159 commitsSun 20:00 — 127 commitsSun 21:00 — 135 commitsSun 22:00 — 98 commitsSun 23:00 — 52 commitsMon 0:00 — 37 commitsMon 1:00 — 18 commitsMon 2:00 — 14 commitsMon 3:00 — 19 commitsMon 4:00 — 17 commitsMon 5:00 — 23 commitsMon 6:00 — 91 commitsMon 7:00 — 147 commitsMon 8:00 — 180 commitsMon 9:00 — 157 commitsMon 10:00 — 186 commitsMon 11:00 — 199 commitsMon 12:00 — 183 commitsMon 13:00 — 150 commitsMon 14:00 — 124 commitsMon 15:00 — 117 commitsMon 16:00 — 155 commitsMon 17:00 — 186 commitsMon 18:00 — 195 commitsMon 19:00 — 131 commitsMon 20:00 — 135 commitsMon 21:00 — 129 commitsMon 22:00 — 101 commitsMon 23:00 — 88 commitsTue 0:00 — 34 commitsTue 1:00 — 29 commitsTue 2:00 — 12 commitsTue 3:00 — 16 commitsTue 4:00 — 26 commitsTue 5:00 — 37 commitsTue 6:00 — 61 commitsTue 7:00 — 102 commitsTue 8:00 — 156 commitsTue 9:00 — 131 commitsTue 10:00 — 151 commitsTue 11:00 — 167 commitsTue 12:00 — 135 commitsTue 13:00 — 123 commitsTue 14:00 — 145 commitsTue 15:00 — 112 commitsTue 16:00 — 158 commitsTue 17:00 — 189 commitsTue 18:00 — 195 commitsTue 19:00 — 181 commitsTue 20:00 — 139 commitsTue 21:00 — 109 commitsTue 22:00 — 76 commitsTue 23:00 — 74 commitsWed 0:00 — 31 commitsWed 1:00 — 13 commitsWed 2:00 — 23 commitsWed 3:00 — 24 commitsWed 4:00 — 21 commitsWed 5:00 — 39 commitsWed 6:00 — 68 commitsWed 7:00 — 127 commitsWed 8:00 — 125 commitsWed 9:00 — 127 commitsWed 10:00 — 146 commitsWed 11:00 — 148 commitsWed 12:00 — 153 commitsWed 13:00 — 140 commitsWed 14:00 — 120 commitsWed 15:00 — 120 commitsWed 16:00 — 133 commitsWed 17:00 — 170 commitsWed 18:00 — 248 commitsWed 19:00 — 204 commitsWed 20:00 — 134 commitsWed 21:00 — 155 commitsWed 22:00 — 117 commitsWed 23:00 — 62 commitsThu 0:00 — 22 commitsThu 1:00 — 35 commitsThu 2:00 — 21 commitsThu 3:00 — 24 commitsThu 4:00 — 26 commitsThu 5:00 — 30 commitsThu 6:00 — 51 commitsThu 7:00 — 93 commitsThu 8:00 — 162 commitsThu 9:00 — 139 commitsThu 10:00 — 153 commitsThu 11:00 — 142 commitsThu 12:00 — 151 commitsThu 13:00 — 156 commitsThu 14:00 — 132 commitsThu 15:00 — 126 commitsThu 16:00 — 122 commitsThu 17:00 — 161 commitsThu 18:00 — 220 commitsThu 19:00 — 178 commitsThu 20:00 — 122 commitsThu 21:00 — 125 commitsThu 22:00 — 115 commitsThu 23:00 — 73 commitsFri 0:00 — 44 commitsFri 1:00 — 18 commitsFri 2:00 — 13 commitsFri 3:00 — 19 commitsFri 4:00 — 28 commitsFri 5:00 — 28 commitsFri 6:00 — 58 commitsFri 7:00 — 130 commitsFri 8:00 — 150 commitsFri 9:00 — 129 commitsFri 10:00 — 120 commitsFri 11:00 — 126 commitsFri 12:00 — 124 commitsFri 13:00 — 132 commitsFri 14:00 — 135 commitsFri 15:00 — 122 commitsFri 16:00 — 167 commitsFri 17:00 — 160 commitsFri 18:00 — 171 commitsFri 19:00 — 96 commitsFri 20:00 — 58 commitsFri 21:00 — 99 commitsFri 22:00 — 85 commitsFri 23:00 — 51 commitsSat 0:00 — 44 commitsSat 1:00 — 27 commitsSat 2:00 — 17 commitsSat 3:00 — 9 commitsSat 4:00 — 13 commitsSat 5:00 — 27 commitsSat 6:00 — 58 commitsSat 7:00 — 180 commitsSat 8:00 — 278 commitsSat 9:00 — 328 commitsSat 10:00 — 293 commitsSat 11:00 — 257 commitsSat 12:00 — 182 commitsSat 13:00 — 191 commitsSat 14:00 — 185 commitsSat 15:00 — 193 commitsSat 16:00 — 221 commitsSat 17:00 — 258 commitsSat 18:00 — 189 commitsSat 19:00 — 126 commitsSat 20:00 — 103 commitsSat 21:00 — 98 commitsSat 22:00 — 93 commitsSat 23:00 — 104 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.
DateListRankStars gained
Aug 21, 2026daily#4+80
Aug 20, 2026daily#4+80
Aug 19, 2026daily#3+120
Aug 18, 2026daily#3+120
Feb 16, 2026daily#22+143
  • morluto/rea

    Reverse engineer anything with agents, from app behavior down to native binaries.

    471.6K stars · TypeScript

  • donnemartin/system-design-primer

    Learn how to design large-scale systems. Prep for the system design interview. Includes Anki flashcards.

    378.7K stars · Python

  • practical-tutorials/project-based-learning

    Curated list of project-based tutorials

    290.1K stars · Python

  • yt-dlp/yt-dlp

    A feature-rich command-line audio/video downloader

    209.4K stars · Python

  • tensorflow/tensorflow

    An Open Source Machine Learning Framework for Everyone

    201.7K stars · C++

  • ultraworkers/claw-code

    An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

    194.8K stars · Rust