How shedding package:provider eliminates dependency hell, fixes Flutter's lingering ghost rebuild bug, and delivers fine-grained synchronous reactivity in 2026.
If you browse r/FlutterDev on any given week, you will find the exact same architectural debate playing out:
"Should I use BLoC or Riverpod for my next production app? BLoC has great structure and discipline, but the stream boilerplate is overwhelming. Riverpod is reactive and flexible, but the @riverpod code generation and constant version transitions make it feel heavyweight."
And inevitably, someone in the comments will chime in: "I just stick with plain package:provider because it's simple and doesn't require code-gen."
This trilemma—BLoC vs. Riverpod vs. Provider—has defined Flutter state management for over six years. But behind this debate lies a little-known architectural secret that explains why Flutter state management felt so fractured in the first place:
Let's look at why classic BLoC relied on package:provider, the hidden runtime bugs and dependency deadlocks that came with it, why Riverpod had to break away, and how BlocSignal delivers the ultimate resolution: zero provider, zero streams, and zero code generation. Look Under the Hood: Classic BLoC's Hidden Dependency
When developers think of Felix Angelov’s classic flutterbloc, they think of Streams, Sinks, and unidirectional event architectures. But if you open flutterbloc/pubspec.yaml, you'll find a foundational dependency:
In classic flutterbloc: BlocProvider is literally an extension of package:provider's InheritedProvider. MultiBlocProvider is just a thin alias over MultiProvider. RepositoryProvider is literally Provider.
Why Did Classic BLoC Do This? Back in 2018–2019, writing custom InheritedWidget plumbing in Flutter was verbose and error-prone. Rémi Rousselet’s package:provider was the newly crowned Google-recommended solution for dependency injection and widget tree scoping.
Building flutterbloc on top of package:provider allowed BLoC to focus on its stream state machine while outsourcing widget tree scoping, lazy instantiation, and disposal to Provider.
It seemed like a great shortcut. But over time, coupling BLoC to package:provider introduced two massive architectural headaches. The Two Fatal Flaws of the Provider Foundation
Because package:provider is one of the most widely used packages in the Flutter ecosystem, major version updates (such as migrating from v4 to v5 to v6 for null safety) created widespread dependency deadlocks:
Every Flutter developer has experienced this nightmare: You couldn't upgrade flutterbloc because an analytics or payment SDK pinned an older provider. Teams were forced to use risky dependencyoverrides: in pubspec.yaml and pray that internal breaking changes wouldn't crash production builds. Engineers had to fork third-party repositories just to bump a provider constraint.
This is the deepest, most subtle flaw in Flutter's InheritedWidget system—and it was the primary catalyst that drove Rémi Rousselet to abandon Provider and create Riverpod.
When an Element calls context.watch() or Provider.of(context), Flutter registers that Element as a dependent of the ancestor InheritedWidget.
The fatal catch: Flutter’s engine never unregisters an element from an InheritedWidget on subsequent builds! Dependencies are only cleared when the widget is completely unmounted.
Once isExpanded is true even once, Flutter permanently binds DetailsModel to that widget. When the card collapses, it continues to rebuild on every DetailsModel emission indefinitely, wasting CPU cycles, battery, and rendering frames on state it isn't even displaying! The Riverpod Exodus: Escaping the Widget Tree
Rémi recognized that Flutter's InheritedWidget and BuildContext had fundamental limitations that could not be fixed within package:provider: You couldn't easily read state outside the widget tree (for example, in background services or pure Dart logic). The lingering dependency bug caused unavoidable ghost rebuilds on conditional branches. Combining two providers required ugly nested widget hierarchies or manual proxies.