RyanCodrai/turbovecPublic

A vector index built on TurboQuant, written in Rust with Python bindings

AI summary: A memory-efficient Rust vector index with Python bindings, built on Google's TurboQuant algorithm.

Stars
17.5K
+6 today
Forks
1.5K
Watchers
71
Open issues
23
Open PRs
1
Contributors
~8
Commits
376
Branches
5
Views (30d)
2

RustMITCreated Mar 26, 2026Last push 1mo ago+12 stars this week+103 this month

Quick answers

What is turbovec?
A memory-efficient Rust vector index with Python bindings, built on Google's TurboQuant algorithm.
What does turbovec do?
turbovec is a high-performance vector index implemented in Rust that utilizes Google Research's TurboQuant algorithm to achieve extreme memory compression. It allows a 10 million document corpus to fit into 4 GB of RAM instead of the typical 31 GB required for float32. The system maps coordinates to a canonical Beta distribution using Hadamard transforms and applies Lloyd-Max scalar quantization without requiring a separate training phase. It features fast, hand-written SIMD search kernels for both ARM and x86 architectures, often outperforming traditional FAISS indexes in speed. It supports online ingestion, incremental saves, and search-time filtering.
Who is turbovec for?
Data engineers, ML practitioners, and backend developers needing fast, memory-efficient vector search for RAG or similarity applications. Familiarity with Python or Rust is required.
How do I get started with turbovec?
pip install turbovec
How popular is turbovec on GitHub?
RyanCodrai/turbovec has 17,498 stars and 1,483 forks on GitHub, and gained 12 stars in the last 7 days.
What license does turbovec use?
RyanCodrai/turbovec is released under the MIT license.

Star history

since Jul 28, 2026
05K10K15KJul 2026Sep 2026Oct 2026Nov 2026
17.5K stars as of Nov 17, 2026. Measured daily since Jul 28, 2026; GitHub no longer exposes earlier star timestamps.

Contribution activity

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

Signals and awards

derived from tracked data
  • Widely adopted

    17,498 stars

  • Well documented

    High community health score

  • Permissive license

    MIT

  • Continuous integration

    Automated checks passing

  • Repeat trending

    9 trending appearances

What turbovec does

turbovec is a high-performance vector index implemented in Rust that utilizes Google Research's TurboQuant algorithm to achieve extreme memory compression. It allows a 10 million document corpus to fit into 4 GB of RAM instead of the typical 31 GB required for float32. The system maps coordinates to a canonical Beta distribution using Hadamard transforms and applies Lloyd-Max scalar quantization without requiring a separate training phase. It features fast, hand-written SIMD search kernels for both ARM and x86 architectures, often outperforming traditional FAISS indexes in speed. It supports online ingestion, incremental saves, and search-time filtering.

Data engineers, ML practitioners, and backend developers needing fast, memory-efficient vector search for RAG or similarity applications. Familiarity with Python or Rust is required.

  • Online Vector Ingestion: Adds vectors dynamically with no training step, parameter tuning, or index rebuilds required.
  • SIMD-Optimized Search: Uses hand-written NEON (ARM) and AVX-512BW (x86) kernels for blazing fast similarity search.
  • Extreme Memory Compression: Applies advanced Hadamard transforms and scalar quantization to provide up to 16x memory savings.
  • Search-Time Filtering: Honors ID allowlists or slot bitmasks directly within the SIMD kernel to prevent over-fetching.
  • Incremental Disk Syncing: Persists only the changes made since the last sync, ensuring crash-safe, fast saves.
  • Seamless Framework Integration: Provides drop-in replacements for vector stores in LangChain, LlamaIndex, Haystack, and Agno.

Where teams use it

High-Scale Vector Search

Running massive vector databases on memory-constrained or cost-sensitive hardware environments.

Low-Latency RAG Pipelines

Improving retrieval speed and reducing memory footprint in retrieval-augmented generation architectures.

On-Device Embeddings

Deploying large vector indices on edge devices, consumer hardware, or air-gapped systems.

Hybrid Search Retrieval

Combining dense vector reranking with candidate sets produced by external systems like SQL or BM25.

Getting started: pip install turbovec

README

main branch

turbovec — Google's TurboQuant for vector search

License PyPI version crates.io version TurboQuant paper

Python · Rust · How it compares · When to use something else · API reference · Benchmarks


Ten million 768-dimensional embeddings take 31 GB of RAM as float32. turbovec holds them in 4 GB and searches them 4.4× faster than FAISS, at matching recall.

turbovec is an in-process vector index for Python and Rust. It stores each vector at 2 or 4 bits per dimension using Google Research's TurboQuant and searches that compressed form directly with agent-optimised SIMD kernels.

  • Fast. 4.4× FAISS FastScan at 4-bit and 2.2× at 2-bit, on ARM and x86. A staged search scans one bit plane and rescores the shortlist exactly.
  • Low memory. 7.8× smaller than float32 at 4-bit, 15.5× at 2-bit, at the same recall as FAISS.
  • Online. No training step, no rebuilds: the codebook comes from the maths, not your data. Add a vector and it is searchable; remove one in microseconds.
  • Incremental. sync(path) writes only what changed since the last call — one fsync, crash-safe at any byte, milliseconds however large the index.
  • Local. A library, not a service: nothing leaves your process. Pair it with an open-source embedding model for a fully offline stack.
  • Filtered. Pass an allowlist of ids or a bitmask; the kernel skips what the filter excludes and returns up to k results from the allowed set.

Python

pip install turbovec
import numpy as np
from turbovec import TurboQuantIndex

vectors = np.load("embeddings.npy").astype(np.float32)   # shape (n, 1536)

index = TurboQuantIndex(dim=1536, bit_width=4)
index.add(vectors)

scores, indices = index.search(vectors[:1], k=5)
print(indices)         # [[    0 86544  3385 84492 24967]]   int64 slot positions
print(scores.shape)    # (1, 5)                             float32 inner products

index.sync("index.tv")                  # first sync writes the file
index.add(more_vectors)
index.sync("index.tv")                  # later syncs write just the change, durably

index = TurboQuantIndex.load("index.tv")   # loads either a sync'd or a write() file

Inputs are 2-D float32 arrays of shape (n, dim); other dtypes raise rather than silently convert. Scores are inner products, so normalise your vectors if you want cosine similarity.

Need ids that survive deletes? IdMapIndex keys everything by your own uint64 ids:

from turbovec import IdMapIndex

index = IdMapIndex(dim=1536, bit_width=4)
index.add_with_ids(vectors, ids)               # ids: uint64 array, one per row

scores, ids = index.search(query, k=10)        # your ids, not slot positions
index.remove(1002)                             # O(1)

# Filter: only ids another system approved — a SQL predicate, an ACL, a time window.
allowed = np.array([1001, 1003, 1042], dtype=np.uint64)
scores, ids = index.search(query, k=10, allowlist=allowed)   # shape (1, min(k, 3))

Framework integrations are drop-in replacements for each framework's in-memory store — same public surface, same persistence, same retriever wiring: LangChain (pip install turbovec[langchain]) · LlamaIndex (turbovec[llama-index]) · Haystack (turbovec[haystack]) · Agno (turbovec[agno]).

Rust

cargo add turbovec
use turbovec::{IdMapIndex, TurboQuantIndex};

let mut index = TurboQuantIndex::new(1536, 4)?;
index.add(&vectors);                          // &[f32], row-major, n × 1536
let results = index.search(&queries, 10);     // scores and slot indices, nq × 10
index.write("index.tv")?;
let index = TurboQuantIndex::load("index.tv")?;

let mut ids = IdMapIndex::new(1536, 4)?;
ids.add_with_ids(&vectors, &[1001, 1002, 1003])?;
let (scores, found) = ids.search(&queries, 10);
ids.remove(1002);

The Rust API mirrors the Python one; docs/api.md covers both, including the file formats, sync(), calibration and the staged search.

How it compares

All figures: 100K OpenAI embeddings (d=1536 and d=3072) and GloVe (d=200), k=64, 1K queries, median of 5 runs, on a GCP c4a-standard-8 (ARM) and c3-standard-8 (x86), against FAISS at a matched bit rate. Scripts, raw JSON and every chart are in docs/benchmarks.md.

Search speed, ARM, multi-threaded: turbovec vs FAISS IndexPQFastScan

Recall at k on OpenAI d=1536: turbovec vs FAISS IndexPQ at the same bit rate

turbovec FAISS
Search, 4-bit 3.8–5.1× faster across the eight cells (ARM 4.0×, x86 4.9×) IndexPQFastScan every cell
Search, 2-bit 1.8–2.5× faster (ARM 2.05×, x86 2.35×) IndexPQFastScan every cell
Recall@1, OpenAI 0.959 / 0.981 at 4-bit, 0.901 / 0.931 at 2-bit (d=1536 / d=3072) 0.966 / 0.971, 0.876 / 0.911 IndexPQ, m matched to bit rate
Recall@1, GloVe d=200 0.860 at 4-bit, 0.572 at 2-bit 0.842, 0.565 IndexPQ, m matched to bit rate
Memory, d=1536 75 MB at 4-bit, 38 MB at 2-bit 586 MB float32 7.8× / 15.5×
Single add() 7.9–21.7 µs 6.3–12.6× slower into a trained, populated index
remove(id) 1.4–5.8 µs 0.19–1.03 s FAISS repacks all codes per call
Whole-file save 1.0–1.4× slower than FAISS write_index turbovec fsyncs and renames atomically
Load → first search 1.0–1.5× slower than FAISS read_index 40 vs 31 ms at d=1536 4-bit on x86

Both always return the true nearest neighbour within the first 8 results on the OpenAI corpora. The full suite — every chart, the raw JSON and the scripts to re-run it — is in docs/benchmarks.md.

When to use something else

  • You need a graph index. turbovec scans every vector. At 100K vectors a query costs 0.13–0.25 ms on all eight cores of the benchmark boxes and 0.5–2.0 ms on one thread (k=64, 1,000-query batches, d=1536 to d=3072), and the cost grows linearly with the corpus. For hundreds of millions of vectors behind strict latency, an HNSW or IVF index in front of it is the right shape, and turbovec is not one.
  • You need exact float results. Quantization is lossy. On the OpenAI corpora the top result matches the float ground truth 96–98% of the time at 4-bit (90–93% at 2-bit) and is always within the first 8 returned; low-dimensional embeddings such as GloVe d=200 lose more. Check recall on a sample of your own data.
  • You need a server. turbovec is a library with a file format. There is no network API, replication or multi-tenant service; the integrations above are how it slots into a stack that has those.
  • Your vectors are not multiples of 8 wide, or wider than 16,384. Those are the dimension limits. Bit widths are 2 and 4.

How it works

Normalise each vector and store its length. Rotate every vector by one shared random orthogonal matrix, after which each coordinate follows a known distribution whatever the input. Quantise each coordinate with a Lloyd-Max codebook computed for that distribution — 4 levels at 2-bit, 16 at 4-bit — and bit-pack. At search time the query is rotated once and scored against the codebook with SIMD lookup tables; a per-vector scalar fixed at encode time removes the inner-product bias quantization introduces. An optional one-shot calibrate(sample) fits two scalars per coordinate for data that drifts from the asymptotic distribution (low-dimensional and word-vector embeddings gain most).

The full walk-through, with the maths and the references, is in docs/how-it-works.md.

Building from source

Python wheel and Rust crate
pip install maturin
cd turbovec-python && maturin build --release && pip install target/wheels/*.whl
cargo build --release

x86_64 builds target x86-64-v2 (SSE4.2, Nehalem 2008+) via .cargo/config.toml; the AVX-512 and AVX2 kernels are #[target_feature]-gated and chosen at runtime with is_x86_feature_detected!, so one binary runs everywhere and uses what the CPU has. Running the benchmark suite is described in docs/benchmarks.md.

References

View on GitHub

Recent activity

commits and pull requests

Code frequency

additions and deletions
+44.5K-44.5KWeek of 2026-03-22: +688 linesWeek of 2026-03-22: -120 linesWeek of 2026-03-29: +10,795 linesWeek of 2026-03-29: -5,454 linesWeek of 2026-04-05: +0 linesWeek of 2026-04-05: -0 linesWeek of 2026-04-12: +2,648 linesWeek of 2026-04-12: -1,271 linesWeek of 2026-04-19: +4,674 linesWeek of 2026-04-19: -556 linesWeek of 2026-04-26: +29 linesWeek of 2026-04-26: -0 linesWeek of 2026-05-03: +0 linesWeek of 2026-05-03: -0 linesWeek of 2026-05-10: +0 linesWeek of 2026-05-10: -0 linesWeek of 2026-05-17: +9,152 linesWeek of 2026-05-17: -685 linesWeek of 2026-05-24: +7,229 linesWeek of 2026-05-24: -1,708 linesWeek of 2026-05-31: +0 linesWeek of 2026-05-31: -0 linesWeek of 2026-06-07: +1,460 linesWeek of 2026-06-07: -2,144 linesWeek of 2026-06-14: +0 linesWeek of 2026-06-14: -0 linesWeek of 2026-06-21: +0 linesWeek of 2026-06-21: -0 linesWeek of 2026-06-28: +0 linesWeek of 2026-06-28: -0 linesWeek of 2026-07-05: +0 linesWeek of 2026-07-05: -0 linesWeek of 2026-07-12: +0 linesWeek of 2026-07-12: -0 linesWeek of 2026-07-19: +9,547 linesWeek of 2026-07-19: -2,197 linesWeek of 2026-07-26: +43,436 linesWeek of 2026-07-26: -8,154 linesWeek of 2026-08-02: +38,104 linesWeek of 2026-08-02: -6,115 linesWeek of 2026-08-09: +3,671 linesWeek of 2026-08-09: -177 linesWeek of 2026-08-16: +3,541 linesWeek of 2026-08-16: -5,129 linesWeek of 2026-08-23: +0 linesWeek of 2026-08-23: -0 linesWeek of 2026-08-30: +0 linesWeek of 2026-08-30: -0 linesWeek of 2026-09-06: +0 linesWeek of 2026-09-06: -0 linesWeek of 2026-09-13: +0 linesWeek of 2026-09-13: -0 linesWeek of 2026-09-20: +0 linesWeek of 2026-09-20: -0 linesWeek of 2026-09-27: +44,453 linesWeek of 2026-09-27: -152 linesWeek of 2026-10-04: +6,003 linesWeek of 2026-10-04: -1,950 linesWeek of 2026-10-11: +0 linesWeek of 2026-10-11: -0 linesWeek of 2026-10-18: +0 linesWeek of 2026-10-18: -0 linesWeek of 2026-10-25: +0 linesWeek of 2026-10-25: -0 linesWeek of 2026-11-01: +0 linesWeek of 2026-11-01: -0 linesWeek of 2026-11-08: +0 linesWeek of 2026-11-08: -0 linesMar 22, 2026Nov 8, 2026
+185.4K lines added, -35.8K removed over the last year.

Commits per week

last 52 weeks
1400Week of 2025-11-16: 0 commitsWeek of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 0 commitsWeek of 2026-02-15: 0 commitsWeek of 2026-02-22: 0 commitsWeek of 2026-03-01: 0 commitsWeek of 2026-03-08: 0 commitsWeek of 2026-03-15: 0 commitsWeek of 2026-03-22: 17 commitsWeek of 2026-03-29: 38 commitsWeek of 2026-04-05: 0 commitsWeek of 2026-04-12: 40 commitsWeek of 2026-04-19: 14 commitsWeek of 2026-04-26: 1 commitsWeek of 2026-05-03: 0 commitsWeek of 2026-05-10: 0 commitsWeek of 2026-05-17: 17 commitsWeek of 2026-05-24: 17 commitsWeek of 2026-05-31: 0 commitsWeek of 2026-06-07: 8 commitsWeek of 2026-06-14: 0 commitsWeek of 2026-06-21: 0 commitsWeek of 2026-06-28: 0 commitsWeek of 2026-07-05: 0 commitsWeek of 2026-07-12: 0 commitsWeek of 2026-07-19: 29 commitsWeek of 2026-07-26: 140 commitsWeek of 2026-08-02: 16 commitsWeek of 2026-08-09: 14 commitsWeek of 2026-08-16: 7 commitsWeek of 2026-08-23: 0 commitsWeek of 2026-08-30: 0 commitsWeek of 2026-09-06: 0 commitsWeek of 2026-09-13: 0 commitsWeek of 2026-09-20: 0 commitsWeek of 2026-09-27: 4 commitsWeek of 2026-10-04: 10 commitsWeek of 2026-10-11: 0 commitsWeek of 2026-10-18: 0 commitsWeek of 2026-10-25: 0 commitsWeek of 2026-11-01: 0 commitsWeek of 2026-11-08: 0 commitsNov 16, 2025Nov 8, 2026
372 commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 1 commitsSun 1:00 — 0 commitsSun 2:00 — 0 commitsSun 3:00 — 0 commitsSun 4:00 — 0 commitsSun 5:00 — 4 commitsSun 6:00 — 0 commitsSun 7:00 — 0 commitsSun 8:00 — 0 commitsSun 9:00 — 3 commitsSun 10:00 — 2 commitsSun 11:00 — 5 commitsSun 12:00 — 0 commitsSun 13:00 — 0 commitsSun 14:00 — 0 commitsSun 15:00 — 1 commitsSun 16:00 — 0 commitsSun 17:00 — 0 commitsSun 18:00 — 2 commitsSun 19:00 — 5 commitsSun 20:00 — 4 commitsSun 21:00 — 5 commitsSun 22:00 — 2 commitsSun 23:00 — 10 commitsMon 0:00 — 2 commitsMon 1:00 — 0 commitsMon 2:00 — 0 commitsMon 3:00 — 0 commitsMon 4:00 — 0 commitsMon 5:00 — 0 commitsMon 6:00 — 1 commitsMon 7:00 — 0 commitsMon 8:00 — 0 commitsMon 9:00 — 0 commitsMon 10:00 — 4 commitsMon 11:00 — 6 commitsMon 12:00 — 4 commitsMon 13:00 — 4 commitsMon 14:00 — 7 commitsMon 15:00 — 10 commitsMon 16:00 — 7 commitsMon 17:00 — 7 commitsMon 18:00 — 10 commitsMon 19:00 — 7 commitsMon 20:00 — 5 commitsMon 21:00 — 4 commitsMon 22:00 — 7 commitsMon 23:00 — 5 commitsTue 0:00 — 0 commitsTue 1:00 — 0 commitsTue 2:00 — 0 commitsTue 3:00 — 0 commitsTue 4:00 — 0 commitsTue 5:00 — 0 commitsTue 6:00 — 0 commitsTue 7:00 — 0 commitsTue 8:00 — 0 commitsTue 9:00 — 1 commitsTue 10:00 — 0 commitsTue 11:00 — 1 commitsTue 12:00 — 1 commitsTue 13:00 — 4 commitsTue 14:00 — 2 commitsTue 15:00 — 4 commitsTue 16:00 — 6 commitsTue 17:00 — 5 commitsTue 18:00 — 3 commitsTue 19:00 — 0 commitsTue 20:00 — 1 commitsTue 21:00 — 3 commitsTue 22:00 — 1 commitsTue 23:00 — 3 commitsWed 0:00 — 6 commitsWed 1:00 — 6 commitsWed 2:00 — 3 commitsWed 3:00 — 3 commitsWed 4:00 — 5 commitsWed 5:00 — 3 commitsWed 6:00 — 0 commitsWed 7:00 — 0 commitsWed 8:00 — 0 commitsWed 9:00 — 1 commitsWed 10:00 — 0 commitsWed 11:00 — 9 commitsWed 12:00 — 4 commitsWed 13:00 — 3 commitsWed 14:00 — 2 commitsWed 15:00 — 4 commitsWed 16:00 — 9 commitsWed 17:00 — 4 commitsWed 18:00 — 5 commitsWed 19:00 — 4 commitsWed 20:00 — 5 commitsWed 21:00 — 3 commitsWed 22:00 — 4 commitsWed 23:00 — 1 commitsThu 0:00 — 0 commitsThu 1:00 — 0 commitsThu 2:00 — 0 commitsThu 3:00 — 0 commitsThu 4:00 — 0 commitsThu 5:00 — 1 commitsThu 6:00 — 1 commitsThu 7:00 — 0 commitsThu 8:00 — 0 commitsThu 9:00 — 1 commitsThu 10:00 — 1 commitsThu 11:00 — 3 commitsThu 12:00 — 3 commitsThu 13:00 — 1 commitsThu 14:00 — 8 commitsThu 15:00 — 2 commitsThu 16:00 — 1 commitsThu 17:00 — 0 commitsThu 18:00 — 0 commitsThu 19:00 — 1 commitsThu 20:00 — 1 commitsThu 21:00 — 1 commitsThu 22:00 — 7 commitsThu 23:00 — 3 commitsFri 0:00 — 2 commitsFri 1:00 — 2 commitsFri 2:00 — 0 commitsFri 3:00 — 0 commitsFri 4:00 — 0 commitsFri 5:00 — 0 commitsFri 6:00 — 0 commitsFri 7:00 — 0 commitsFri 8:00 — 6 commitsFri 9:00 — 4 commitsFri 10:00 — 1 commitsFri 11:00 — 3 commitsFri 12:00 — 0 commitsFri 13:00 — 9 commitsFri 14:00 — 1 commitsFri 15:00 — 2 commitsFri 16:00 — 1 commitsFri 17:00 — 5 commitsFri 18:00 — 4 commitsFri 19:00 — 1 commitsFri 20:00 — 0 commitsFri 21:00 — 1 commitsFri 22:00 — 9 commitsFri 23:00 — 1 commitsSat 0:00 — 2 commitsSat 1:00 — 0 commitsSat 2:00 — 0 commitsSat 3:00 — 0 commitsSat 4:00 — 0 commitsSat 5:00 — 0 commitsSat 6:00 — 0 commitsSat 7:00 — 0 commitsSat 8:00 — 0 commitsSat 9:00 — 0 commitsSat 10:00 — 1 commitsSat 11:00 — 0 commitsSat 12:00 — 0 commitsSat 13:00 — 2 commitsSat 14:00 — 2 commitsSat 15:00 — 1 commitsSat 16:00 — 3 commitsSat 17:00 — 4 commitsSat 18:00 — 2 commitsSat 19:00 — 0 commitsSat 20:00 — 1 commitsSat 21:00 — 1 commitsSat 22:00 — 11 commitsSat 23:00 — 2 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.

Who is committing

last 52 weeks
Maintainer commits364 (97%)
Community commits12 (3%)

376 commits in total over the last year.

DateListRankStars gained
Aug 22, 2026daily#12+230
Aug 21, 2026daily#12+230
Jun 10, 2026daily#22+19
Jun 9, 2026daily#5+34
Jun 8, 2026daily#5+66
Jun 7, 2026daily#3+166
Jun 6, 2026daily#14+65
May 22, 2026daily#22+45
May 21, 2026daily#20+43
  • 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