Lazy is the new fast: How Lazy Imports and Cinder accelerate machine learning at Meta

The Startup Bottleneck in ML Training

Machine learning development is a waiting game. The interval between launching a training job and feeding it the first batch of data — time to first batch (TTFB) — can stretch into minutes of idle compute and stalled developer momentum. Meta has been chipping away at that overhead with two Python technologies: Lazy Imports and the Cinder runtime. Their results show TTFB improvements up to 40 percent for key AI workloads, along with a 20 percent reduction in Jupyter kernel startup times.

Why Import Statements Slow Everything Down

Batch processing underpins modern ML training, but the workloads themselves are slow to get moving. TTFB captures the full delay between kicking off a training run and the moment data starts flowing through the model. Infrastructure overhead and scheduling delays contribute to that gap, but a sizable chunk lies in Python's own startup behavior: eagerly loading every module and dependency at interpreter launch. That cost hits developers hardest during rapid experimentation, where long waits translate directly into wasted engineering time and compute resources.

Lazy Imports Goes Beyond Selective Deferral

Existing Python tooling already offered partial relief. The standard importlib LazyLoader and third-party projects like lazy-import defer explicit imports until execution reaches them. Their flaw is scope: developers must hand-pick each dependency to be lazily loaded, which demands careful codebase curation, constant refactoring, and often yields inconsistent results.

Meta's Cinder runtime takes a broader approach. Rather than making selective imports lazy, it defers all imports by default, pushing module loading to the exact moment a name is first used. This removes the guesswork from the process entirely. Developers no longer need to rely on typing-only imports or wrap conditional logic around type checking. A simple from __future__ import annotations declaration at the top of a file delays type evaluation, while Lazy Imports postpones the actual import statements until required. Together they cut costly runtime imports and simplify code maintenance.

Rolled out across ML frameworks and Jupyter kernels, the combination produced measurable wins. Meta reports savings of seconds to minutes per training run, with the most impactful workloads seeing up to 40 percent TTFB reduction. Developers reach the training phase faster, which feeds directly into more iterations per day and a better overall development experience.

Real-World Friction: Compatibility and Semantics

The gains did not come without compromise. Three implementation challenges stand out from Meta's experience.

Library Compatibility

Core data science libraries — PyTorch, Numba, NumPy, and SciPy — do not naturally align with deferred module loading. These libraries depend on import side effects: module-level code that registers classes, functions, and operations as a side effect of being loaded. When import order shifts or gets postponed, those registrations silently fail. Diagnosing the resulting import cycles and discrepancies required painstaking, case-by-case troubleshooting.

Performance vs. Predictability

Lazy Imports imposes a significant semantic change on how Python imports behave, and that shift can make codebases less intuitive. Meta had to balance aggressive performance gains against code dependability. The resolution was to limit the blast radius: Lazy Imports is enabled only during the startup and preparation phases of a workload, then disabled before the first batch begins. This confines semantic changes to well-tested portions of the pipeline while preserving the TTFB benefit.

Team Education

Moving to a new import model introduces a learning curve for ML engineers, infrastructure engineers, and systems engineers alike. Understanding the nuances of deferred loading — and knowing when it is safe — takes deliberate training beyond a simple toggle.

Next Steps: Tooling and Community

Meta's work with Lazy Imports is still evolving. Debugging code with deferred imports remains intricate, so the company is investing in tooling to simplify troubleshooting after the fact. Developer onboarding is another focus, with educational materials designed to ease newcomers into the paradigm shift. The company also plans to share its findings with the broader Python community — particularly around supporting patterns and antipatterns for lazy loading — to help other organizations adopt the approach without repeating the same troubleshooting cycles.

The adoption of Lazy Imports and Cinder delivered real gains Meta's ML workloads, not through faster compute but through cutting the dead time between an engineer's intent and a model's first learning step.