alesha-pro GitHub avatar

4x3090-llm-benchmarks

alesha-pro

A publicly archived dataset of 638 LLM inference benchmarks from a 4x RTX 3090 home rig, with full per-run metadata including exact launch commands and queryable via SQLite, JSONL, and Markdown catalog.

Stars

11

7-day growth

No data

Forks

1

Open issues

0

License

No data

Last updated

2026-07-28

AI repository intelligence
FR-AI / ANALYSIS

Why it is worth attention

It provides an unusually detailed and reproducible benchmark archive that preserves model checkpoint, quantization, KV dtype, TP layout, engine build, and launch command for every run, enabling accurate cross-comparison and analysis that typical tok/s numbers alone cannot offer.

Who it is for

  • LLM inference benchmarking enthusiasts
  • Engineers optimizing multi-GPU LLM deployment on consumer hardware
  • Researchers comparing quantization methods or engine performance
  • Developers building or tuning vLLM, llama.cpp, or similar runtimes

Use cases

  • Compare inference throughput across quantization formats (e.g., AutoRound vs AWQ) on the same model and hardware
  • Determine optimal tensor parallelism (TP) and power limit for a given workload (e.g., single-stream vs high concurrency)
  • Analyze KV-cache efficiency with different context lengths and dtypes
  • Reproduce or validate published benchmark claims by checking exact launch commands and artifacts

Strengths

  • 637 of 638 measurements include the exact launch argv/command, ensuring reproducibility
  • Data is stored in multiple queryable formats (SQLite, JSONL) with schema documentation
  • Covers 14 model families, 20 benchmark campaigns, and 23 quantization categories across vLLM, llama.cpp, and exllamav3
  • Every row records runtime details (engine version, attention backend, KV-cache dtype, GPU layout, power limit) needed to interpret the metric

Considerations

  • Not a leaderboard; harness and test variables change between campaigns, so direct row-to-row comparison is only valid within the same campaign
  • Based on a single hardware configuration (4x RTX 3090 on PCIe 3.0, no NVLink), limiting generalization to other setups
  • Dataset updates are manual and infrequent; new snapshots are published only when the author reviews and pushes them

README quick start

4x RTX 3090 LLM benchmark archive

638 local inference measurements from one 96 GB home rig. The exact launch command is attached to 637 of them.

Most benchmark posts give you a model name and one tok/s number. I kept losing the rest: which checkpoint, which quant, which KV dtype, which TP layout, which engine build, and whether the number meant single-stream decode or aggregate throughput.

This repository is the database I wanted. You can inspect one result in the Markdown catalog, query all of them in SQLite, or take the JSONL and run your own analysis.

Navigation

OpenWhat is there
ModelsAll 14 model families and their runs
Benchmark campaignsMatched experiments and test matrices
EnginesvLLM, llama.cpp, and the experimental exllamav3 slice
Query guideReady-to-run SQLite, JSONL, and Python examples
MethodologyMetric definitions, comparison rules, and limitations
HardwareThe 4x RTX 3090 rig, topology, power limits, and software versions
Dataset filesJSONL, SQLite, snapshot metadata, and schema notes

The archive currently has 638 measurements from 20 benchmark campaigns across 14 model families. Most runs use vLLM. The llama.cpp set is smaller, and the 38 exllamav3 rows came from a short experiment rather than broad engine coverage.

This is a benchmark archive, not a leaderboard. The harness and the variable I was testing changed between campaigns, so some rows should not be compared directly. Each row keeps its workload, topology, power limit, engine version, source references, and launch command when available. 637 of 638 measurements retain an exact argv or command.

What makes one row useful

Every result keeps the context needed to understand or reproduce it:

Recorded with the numberExamples
Model artifactcheckpoint, quantization recipe, source revision
Runtimeengine, version, attention backend, KV-cache dtype
GPU layoutTP, PP, DP, instance count, power limit, P2P state
Workloadprompt length, output length, concurrency, context limit
Metric meaningsingle-stream wall rate, decode rate, aggregate output, TTFT
Receipt

Description

Local LLM speed measurements from a 4x RTX 3090 rig, with exact launch commands and per-run provenance.

Related repositories

Similar projects matched by category, topics, and programming language.

gavamedia
Featured
gavamedia GitHub avatar

deltafin

Deltafin is a research project that runs the 2.8-trillion-parameter Mixture-of-Experts model Kimi K3 on a single Apple Silicon Mac (e.g., M1 Max with 64 GB) at about 16 seconds per token, using exact, reproducible inference with local or streaming expert loading.

AI & Machine LearningLarge Language Models
304
slvDev
Featured
slvDev GitHub avatar

esp32-ai

A 28.9 million parameter language model runs on an $8 ESP32-S3 microcontroller entirely on-device, generating simple stories at about 9.5 tokens per second.

AI & Machine LearningLarge Language Models
1,960
jamesob
Featured
jamesob GitHub avatar

local-llm

A comprehensive guide for building and configuring a high-end local machine to run state-of-the-art LLMs, with detailed hardware choices, BIOS tuning, and Docker-based model serving.

AI & Machine LearningLarge Language Models
1,660