Skip to content
Blog

pub.dev Reaches 700,000 Monthly Active Users: What It Means for Flutter Devs

pub.dev passed 700,000 monthly active users and grew its package count 26% in a single year. Here's what that scale means for how you pick, trust, and maintain Flutter dependencies.

Published on • October 29, 2026

AI Assistant

When the Flutter team announced that pub.dev had surpassed 700,000 monthly active users (as of January 2024), it was easy to read the number as a vanity metric. It isn’t. Monthly active users on a package registry means 700,000 developers per month are searching, reading pubscore pages, resolving dependencies, and — crucially — deciding which third-party code to trust inside production apps. In the same update, the team reported the ecosystem grew 26% in 2023, from roughly 38,000 packages in January to 48,000 by December.

That scale cuts both ways. More packages means more solutions to your problem — and more noise, more abandoned code, and more subtle supply-chain risk. In this post, we’ll look at what the growth actually changed, how the community’s quality norms (Flutter Favorites, review, summits) evolved alongside it, and how to make dependency decisions that hold up in a registry with tens of thousands of options.

The growth, in numbers

According to the Flutter team’s ecosystem update, the key figures were:

  • 700,000+ monthly active users on pub.dev as of January 2024
  • 26% package growth in 2023: ~38,000 packages in January → ~48,000 in December
  • 50+ contributors (Googler and non-Googler) attended the first Package Ecosystem Virtual Summit in August 2023
  • Seven new Flutter Favorites announced in that cycle, including riverpod, flame, flutter_animate, video_player, macos_ui, fpdart, and flutter_rust_bridge

The user number matters more than the package count. A registry with 48,000 packages but a small audience would struggle to sustain maintainers. A registry with 700,000 monthly users is where maintainers find users, where companies feel justified investing in open-source plugins, and where a well-titled package can become the default solution within months. This is the flywheel: users attract maintainers, maintainers attract more users.

Quality norms matured with the numbers

Growth of that speed usually degrades discovery. The Flutter team’s response was to double down on curated quality signals rather than try to police every package.

Flutter Favorites as the trust anchor

The Flutter Favorites program recognizes packages that demonstrate “exceptional quality, popularity, and community engagement.” It’s the closest thing pub.dev has to an editorial endorsement. Notice the mix in the announced batch: riverpod (state management), flame (2D game engine), flutter_rust_bridge (Rust FFI interop), fpdart (functional programming). Favorites aren’t a popularity contest for one category — they span the ecosystem, which makes them useful precisely when you’re evaluating an unfamiliar domain.

The team also made a deliberate trade-off: they sunset the Happy Paths recommendation program to concentrate effort on Favorites, explicitly pointing to community projects like Flutter Gems as complementary discovery tools. Curating well beats curating broadly.

The community started self-governing

The Package Ecosystem Virtual Summit brought together 50+ pub.dev contributors in an unconference format, with three attendee-voted topics that are telling about where a mature ecosystem’s pain points sit:

  1. Building high-quality packages — best practices and challenges
  2. Maintaining packages long-term — sustainable models
  3. Flutter and Dart DevTools extensions

Item two is the one every experienced Flutter team learns the hard way: the package you depend on today needs a maintainer in three years. Summit-level attention to sustainable maintenance models is a signal that the ecosystem’s adults are worried about the same thing your architecture review is.

Discovery also got attention. In 2023, pub.dev added 1–5 free-text topics in the pubspec.yaml, and the team proposed canonicalizing near-duplicates (widget vs widgets) to keep tag-based search useful at scale.

What growth means for your dependency choices

Here’s the practical translation. In a 48,000-package registry with 700,000 monthly users, “it has a lot of downloads” is a weaker signal than it used to be, and “it’s the first result for my search” is not a quality signal at all. A dependency workflow that scales with the ecosystem looks like this:

# pubspec.yaml — pin what you trust, constrain what you don't
dependencies:
  flutter:
    sdk: flutter
  riverpod: ^2.5.1        # Favorites-tier, actively maintained

dev_dependencies:
  flutter_test:
    sdk: flutter
  # Evaluate newcomers behind a version constraint and a test suite,
  # not straight to latest.
  some_new_parser: ^0.3.0

A checklist that reflects the ecosystem’s own quality norms:

  1. Start with Favorites or first-party. If the Flutter or Dart team maintains it, or it’s a Favorite, that’s your low-risk tier.
  2. Read the pub.dev page, not just the README. Likes, popularity, and the publisher (verified publishers exist for a reason) tell you about stewardship, not just features.
  3. Check maintenance signals before features. Last publish date, open issue responsiveness, changelog discipline, and supported platforms. The summit’s “maintaining packages long term” track exists because abandoned packages are the ecosystem’s chronic failure mode.
  4. Prefer packages with narrow, deep scope. fpdart does functional programming well. A “utilities” package that does forty things is a future migration.
  5. Budget for exits. Abstract the boundary (interface + implementation) for anything business-critical, so a stalled package costs you a week, not a quarter.

Putting it all together

700,000 monthly users and 26% annual growth make pub.dev one of the healthiest package registries in modern development — but scale changes the game from “can I find a package?” to “can I find the right package, and will it still be maintained when my app is on v4?” The ecosystem’s answer is layered: curated Favorites for trust, community summits for sustainability norms, and metadata work (topics, publishers) for discovery. Your answer should be a deliberate dependency workflow that treats every third-party package as a bet on someone else’s roadmap — sized, researched, and hedged accordingly.

Conclusion & Next Steps

The registry’s growth is a dividend for teams that pick well and a tax for teams that pick carelessly. Use Favorites as your default shortlist, verify maintenance before committing, and keep critical boundaries abstracted.

Next Steps: audit your current pubspec.yaml for packages with no release in 12+ months, shortlist Favorites replacements, and add a “dependency review” step to your next sprint planning.

Sources