The New Era of Python Type Checking: Pyrefly vs. ty – A Technical Deep Dive

Introduction: A Silent Revolution in the Python Ecosystem

For nearly a decade, Python developers have relied on Mypy and Pyright for type checking. At PyCon 2025, two Rust-based newcomers—Meta’s Pyrefly and Astral’s ty—quietly redefined industry standards. Though still in alpha, their architectural innovations and performance benchmarks signal a paradigm shift. This article provides a comprehensive comparison based on live PyCon Typing Summit demonstrations and empirical testing.

Chapter 1: Performance Showdown – The Power of Rust

1.1 Benchmark Methodology

• Hardware: MacBook M4 (8-core CPU/24GB RAM)
• Test Projects: PyTorch 2.7.0, Django 5.2.1, Mypy source code
• Control Tools: Mypy 1.14.0, Pyright 1.1.401

1.2 Key Benchmark Results

Technical Insights:
ty achieves 18,000 lines/second in PyTorch due to:

1. Salsa Incremental Engine: Recomputes only affected function dependencies
2. Zero-Cost Abstractions: Memory-safe parsing via Rust
3. Parallel Processing: Optimized for Apple M4’s heterogeneous architecture

Chapter 2: Design Philosophies – Two Approaches to Type Safety

2.1 Pyrefly: Aggressive Type Inference

Core Principle: Maximize type deduction in unannotated code

# Example: Container Type Inference
my_dict = {k: v*2 for k,v in {"a":1, "b":2}.items()}
reveal_type(my_dict)  # Pyrefly infers dict[str, int]

• Strength: Catches hidden errors in legacy code
• Trade-off: May overflag valid operations as errors

2.2 ty: The Gradual Guarantee

Golden Rule: Valid code shouldn’t break when types are removed

class Data:
    value = None

obj = Data()
obj.value = 100  # ty allows (infers Unknown | None)

• Strength: Reduces migration friction
• Limitation: Requires explicit annotations for full safety

Feature Comparison:

Chapter 3: Incremental Checking – Engineering Behind Speed

3.1 Pyrefly’s Module-Level Approach

• Mechanism:
  Modify a function → Recheck entire module → Update dependencies
• Use Case:
  Large codebases with clear module boundaries (e.g., Meta’s internal projects)

3.2 ty’s Function-Level Precision

• Tech Stack:
  Salsa framework (used in Rust Analyzer)
• Workflow:
  Modify Function A → Recheck A and its callers → Skip unrelated code
• Efficiency Gain:
  92% faster rechecks for Django route modifications

Architecture Diagram:

Pyrefly:  
[File Change] → [Module Parse] → [Dependency Update] → [Full Check]  

ty:  
[Function Change] → [Salsa Graph] → [Minimal Scope Check]  

Chapter 4: Feature Testing – From Basics to Innovations

4.1 Advanced Generic Support

class Response[T]:
    data: T

def parse[T](resp: Response[T]) -> T:
    return resp.data  # Pyrefly infers T; ty needs explicit annotation

4.2 Intersection & Negation Types

class Admin: ...
class Guest: ...

def handle(user: Admin | Guest):
    if hasattr(user, 'privilege'):
        reveal_type(user)  # ty infers Admin via intersection types

Breakthrough: ty introduces & (intersection) and ~ (negation) operators.

4.3 Error Messaging Revolution

Traditional:
Argument 1 has incompatible type "str"; expected "int"

ty’s Approach:
Cannot pass string "abc" to parameter 'count' (defined as int at data_loader.py:47)
Improvement: Contextualizes errors and suggests fixes.

Chapter 5: Getting Started – Installation & Early Access

5.1 Pyrefly Quick Setup

# Installation
uv pip install pyrefly==0.17.0

# Basic Usage
pyrefly check /path/to/project

Live Sandbox: pyrefly.org/sandbox

5.2 ty First Steps

# Installation
uvx install ty@0.0.1-alpha.7

# VSCode Integration
ext install astral.ty-lsp

Playground: play.ty.dev

Chapter 6: Roadmap – The Future of Python Typing

6.1 Pyrefly’s Trajectory

• 2025 Q3: Full Python 3.12 support
• 2026 Q1: Pyre compatibility mode

6.2 ty’s Vision

• Type System: Add dependent types
• Ecosystem: Deep integration with Ruff

Industry Impact Predictions:

• Enterprises (>1M LOC): Favor Pyrefly
• Startups/OSS: Prefer ty
• Legacy Tools: Focus on annotation assistance

Conclusion: The Philosophy Behind Tool Evolution

The Pyrefly vs. ty rivalry embodies the balance between engineering rigor and developer flexibility. When ty demonstrated type-driven Diophantine equation solving, it wasn’t just about tools—it signaled Python’s metamorphosis from a “glue language” to a systems-language contender. As static checking accelerates by 300x, every developer must ask: Are we witnessing Python’s second act?

Appendix: Raw Test Data

• PyTorch Benchmarks
• Django Analysis Logs