TechPrufer
Get started
Meta
Meta logoMeta · Feature trail

Python Typing System Evolution

2 posts · Nov 2014 – Dec 2025

What this trail covers

Meta's Python typing system continues to evolve, with the 2025 survey indicating strong adoption driven by code quality and flexibility. Key challenges include third-party library support, complexity of advanced features like generics, and tooling fragmentation. The community is requesting features inspired by TypeScript, runtime enforcement, better generics, and improved tooling. Emerging Rust-based type checkers are gaining traction alongside established tools like Mypy. Developers rely on off-the-shelf solutions for static analysis, and the adoption of static typing is driven by its ability to catch errors early and improve code maintainability. This post details the initial release of Flow, a static type checker for JavaScript, which aims to improve developer productivity and code quality by providing early error checking and enhanced code intelligence. Flow's design emphasizes minimal compile-time overhead and works with existing JavaScript idioms through sophisticated program analysis and type inference. It scales by checking modules independently and incrementally, maintaining a persistent server for instant feedback. Flow supports ES6 features, JSX, and React applications, and is implemented in OCaml. It differs from TypeScript by inferring types automatically where possible, rather than requiring explicit annotations.

All Meta trails
  1. Python Typing Survey 2025: Code Quality and Flexibility As Top Reasons for Typing AdoptionThis post details the findings of the 2025 Typed Python Survey, highlighting the widespread adoption of Python type hints (86% of respondents use them often or always). It identifies key reasons for adoption (optionality, readability, tooling, bug prevention, flexibility) and significant challenges (third-party library support, complexity of advanced features like generics and callables, tooling fragmentation, lack of runtime enforcement, verbosity, legacy code integration, and type system limitations). The survey also outlines most requested features, including TypeScript-like features (intersection, mapped, conditional types), runtime enforcement, better generics (HKTs, TypeVarTuple), and improved tooling. Tooling trends show Mypy's continued dominance but also the rise of Rust-based checkers like Pyrefly. Learning resources include official documentation, blog posts, community platforms (Reddit), and LLMs.
  2. Open-sourcing Pyrefly: A faster Python type checker written in RustThis post announces the open-sourcing of Pyrefly, a new Python type checker and IDE experience written in Rust. Pyrefly is designed to catch errors before runtime in Python codebases of any size and supports both CLI usage and IDE integration. It was developed to address the evolving needs of Instagram's typed Python codebase and scales to monorepos.
  3. Introducing Pyrefly: A new type checker and IDE experience for PythonIntroduces Pyrefly, a new open-source Python type checker and IDE extension written in Rust. Pyrefly aims to improve upon Pyre by offering enhanced performance (1.8 million lines of code per second), a first-class IDE experience, and advanced type inference. It is designed for scalability on large codebases and aims to shift type checking earlier in the development cycle. The project is open-sourced on GitHub under the MIT license.
  4. Enhancing the Python ecosystem with type checking and free threadingThis post details Meta's contributions to improving type annotation coverage in pandas-stubs (from 36% to over 50%) and numpy, including tooling development for cataloging missing annotations and measuring coverage for independently distributed stubs. It also describes the preparation of the Python ecosystem for free-threaded Python (FTP) by adding support to popular scientific computing packages (numpy, scipy, scikit-learn) and language bindings (Cython, nanobind, pybind, PyO3).
  5. How Meta is translating its Java codebase to KotlinThis post details Meta's ongoing large-scale migration of its Android codebase from Java to Kotlin. It highlights the use of custom tools and utilities for manipulating Kotlin code, the challenges encountered in translating tens of millions of lines of Java code, and strategies for avoiding nullability issues and generating idiomatic Kotlin code for internal frameworks. The post also references previous efforts in translating Java to Kotlin and the open-sourcing of Kotlin AST tools.
  7. Meta loves PythonThis post details Meta engineers' contributions to Python 3.12, including the development of custom JITs (Cinder), Immortal Objects, and enhancements to the type system and comprehensions. It also highlights Meta's engagement with the Python community and the development of these features.
  8. Meta contributes new features to Python 3.12Meta contributed several features to Python 3.12: Immortal Objects (PEP 683) to reduce memory use and enable better parallelism; the @typing.override decorator (PEP 698) to improve refactoring safety in type-checked code; faster comprehensions (PEP 709) by inlining them; an opt-in eager asyncio task factory for reduced overhead; faster C implementation of asyncio.current_task and optimization to async task creation; faster super() calls with the new LOAD_SUPER_ATTR opcode; optimizations to hasattr; and a 3.8x performance improvement to unittest.mock.Mock. Meta also added new benchmarks to the Python Performance Benchmark suite to better represent Meta's workload characteristics, and landed several Cinder hooks in Python 3.12 to support its JIT compiler and Static Python extension module.
  9. From zero to 10 million lines of KotlinThis post details the migration of Meta's Android development from Java to Kotlin, involving over 10 million lines of code. It discusses the advantages of Kotlin (nullability, functional programming, conciseness) and the challenges (interoperability, tooling, build times). The migration process involved unblocking internal tools and accelerating conversion through a three-step pipeline: Java preparation, J2K conversion, and postprocessing with automated refactors and fixes. Open-sourced tools like Ktfmt and Kotlin AST manipulation utilities were developed to support this large-scale migration.
  10. Flow, a new static type checker for JavaScriptThis post introduces Flow, a new open-source static type checker for JavaScript. It details Flow's design principles, including its focus on developer productivity and code quality through early error checking and code intelligence. The post explains Flow's technical approach, such as using data-flow and control-flow analysis for type inference, its modular and incremental type-checking architecture for scalability, and its opt-in nature. It highlights Flow's differences from TypeScript, particularly its emphasis on type inference over explicit annotation. The post also covers Flow's type system features, including support for primitive types, unions, and maybe types, as well as its handling of null values and control flow. Compatibility with ES6 features, JSX, and React applications is also discussed. The implementation is primarily in OCaml, and the project is open-sourced.