The 2025 Typed Python Survey, a collaborative effort by contributors from JetBrains, Meta, and the wider Python typing community, provides an in-depth overview of Python’s current type system and associated developer tools. This year’s survey gathered 1,241 responses, marking a 15% increase from the previous year, and reflects the changing perspectives, difficulties, and potential advancements in Python typing within the open-source environment. This article summarizes the main findings and trends from the latest results.
Who Responded?
The survey was initially disseminated through official social media channels by its creators and then spread organically across platforms such as Reddit, email newsletters, Mastodon, LinkedIn, Discord, and Twitter. Reddit proved to be the most impactful channel for reaching respondents, though email newsletters and Mastodon also generated substantial participation, illustrating the varied online communities where Python developers engage.
The majority of survey participants were developers with considerable experience in both Python and its typing features. Almost half of the respondents reported over ten years of Python experience, with an additional third having between five and ten years. Although new developers were represented, most participants contributed their responses with significant expertise. Experience with type hints was also strong, as most respondents had utilized them for several years, and only a small percentage reported no prior experience.
Typing Adoption and Attitudes
Survey findings indicate that Python’s type hinting system is now a fundamental aspect of development for many engineers. A notable 86% of respondents stated they “always” or “often” incorporate type hints into their Python code, a percentage consistent with the previous year’s Typed Python survey.
This year, the survey introduced questions about participants’ years of experience with both Python and Python typing. It was observed that typing adoption is generally consistent across all experience levels, though some interesting distinctions emerged:
- Developers with 5–10 years of Python experience are the most enthusiastic adopters, with 93% reporting regularly using type hints.
- Among the most junior developers (0–2 years of experience), adoption is slightly lower at 83%. Possible reasons for this could be the learning curve for newcomers (repeatedly mentioned in later survey questions).
- For senior developers (10+ years of experience), adoption was the lowest of all cohorts, with only 80% reporting using them always or often. Reasons for this drop are unclear, it could reflect more experienced python developers having gotten used to writing Python without type hints before they were supported, or possibly they are more likely to work on larger or legacy codebases that are difficult to migrate.
Percent of respondents who use types “often” or “always,” segmented by years of Python experience.
In summary, the data indicates that type hints are broadly accepted within the Python community, receiving significant endorsement from engineers across all experience levels. It is worth noting, however, that a selection bias might be present, as developers more accustomed to and frequent users of type hints could be more inclined to participate in such a survey.
Why Developers Love Python Typing
When participants were asked about their appreciation for the Python type system, responses varied, with some simply stating “nothing” (an optional answer). This suggests that a minority of Python users hold strong negative views regarding the type system. Nevertheless, most responses were positive, highlighting several key themes:
- Optionality and Gradual Adoption: The optional nature of the type system and the ability to adopt it incrementally into existing projects are highly valued, allowing flexibility in development.
- Improved Readability and Documentation: Type hints serve as in-code documentation, making code clearer and easier to read, understand, and reason about for both the author and other developers, especially in larger codebases.
- Enhanced Tooling and IDE Support: The type system significantly improves IDE features like autocomplete/IntelliSense, jump-to-definition, and inline type hints, leading to a better developer experience.
- Bug Prevention and Code Correctness: It helps catch errors and subtle bugs earlier during development or refactoring, increasing confidence and leading to more robust and reliable code.
- Flexibility and Features: Respondents appreciate the flexibility, expressiveness, and powerful features of the system, including protocols, generics (especially the new syntax), and the ability to inspect annotations at runtime for use with libraries like Pydantic/FastAPI.
Sample of responses to the question, “What do you love about Python Typing?”
Challenges and Pain Points
Beyond gauging positive opinions on Python typing, participants were also questioned about the challenges and difficulties encountered. From over 800 responses to “What is the hardest part about using the Python type system?”, the following recurring themes were identified:
- Third-Party Library/Framework Support: Many respondents cited the difficulty of integrating types with untyped, incomplete, or incorrect type annotations in third-party libraries (e.g., NumPy, Pandas, Django).
- Complexity of Advanced Features: Advanced concepts such as generics, TypeVar (including co/contravariance), callables/decorators, and complex/nested types were frequently mentioned as difficult to understand or express.
- Tooling and Ecosystem Fragmentation: The ecosystem is seen as chaotic, with inconsistencies between different type checkers (like Mypy and Pyright), slow performance of tools like Mypy, and a desire for an official, built-in type checker.
- Lack of Enforcement and Runtime Guarantees: The fact that typing is optional and is not enforced at runtime or by the Python interpreter makes it harder to convince others to use it, enforce its consistent use, and fully trust the type hints.
- Verbosity and Code Readability: The necessary type hints, especially for complex structures, can be verbose, make the code less readable, and feel non-Pythonic.
- Dealing with Legacy/Dynamic Code: It is hard to integrate typing into old, untyped codebases, particularly when they use dynamic Python features that do not play well with static typing.
- Type System Limitations and Evolution: The type system is perceived as incomplete or less expressive than languages like TypeScript, and its rapid evolution means syntax and best practices are constantly changing.
Most Requested Features
Slightly under half of the respondents offered suggestions for perceived missing elements in the Python type system, with the most frequently requested features including:
- Missing Features From TypeScript and Other Languages: Many respondents requested features inspired by TypeScript, such as Intersection types (like the & operator), Mapped and Conditional types, Utility types (like Pick, Omit, keyof, and typeof), and better Structural typing for dictionaries/dicts (e.g., more flexible TypedDict or anonymous types).
- Runtime Type Enforcement and Performance: A significant number of developers desire optional runtime type enforcement or guarantees, as well as performance optimizations (JIT/AOT compilation) based on the type hints provided.
- Better Generics and Algebraic Data Types (ADTs): Requests include features like higher-kinded types (HKT), improved support for TypeVarTuple (e.g., bounds and unpacking), better generics implementation, and official support for algebraic data types (e.g., Result, Option, or Rust-like enums/sum types).
- Improved Tooling, Consistency, and Syntax: Developers asked for an official/built-in type checker that is fast and consistent, a less verbose syntax for common patterns like nullable types (? instead of | None) and callables, and better support/documentation for complex types (like nested dicts, NumPy/Pandas arrays).
- Handling of Complex/Dynamic Patterns: Specific missing capabilities include better support for typing function wrappers/decorators (e.g., using ParamSpec effectively), being able to type dynamic attributes (like those added by Django/ORMs), and improved type narrowing and control flow analysis.
Tooling Trends
The array of developer tools for Python typing is continuously developing, with both established and newer tools influencing engineering practices.
Mypy continues to be the most frequently used type checker, reported by 58% of respondents. Although this marks a small decrease from 61% in the previous year’s survey, Mypy maintains a leading role in the ecosystem. Concurrently, new Rust-based type checkers such as Pyrefly, Ty, and Zuban are rapidly gaining popularity, collectively utilized by over 20% of survey participants.
The top six most popular answers to the question, “What type checking tools do your projects use (select all that apply)?”
Regarding development environments, VS Code stands out as the most favored IDE among Python developers, followed by PyCharm and (Neo)vim/vim. The adoption of type checking tools within these IDEs mirrors their overall popularity, with VS Code’s default (Pylance/Pyright) and PyCharm’s integrated support ranking as the first and third most popular choices, respectively.
How Developers Learn and Get Help
Developers seeking to learn about Python typing or obtain assistance utilize a combination of official resources, community-generated content, and AI-driven tools, reflecting a learning environment similar to that observed in the previous year’s survey.
Top six responses to the question, “How do you learn Python typing (select all that apply)?”
Official documentation continues to be the primary resource for most developers. A majority of respondents indicated learning about Python typing via official documentation, with 865 identifying it as their main learning source and 891 using it for assistance. Python’s specific typing documentation and type checker-specific documents are also extensively consulted, demonstrating the ongoing value placed on well-kept, authoritative materials.
Blog posts have increased in popularity, now holding the second position as a common method for developers to learn about typing, an ascent from third place last year. Online tutorials, code reviews, and YouTube videos also contribute significantly.
Community platforms are becoming more influential as sources for updates and new features. Reddit, notably, has emerged as a crucial channel for uncovering new advancements in the type system, moving from fifth to third place as a news source. Email newsletters, podcasts, and Mastodon are also seeing increased usage.
Large language models (LLMs) now represent a significant component of the resources developers use for assistance. More than 400 respondents reported utilizing LLM chat tools, and almost 300 employ in-editor LLM suggestions when engaging with Python typing.
Opportunities and Next Steps
The 2025 Python Typing Survey underscores the Python community’s ongoing embrace of typing features and supporting tools. It also identifies distinct opportunities for further development and enhancement, such as:
- Increasing library coverage: One of the most consistent requests from the community is for broader and deeper type annotation coverage in popular libraries. Expanding type hints across widely used packages will make static typing more practical and valuable for everyone.
- Improving documentation: While official documentation remains the top resource, there’s a strong appetite for more discoverable and accessible learning materials. Leveraging channels like newsletters, blog posts, and Reddit can help surface new features, best practices, and real-world examples to a wider audience.
- Clarify tooling differences: The growing variety of type checkers and tools is a sign of a healthy ecosystem, but can also reflect a lack of consensus/standardisation and can be confusing for users. There’s an opportunity to drive more consistency between tools or provide clearer guidance on their differences and best-fit use cases.
