Typed Python 2025: Adoption Holds, But Pain Points Persist

The 2025 Typed Python Survey — run by contributors from JetBrains, Meta, and the wider typing community — collected 1,241 responses, up 15% from the previous year. The respondent pool skewed experienced: nearly half had over a decade of Python experience, and another third had spent between five and ten years with the language. Most participants also reported several years of hands-on typing experience.

Adoption remains widespread. Eighty-six percent of respondents say they use type hints "always" or "often," a figure consistent with last year's survey. First-time questions about experience level, however, revealed some splits:

  • Developers with 5–10 years of Python experience are most enthusiastic, with 93% using type hints regularly.
  • The most junior cohort (0–2 years) trails slightly at 83%, possibly due to the learning curve newcomers face.
  • Senior developers (10+ years) show the lowest adoption at 80%, which could reflect habits formed before typing existed or the difficulty of migrating large legacy codebases.
Percent of respondents who use types “often” or “always,” segmented by years of Python experience.

Survey organizers note a likely selection bias: developers who already value typing are more likely to respond to a survey about it.

What Developers Value and Struggle With

When asked what they love about Python typing, respondents most frequently cited optionality and gradual adoption, improved readability and self-documenting code, better IDE features such as autocomplete and jump-to-definition, and earlier bug detection. The flexibility of protocols, generics, and runtime annotation inspection for libraries like Pydantic and FastAPI also drew praise. A minority answered "nothing" — a reminder that some strong negative sentiment remains.

The pain points were more numerous and more detailed. Over 800 responses to the question about the hardest part of using the type system clustered around several recurring themes:

  • Third-party library support — untyped, incomplete, or incorrect annotations in popular packages like NumPy, Pandas, and Django.
  • Advanced feature complexity — generics, TypeVar variance, decorators and callables, and deeply nested types are hard to express and reason about.
  • Tooling fragmentation — inconsistencies between checkers like Mypy and Pyright, slow performance, and the lack of an official built-in checker.
  • Optionality cuts both ways — typing is not enforced at runtime, making it harder to convince teams to adopt and trust it consistently.
  • Verbosity — complex annotations can make code less readable and less Pythonic.
  • Legacy and dynamic code — integrating hints into old codebases or code that relies on dynamic attributes is painful.
  • Rapid evolution — the type system is perceived as less expressive than TypeScript's, and syntax and best practices keep shifting.
Sample of responses to the question, “What do you love about Python Typing?”

Features on the Wishlist

A little under half of respondents offered suggestions for missing features. The most common requests included:

  • TypeScript-inspired capabilities such as intersection types (&), mapped and conditional types, utility types like Pick/Omit/keyof/typeof, and more flexible structural typing for dictionaries.
  • Optional runtime type enforcement and performance optimizations such as JIT or AOT compilation based on type hints.
  • Better generics, broader TypeVarTuple support, higher-kinded types, and official algebraic data types like Result or Option.
  • A fast official or built-in type checker, a less verbose syntax for nullable types and callables, and better documentation for complex real-world types.
  • Improved handling for functional wrappers, dynamic attributes added by ORMs, and sharper narrowing and control-flow analysis.

Mypy remains the dominant checker at 58% usage, a slight dip from 61% last year. The field is widening, though: the new Rust-based checkers Pyrefly, Ty, and Zuban collectively account for over 20% of respondents.

The top six most popular answers to the question, “What type checking tools do your projects use (select all that apply)?”

In the editor space, VS Code leads, followed by PyCharm and (Neo)vim. IDE-integrated checking mirrors that ranking: Pylance/Pyright is the most-used option, with PyCharm's built-in support third.

Learning and Getting Help

Official documentation remains the primary learning and troubleshooting resource for most developers — 865 respondents cited it as their main source for learning about typing, and 891 turn to it for help. Blogs moved up to second place for learning, and online tutorials, code reviews, and YouTube videos all still matter.

Top six responses to the question, “How do you learn Python typing (select all that apply)?”

Community channels are becoming more important for staying current. Reddit jumped from fifth to third place as a news source for type-system developments; newsletters, podcasts, and Mastodon are also on the rise. LLM-based tools have entered the picture too, with more than 400 respondents using chat tools and nearly 300 relying on in-editor AI suggestions when working with types.

Clear Paths Forward

The data points to three concrete opportunities. First, library coverage: broader and deeper annotations across popular packages would make static typing practical for far more codebases. Second, documentation and discovery: official docs are valued, but more reachable materials — via blogs, newsletters, and community platforms — would help surface new features and best practices. Third, tooling clarity: the proliferation of checkers reflects a healthy ecosystem, but it also signals a lack of consensus. More consistency between tools, or clearer guidance on their differences and best-fit use cases, would reduce confusion.