AI Creator's Path News Tired of slow Python type checking? Rust-based "ty" is over 60 times faster than mypy! Dramatically change your development workflow. #Python #TypeChecking #Rust
A quick video explanation of this blog post!
This blog post is explained in an easy-to-understand video.
Even if you don't have time to read the text, you can quickly grasp the main points by watching the video. Please take a look!
If you found this video helpful, please follow our YouTube channel "The Path of an AI Creator" for daily AI news.
Subscribe here:
https://www.youtube.com/@AIDoshi
Jon and Lila share their unique perspectives in this conversation in English 👉 [Read the dialogue in English]
👋 Python developers, have you ever been frustrated by slow type checking? Astral's new beta release, "ty," uses the power of Rust to outperform traditional tools and dramatically streamline your codebase.
In your daily coding, do you get stressed out by the slow type checking of mypy and Pyright? Especially in large-scale projects, it's normal to wait for several minutes. Meanwhile, Astral has released a beta version of "ty", a high-speed type checker written in Rust. As an engineer, this is an evolution that cannot be ignored. In benchmarks,Over 60 times fasterIt's likely to change your workflow.
🔰 Article level:⚙️ Technical
🎯 Recommended for:Intermediate to advanced developers looking to improve Python's type safety, engineers looking to optimize CI/CD pipelines, and team leaders working with large codebases.
Python type checker "ty" beta release: Speeding things up with the power of Rust
Key points ①: Ultra-fast type checking based on Rust. Benchmark results show speeds several tens of times faster than mypy.
Key point ②: LSP support for easy IDE integration. Live updates are "extremely fast."
Key point ③: A stable release is scheduled for 2026. You can try the beta version now.
📖 Table of Contents
Background and Issues
Python is a popular dynamically typed language, but type errors can cause serious bugs in large-scale development. Traditional type checkers solve this problem, but execution speed is a bottleneck.
For example, mypy is accurate, but can take tens of minutes for large projects. Pyright is fast, but resource-intensive and inefficient for CI/CD. As an engineer, I'm faced with the dilemma that these tools improve code quality but slow down the development cycle.
To address these challenges, Astral (the developers of Ruff and uv) has launched "ty," which aims to speed up type checking by leveraging Rust's concurrency and memory safety. The beta release is the first step in closing this technology gap.
Technical and content explanation
"ty" is a static type checker for Python implemented in Rust. Its main features are:Checks within 2 seconds without cachingIt supports LSP (Language Server Protocol) and provides real-time feedback in IDEs such as VS Code.
Technically, ty's core is Rust's concurrency model. It efficiently parses Python ASTs and performs fast type inference. What sets it apart from previous tools is its fast incremental updates, achieving 4.7 millisecond updates on large codebases like PyTorch.
As a limitation, since it is a beta version, some advanced type features (e.g. generics in general) are not supported. While aiming for mypy compatibility, it uses its own error message format.
| Item | Conventional tools (mypy / Pyright) | ty (beta) |
|---|---|---|
| Execution speed | A few minutes to a few tens of minutes on a large scale (e.g., a few minutes for home assistant) | Within 2 seconds (2.19 seconds with home-assistant) |
| 言语 | Python (mypy) / TypeScript (Pyright) | Rust (concurrency optimization) |
| LSP Support | Yes (but with delay) | Yes (very fast live updates) |
| compatibility | PEP 484 compliant | Aiming for mypy compatibility, but some parts are not implemented in beta |
| Ease of implementation | Medium (many settings) | Low (Easy installation via UV) |
As you can see from this table, ty has an overwhelming advantage in terms of speed. Rust's memory management reduces errors and improves stability compared to the Python-based mypy. However, it also has the advantage of avoiding Pyright's dependency on an internet connection (by design).
Digging deeper, ty's type inference engine utilizes Rust's borrow checker to analyze the AST in parallel threads. Instead of traditional sequential processing, it creates a dependency graph and executes it in parallel. This achieves a processing speed of 1.8M lines per second. From an engineer's perspective, this architecture is a good example of bringing the strengths of Rust to the Python ecosystem.
However, the flexibility of custom rules may be less than that of mypy. The beta version uses a unique error message format, which requires some getting used to. Comparative benchmarks are based on publicly available data from Astral, with a time of 2.19 seconds for home-assistant, making mypy several dozen times slower.
Impact and use cases
For engineers, the impact of ty is in improving development efficiency. In large open source projects (e.g., PyTorch), incremental checks are performed in milliseconds, providing immediate feedback when code is changed. This results in faster bug detection and potentially a 20-30% increase in productivity.
It is expected to be adopted by Meta and large companies. By incorporating it into a CI/CD pipeline, build times can be reduced. For example, by combining it with the uv toolchain, you can create a consistent, high-speed workflow from project initialization to type checking.
In terms of social impact, it has accelerated the adoption of typing in the Python community. Rust crossover has enriched the inter-language ecosystem. In the technical community, improvements to error messages have been discussed, as in the Lobster discussion.
Example: In the Home Assistant project, the introduction of ty reduced the check time to 2 seconds. This allows developers to fix type errors in real time, improving code quality. From a business perspective, such tools help drive enterprise Python adoption.
Action Guide
As a techie, first install the beta version. Use the uv tool to run "uv tool install ty" and then run "ty check" on your project. To migrate from your existing mypy configuration, see Astral's guide.
Next, install the VS Code extension and experience live checks with LSP. Run benchmarks on your own project to see the speed difference. Post your feedback on the GitHub repository.
The team leader incorporated ty into the CI pipeline to monitor build times, checked limitations, and considered using mypy in conjunction with unsupported features.
Future prospects and risks
The future looks bright, with mypy compatibility expected to be complete in the stable release in 2026. Given the momentum of Astral, it may become a standard tool like Ruff. The Python Typing Survey 2025 also called for speed improvements, and ty could be the answer.
As it's in beta, there are risks of bugs and unimplemented features. For example, complex type hints may not be parsed correctly. The dependency on Rust also means limitations on the build environment. Because it's open source, it's dependent on the community's contributions, but keep an eye on the rise of competing tools like Pyrefly.
To be fair, there is a learning curve and migration costs from existing tools, but in the long term, it has great potential to evolve Python's type system.
My Feelings, Then and Now
The beta release of ty heralds a new era in Python type checking, leveraging Rust's speed and eliminating developer pain points. As an engineer, you can leverage this tool to dramatically improve the reliability and efficiency of your code. Try it out and give us your feedback.
Have you tried ty? Share in the comments any speed differences you noticed or areas you'd like to see improved!
👨💻 Author: SnowJon (WEB3/AI Practitioner/Investor)
Based on the knowledge I gained from the University of Tokyo's Blockchain Innovation Course,
Researches and disseminates information on WEB3 and AI technology from a practical perspective.
We place importance on translating difficult technologies into a form that can be understood.
*AI is used as an auxiliary tool, and the author is responsible for verifying the content and taking final responsibility.
Reference links and information sources
- Python type checker ty now in beta | InfoWorld
- ty: An extremely fast Python type checker and LSP
- Announcing the Beta Release of ty: Python Type Checking, Rewritten for Speed | Medium
- ty: Astral's New Python Type Checker Released – Python Developer Tooling Handbook
- Python Typing Survey 2025: Code Quality and Flexibility As Top Reasons for Typing Adoption – Engineering at Meta