Ty | Awesome Repos

This project is a high-performance static type checker and comprehensive development toolkit for Python. It functions as a core analysis engine that identifies type inconsistencies and enforces code correctness, while simultaneously providing a language server implementation to deliver real-time diagnostics and intelligence directly within development environments.

The tool distinguishes itself through a parallelized execution engine that maximizes performance across large-scale codebases and monorepo structures. It supports gradual type adoption, allowing developers to integrate type checking into existing projects incrementally, and features sophisticated analysis capabilities such as branch reachability detection and intersection type support to maintain precision.

Beyond core type checking, the suite provides extensive automation for code quality assurance, including automated refactoring and fix suggestions for identified issues. It offers deep integration with build pipelines and version control systems, while its hierarchical configuration system allows for granular control over analysis rules, environment targeting, and diagnostic reporting across diverse project setups.

Features

Static Type Checkers - Functions as a high-performance static analysis engine that identifies type inconsistencies and provides real-time code intelligence.
Language Servers - Runs a background server that communicates with code editors to offer real-time diagnostics and code analysis features.
Python Development Tools - Provides a comprehensive suite for managing project environments, enforcing type safety, and automating code quality checks in Python.
Static Type Checkers - Provides high-performance static type checking for Python codebases to ensure correctness and identify type inconsistencies.
Python Type Checkers - Identifies type inconsistencies and violations in Python codebases to ensure correctness and improve overall software reliability.
Language Server Protocols - Communicates with development environments through a standardized messaging interface to provide real-time diagnostics and code intelligence.
Type Violation Detectors - Analyzes source code to detect and report type inconsistencies and violations.
Automated Code Refactoring - Applies automated fixes for missing imports, resolves diagnostic issues, and safely renames symbols across the entire codebase.
Code Intelligence - Offers intelligent suggestions for variables, functions, and modules while automatically inserting necessary import statements.
Language Server Implementations - Implements a background service that delivers IDE features like code completion, symbol navigation, and automated refactoring.
Language Intelligence Services - Delivers real-time code intelligence including completions, navigation, and inlay hints via language server protocols.
Compile-Time Type Inference - Implements automatic determination of variable types at compile time to identify inconsistencies without requiring explicit annotations.
Project Configuration Management - Manages analysis rules and environment settings through hierarchical configuration files that merge project-level and user-level preferences.
Code Analysis - Listed in the “Code Analysis” section of the Awesome Python awesome list.
Developer Tools - Fast Python type checker.
Static Type Checkers - Extremely fast static type checker built in Rust.
Type Checking - High-performance type checker and language server.
Dependency Graph Resolvers - Maintains a persistent dependency graph to re-evaluate only the code affected by recent changes, optimizing analysis performance.
IDE Integrations - Connects to development environments to provide real-time type checking and code analysis within the editor interface.
Module Resolution - Defines project roots and search paths to ensure accurate module and dependency resolution.
Incremental Analysis Engines - Performs incremental re-analysis of modified code to provide rapid feedback during development.
Adoption Frameworks - Supports incremental type checking integration into existing codebases with flexible rule strictness.
Code Quality and Review - Integrates static analysis into build pipelines and version control workflows to enforce coding standards and prevent errors.
Monorepo Managers - Coordinates multiple related projects within a single repository to simplify dependency management and shared code maintenance.
Parallel Execution Engines - Distributes analysis workloads across multiple CPU cores to maximize performance during large-scale codebase scans.
Incremental Adoption Tools - Facilitates the incremental addition of type annotations to existing codebases while maintaining flexible configuration.
Codebase Navigation Tools - Provides tools to jump between symbol definitions, declarations, and references across a workspace.
Rule Configuration Engines - Manages diagnostic severity levels globally or per-rule to control reporting behavior.
CI/CD Integrations - Integrates into version control workflows via hooks to trigger automated checks before code is committed.
Environment Discovery Tools - Automatically detects project environments and interpreters to ensure accurate dependency resolution.
Code Intelligence Providers - Surfaces type signatures, documentation, and inlay hints while providing semantic highlighting to clarify code structure during development.
Build Pipeline Integrations - Integrates static analysis checks directly into build pipelines to ensure code quality and type safety during automated builds.
File-Based Configuration - Applies custom rule configurations to specific file subsets for granular enforcement.
Reachability Analyzers - Identifies and ignores logically impossible code paths to prevent false positive errors during analysis.
Version Requirement Validators - Validates project code against target language versions to ensure syntax compatibility and standard library availability.
Hierarchical Configuration Systems - Supports merging configuration settings across directory structures to define project-specific analysis rules and environment constraints.
Intersection Type Engines - Combines multiple type constraints into single requirements to ensure objects satisfy all specified properties simultaneously.

facebook/pyrefly

5,390View on GitHub

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 exi

oxc-project/oxc

21,675View on GitHub

Oxc is a high-performance toolchain designed for the analysis, linting, formatting, and transformation of JavaScript and TypeScript codebases. It functions as a comprehensive static analysis engine and compiler-based utility, providing the infrastructure necessary to parse source code into high-performance abstract syntax trees and map complex module dependency graphs across entire projects. The project distinguishes itself through its use of multi-core parallel processing to maximize throughput during intensive tasks like linting and minification. It offers deep, type-aware static analysis t

rust-lang/rust-analyzer

16,590View on GitHub

Rust-analyzer is a language server implementation that provides real-time code intelligence, static analysis, and development productivity tools for the Rust programming language. It functions as a backend engine that communicates with text editors to deliver deep structural understanding of source code, enabling features like semantic analysis, symbol navigation, and automated refactoring. The project distinguishes itself through a core engine designed for high-performance responsiveness, utilizing incremental query-based compilation and lazy demand-driven evaluation to minimize resource con

microsoft/pyright

15,241View on GitHub

Pyright is a static type checker for Python designed to validate type hints and identify potential errors within large codebases. It functions as a command-line utility that integrates into local development environments and continuous integration pipelines to ensure code quality and consistency. The tool distinguishes itself through a high-performance analysis engine that utilizes incremental dependency graph analysis and persistent state caching to re-evaluate only the affected portions of a project. By implementing the Language Server Protocol, it provides real-time feedback, including err

astral-shty

Ty

Features