Astral ty Python Type Checker: 60x Faster Than Mypy

Astral released ty Beta on December 16, 2025—a Python type checker that runs 10-60x faster than mypy and Pyright. The type checks that take large organizations 25-30 minutes with mypy complete in 10-15 seconds with ty. On the PyTorch codebase, incremental updates finish in 4.7 milliseconds versus Pyrefly’s 2.38 seconds—500x faster. This performance doesn’t just save time. It unlocks workflows that were impractical before: pre-commit hooks without bottlenecks, real-time editor feedback without lag, and CI/CD pipelines that don’t wait on type checking.

Performance That Changes What’s Possible

The benchmarks are dramatic. On the home-assistant project, ty completes type checks in 2.19 seconds. Pyright takes 19.62 seconds. mypy takes 45.66 seconds. That’s 9x and 21x faster respectively. However, the cold-run numbers miss the real story.

Incremental updates reveal ty’s architectural advantage. After editing a load-bearing file in the PyTorch repository, ty recomputes diagnostics in 4.7 milliseconds—80x faster than Pyright’s 386 milliseconds and 500x faster than Pyrefly’s 2.38 seconds. This isn’t just speed. It’s the difference between real-time feedback and perceptible lag. Between usable and unusable.

Community benchmarks align with Astral’s claims. One developer reported on Hacker News checking their large codebase in 0.5 seconds versus mypy’s 18 seconds—a 36x improvement. Pre-commit hooks become practical when type checks drop from 18 seconds to half a second. CI/CD pipelines stop bottlenecking when 30-minute type check runs shrink to 15 seconds.

The speed comes from architectural decisions. ty uses the Salsa incremental computation framework—the same system powering Rust Analyzer. Fine-grained incrementality means changing one function triggers re-parsing only that function and its dependents, not the entire codebase. This query-based memoization is why incremental gains (500x) exceed cold-run advantages (21x). Competitors would need ground-up rewrites to match this.

The Accuracy Trade-Off: Beta Means Fast but Maturing

ty’s speed comes with a current limitation: accuracy trails Pyright. Independent conformance testing shows ty passes approximately 15% of test cases, compared to 69% for zuban and 58% for Pyrefly. Pyright, the gold standard, passes significantly more.

Real-world testing confirms the gap. One developer benchmarked a 100,000-line codebase and found ty generated 1,599 diagnostics in 2.5 seconds. Pyright found 10 errors in 13.6 seconds—all 10 were correct. The developer’s conclusion: “There’s plenty of potential here, but Ty’s type inference is just not as sophisticated as Pyright’s.”

Astral’s strategy is deliberate: ship disruptive performance now, iterate rapidly on accuracy. This approach worked for Ruff (initially “too fast to trust,” now the industry standard with 100,000+ GitHub stars) and uv (30,000 stars in under a year, displacing pip/poetry). Astral uses ty exclusively in their own projects—uv and Ruff development—which signals confidence despite Beta limitations.

The Stable release roadmap targets 2026 with focus on >60% conformance, direct Pydantic and Django support, and stability improvements. For now, ty is production-ready for teams willing to trade some false positives for transformative speed gains.

Related: Developer Productivity Metrics Fail: 66% Distrust Crisis

Astral’s Track Record Validates The Bet

ty is the third tool completing Astral’s Rust-based Python ecosystem. The pattern across all three is consistent: disruptive performance, community skepticism, rapid adoption, accuracy improvements, industry dominance.

Ruff launched as a Python linter/formatter claiming 10-100x speed over existing tools. Initial reactions questioned whether such performance was real. Today, Ruff has 100,000+ GitHub stars and ships with FastAPI, Airflow, and major Python projects. It’s the de facto standard despite being “impossibly fast” two years ago.

uv followed the same trajectory. Astral’s Python package manager hit 30,000 GitHub stars in under a year with 10x faster installations than pip. Both tools now serve tens of millions of monthly downloads. The community response to ty echoes this history: “Finally the missing puzzle piece from the astral toolchain is here!”

Astral has VC funding, a full-time team, and a proven ability to ship fast and iterate relentlessly. Betting on ty isn’t betting on current Beta quality—it’s betting on Astral’s execution track record. The company that turned “Rust-based Python tooling” from experiment to industry standard knows how to close the accuracy gap.

Related: Rust Hits Industry Tipping Point: 68% Commercial Growth in 3 Years

When to Adopt ty Python Type Checker

ty is production-ready for specific scenarios. Large codebases where mypy runs exceed 5 minutes see immediate productivity gains. Teams already using uv and Ruff benefit from ecosystem cohesion. Developers prioritizing editor responsiveness over absolute accuracy get keystroke-level type feedback without crashes or lag.

It’s not ready for mission-critical systems requiring battle-tested accuracy, Django or SQLAlchemy-heavy codebases (no plugin system yet), or risk-averse organizations. The recommended strategy: run ty alongside mypy or Pyright initially. Use ty for fast editor feedback. Keep existing tools in CI for verification. Evaluate accuracy improvements as Astral progresses toward Stable 2026.

Installation is straightforward via uv:

# Install ty globally
uv tool install ty@latest

# Quick check all Python files
uvx ty check

# Check specific directories
ty check src/

Astral’s roadmap targets >60% conformance by Stable release in 2026, with direct support for Pydantic and Django. For teams hitting mypy’s productivity ceiling today, ty’s Beta offers transformative speed now—with a clear path to accuracy parity ahead.

Key Takeaways

• Astral released ty Beta on December 16, 2025: Python type checker delivering 10-60x faster performance than mypy/Pyright, with 500x faster incremental updates (4.7ms vs 2.38s on PyTorch).
• Performance gains enable new workflows—pre-commit hooks without bottlenecks (0.5s vs 18s), real-time editor feedback without lag, and CI/CD pipelines that don’t wait on type checking (15s vs 30 minutes).
• Accuracy currently trails Pyright: ty passes ~15% conformance tests versus ~69% for zuban and ~58% for Pyrefly. Real-world example: 1,599 ty diagnostics versus 10 correct Pyright errors on 100K LOC codebase.
• Astral’s execution track record validates the strategy: Ruff hit 100,000+ GitHub stars (industry standard linter), uv reached 30,000 stars in under a year (displacing pip/poetry). Both prove disruptive speed → rapid adoption → accuracy improvements pattern works.
• Production-ready for large codebases and early adopters willing to accept Beta maturity. Recommended: Run dual tools (ty for speed, Pyright for accuracy verification). Stable 2026 targets >60% conformance with Pydantic/Django support.