Pyrefly

Pyrefly is a static type checker for Python that operates as a language server, delivering real-time diagnostics, completions, and navigation in any editor supporting the Language Server Protocol. It also performs static tensor shape analysis, using symbolic dimension variables and arithmetic to verify shape consistency in deep learning models without runtime execution.

Beyond core type checking, Pyrefly supports gradual adoption workflows: it can generate a baseline of known errors so only new issues are reported, migrate configuration from other type checkers, and automatically suppress existing errors. Preset-based strictness tiers—safe, strict, and custom—control the level of checking. The checker natively understands Django ORM models, class-based views, and Pydantic models, inferring types without plugins. It integrates with CI pipelines through pre-commit hooks and inline error annotations on pull requests.

Pyrefly’s incremental architecture re-checks only modified files, providing sub-second feedback. Import resolution prefers stub files over source code and bundles type stubs for popular libraries. The language server offers autocomplete, hover information, inlay hints, signature help, code actions, and navigation features such as go-to-definition, find all references, call and type hierarchies, and workspace symbol search. Diagnostics appear in notebooks and with semantic token highlighting.

Configuration is handled through project files with options for import resolution, typeshed paths, and types of errors to report. The checker measures type coverage and can report per-module statistics.

Features

Python Type Checkers - Catches type mismatches and invalid operations in Python code before runtime with configurable strictness and fast incremental analysis.

Static Shape Validators - Validates tensor shape consistency at compile time using symbolic arithmetic and shape rules for operations.

Tensor Shape Inferences - Infers tensor shapes automatically from operations and reports mismatches without manual annotations.

Symbolic Tensor Shape Analyzers - Infers tensor shapes using symbolic dimension variables and arithmetic to verify shape consistency at compile time.

Static Shape Validators - Verifies tensor shape consistency in deep learning models at compile time using symbolic dimension variables.

Framework Support - Provides native static analysis type inference for Django, Pydantic, and similar frameworks without plugins.

Django ORM Model - Infers types for Django ORM model fields and relationships without plugins.

Argument Type Mismatch Detectors - Provides static detection of argument type mismatches before code execution.

Language Server Protocols - Connects a Python type checker to any LSP-compatible editor to deliver diagnostics, autocomplete, and navigation.

Language Servers - Delivers diagnostics, completions, and navigation via the Language Server Protocol for any compatible editor.

Stub-First Import Resolvers - Prefers .pyi stub files and -stubs packages over source code for static type information.

Generic Types - Supports generic types and type-safe polymorphism through parameterized type variables.

Type-Based Overloading - Supports defining multiple type signatures for functions to alter return types based on input types.

Structural Type Equivalences - Validates types based on their structure and attributes, supporting duck typing without explicit inheritance.

Static Type Inference - Infers variable types from code without requiring explicit annotations.

Optional Value Types - Represents values that may be one of several types or None for flexible type definitions.

Gradual Typing Adoption - Migrates existing Python projects to type safety by generating configuration from other checkers and suppressing current errors.

Static Type Checking - Reports type mismatches and invalid attribute accesses statically without executing code.

Pydantic Model Validations - Executes static analysis that mirrors Pydantic runtime validation rules to catch data model errors in the editor.

Dimension String Annotations - Accepts dimension string annotations for linking tensor dimensions to type-level symbols during static analysis.

Dimension Type Extractors - Extracts runtime dimension types from tensors while preserving symbolic links for subsequent shape verification.

Model Shape Annotation Porting - Automates porting of tensor shape annotations for compile-time shape safety.

Symbolic Dimension Arithmetics - Performs symbolic arithmetic on dimension types for expressing tensor shape transformations at compile time.

Tensor Shape Annotations - Links runtime tensor dimensions to type-level symbols for shape consistency verification.

LSP Server Configurations - Configures the LSP server to work in various editors via Language Server Protocol.

LSP-Integrated Environments - Connects to editors using the Language Server Protocol to deliver diagnostics and completions.

Configurable Strictness Levels - Provides safe, strict, and custom preset strictness tiers to control type error reporting.

Incremental Type Checkers - Performs incremental type checking with sub-second feedback for fast editing cycles.

Symbol Search Interfaces - Searches globally for functions, classes, and variables across the project.

Automated Type Checking Pipelines - Runs type checks automatically on every push or pull request and blocks commits that introduce type errors.

Call Hierarchies - Shows incoming and outgoing function calls in a structured hierarchy.

Cancellation-Aware Incremental Checkers - Implements incremental file re-checking and cancels stale analyses, providing instant feedback on edits.

Inline Diagnostic Displays - Shows type errors and warnings from the static checker in the diagnostics pane as you type.

Code Navigators - Provides code navigation and hints across editors via a standardized protocol.

Declaration Navigations - Provides go-to-declaration navigation as a built-in language server feature.

Type Definition Navigations - Jumps to the underlying type definition of an expression.

Type Hint Integrations - Delivers type information to the editor for inline error markers and enhanced autocompletion.

Inlay Hint Renderers - Displays inferred types and parameter names as virtual text directly in the editor.

Django Type Inference Engines - Infers types for Django model fields, relationships, and generic views without requiring plugins or manual annotations.

Automatic Suppression Additions - Scans projects and automatically suppresses pre-existing type errors for gradual adoption.

Temporary Suppression Mechanisms - Adds temporary ignore comments to suppress new errors after dependency upgrades.

Automatic Signature Help Displays - Shows live function signatures with parameter hints as the user types a function call.

Implementation Navigations - Ships go-to-implementations navigation for exploring method reimplementations.

Module Import Resolvers - Searches user paths, typeshed, and site-packages in fixed priority order for accurate module resolution.

Bundled Type Stubs - Ships pre-bundled type stubs for popular libraries to enable static checking without manual installation.

Type Stub Generators - Generates type stub files from Python source code for static type checking without runtime execution.

Strictness Preset Configurators - Offers safe, strict, and custom presets to control type checking severity and rules.

Symbol Navigation - Jumps from a symbol usage to its original definition, preferring source files.

Hover Information Displays - Displays type information and documentation inline when hovering over symbols in the editor.

Type Checker Configuration Migrations - Automatically migrates configuration from other type checkers for gradual adoption.

Continuous Integration Checks - Runs type checking automatically on every push or pull request inside continuous integration pipelines.

Symbolic Dimension Declarations - Declares tensor shapes with symbolic dimension variables and arithmetic for static shape consistency.

Import Path Resolution - Resolves absolute imports by searching user paths, typeshed, site-packages, and fallback locations.

Python Import Resolution Configurators - Configures import resolution by setting search paths, site-packages, typeshed, and autodetecting Python interpreter.

Relative Import Resolvers - Resolves relative import statements by ascending from the importing file's directory.

Static Analysis Rule Configurators - Adjusts strictness via presets, controls unannotated definitions, return type inference, callable subtyping, and specialized lints.

Codebase Symbol References - Lists every usage of a symbol across the entire codebase.

Diagnostic Filtering and Suppression - Filters diagnostics by severity, suppresses known errors with a baseline, and formats output for CI or display.

Issue Baselining - Creates a baseline of known errors to report only new regressions, enabling gradual adoption.

Type Hierarchies - Shows all subclasses and superclasses of a selected class in a hierarchy view.

Type Coverage Analysis - Measures type annotation coverage and can fail on low coverage or export statistics.

Rule Suppression Comments - Suppresses type errors via inline or file-level comments.

Code Autocomplete Engines - Provides context-aware autocomplete suggestions for symbols and imports as the user types in the editor.

Semantic Highlighters - Applies rich syntax highlighting based on token type and origin from semantic analysis.

Class-Based View Type Checking - Infers types for Django class-based views and mixins without plugins.

Code Analysis - Listed in the “Code Analysis” section of the Awesome Python awesome list.

Developer Tools - Fast typechecker and IDE support for Python.

Rust Projects - Listed in the “Rust Projects” section of the Awesome For Beginners awesome list.

Static Type Checkers - Fast type checking and language server implementation.

Type Checking - Fast type checker and language server.

facebookpyrefly

Features

Star history