Flutter Community

🚀 Major Architecture Shift in Flutter: Standalone Material & Cupertino UI Packages! Flutter is unbundling Material Design and Cupertino libraries from the monolithic core framework into standalone packages on pub.dev (package:material_ui and package:cupertino_ui). While this brings faster release cadences, smaller app bundles, and pure headless core development (building directly on package:flutter/widgets.dart), it also introduces a significant codebase migration across the ecosystem. If you use AI coding assistants like Google Antigravity, Claude Code, Cursor, GitHub Copilot, or Cline, they often stumble on this transition due to LLM training cutoffs. In my latest article, I walk through how you can use the open-source "dart-sdk-skills" repository to teach your AI coding agents to automate this migration in a single prompt: 🔍 What the runbook covers: • Running data-driven automated refactors via `dart fix --apply --code=migrate_design_widgets` • Updating pubspec.yaml dependencies and rewriting canonical imports • Configuring updated GlobalMaterialLocalizations delegates • Building lightweight headless apps with zero Material/Cupertino overhead 📖 Read the full article on DEV: https://lnkd.in/gk5KhRNw #Flutter #Dart #FlutterCommunity #MobileDevelopment #SoftwareEngineering #AI #Programming

In Dart, classes are restricted to single inheritance. But in real-world Flutter, your domain repositories and UI controllers already extend base classes like TextEditingController, ChangeNotifier, or BaseRepository. In bloc_signals 1.2.0, we’ve introduced CubitSignalMixin and BlocSignalMixin—allowing you to mix 0ms synchronous reactivity and event concurrency directly into existing classes without wrapper boilerplate or proxy objects. Read Episode 26 of the BlocSignal Architecture series: https://lnkd.in/ghv9_TEc #Flutter #Dart #MobileDevelopment #SoftwareArchitecture #StateManagement

State management in Flutter does not have to be an ideological battleground or an all-or-nothing rewrite. Today, I’m excited to announce the release of bloc_signals_bloc and a major update to bloc_signals_riverpod (v1.2.0), bringing full bidirectional peer interoperability across Flutter’s state management ecosystem. At the "Grand Central State Terminal", three foundational rail lines now operate side by side as first-class equals: 🚂 Classic BLoC — The battle-tested event-driven iron horse 🚚 Riverpod — The declarative dependency graph logistics hauler 🚄 BlocSignal — The high-speed, streamless synchronous signal maglev What this means for engineering teams: 🔹 No More Rewrite Tax: Introduce synchronous, fine-grained Signals into massive legacy BLoC or Riverpod codebases one widget or screen at a time. 🔹 Respect for Established Code: Existing authentication BLoCs and Riverpod dependency trees plug directly into reactive signal pipelines with zero migration friction. 🔹 Typed Bidirectional Control: Mutate Riverpod notifiers or dispatch BLoC events directly through signal peer handles with automatic lifecycle disposal. Read the complete breakdown and see how all three architectures seamlessly synchronize in our Triple Counter reference app: 🔗 https://lnkd.in/gq_w9YUD Documentation and live interactive showcases: https://blocsignal.dev #Flutter #Dart #SoftwareArchitecture #MobileDevelopment #TechLeadership #StateManagement #OpenSource

🚀 Saying goodbye to FutureBuilder and StreamBuilder boilerplate in Flutter. Flutter developers know the drill with asynchronous widgets: ❌ Re-executing futures whenever a parent widget rebuilds. ❌ Nesting verbose AsyncSnapshot matching and ConnectionState switches inside UI build methods. ❌ Glitchy layout flicker and complex teardown logic. We just released bloc_signals 1.1.0, introducing symmetrical async adapters that lift Future<T> and Stream<T> directly into synchronous, fine-grained state containers at the business logic layer. 💡 What’s new in 1.1.0: • Symmetrical Dual-Track Adapters: Seamlessly choose between raw domain values (future.toBlocSignal(initialState: ...)) and sealed pattern-matched states (future.toAsyncBlocSignal()). • Universal Signal Bridging: Wrap any Signal, Computed, or StreamSignal directly into a BlocSignalBase. • Synchronous UI Rebuilds: Consume async data in UI components with BlocSignalBuilder or context.select() with zero unnecessary widget re-evaluations. 📖 Check out the full architectural deep-dive on DEV.to: 👉 https://lnkd.in/ggbW8sGW 📦 Package on pub.dev: https://lnkd.in/g5zzy8Wg 🌐 Docs & Playground: https://blocsignal.dev #Flutter #Dart #MobileDevelopment #StateManagement #ReactiveProgramming #OpenSource #SoftwareArchitecture

Is FutureBuilder an architectural anti-pattern in large-scale Flutter apps? While convenient for quick demos, embedding raw asynchronous futures and streams directly into widget trees violates the core Flutter design tenet: Widgets should be pure, synchronous projections of state. This trap is so prevalent that even the original Flutter documentation video for FutureBuilder made the mistake of constructing the future inside build() until I filed a bug report (the current official video on YouTube still shows "Take 2" on the clapperboard as proof!). In Part 21 of the BlocSignal Architecture & Practice series on DEV.to, I break down: 🛑 The four fatal flaws of in-view asynchrony (layering collapse, accidental refetching, uncoordinated layout shifts, and fragile async tests). 🛡️ The "Async at the Edge" architectural pattern using AsyncSignal and BlocSignal. ⚡ How to achieve deterministic, Frame 1 synchronous widget testing without flaky pumpAndSettle() delays. 🔗 Read the full deep-dive here: https://lnkd.in/gg_Zg9mK #Flutter #Dart #MobileDevelopment #SoftwareArchitecture #StateManagement #GoogleDeveloperExperts

#HumpdayQandA and Live Coding in 30 minutes at 5pm BST / 6pm CEST / 9am PDT today! Answering your #Flutter and #Dart questions with Simon, Randal, John and Esra https://lnkd.in/gADnmipU

Gemini Nano and Apple Intelligence in your Flutter app 🤖 Remember how Flutter Gemma follows the "one codebase — any engine" principle? Now the engine can be the AI already built into the device — with zero megabytes to download. Inference engines are now pluggable: you register them at startup, and the plugin picks the right one for the model and platform. Need a bundled model (Gemma, Qwen, Phi…)? Sure. Need the one baked into the OS? Covered too. The star is the new `flutter_gemma_builtin_ai` engine — it runs the model the device already ships with, nothing to fetch: • 🤖 Android — Gemini Nano (ML Kit GenAI / AICore) • 🍎 iOS / macOS — Apple Foundation Models (Apple Intelligence) • 🌐 Web — Gemini Nano via the Chrome Prompt API That gives you a simple, powerful pattern: device supports it → use the built-in model (0 MB, private, fast); if not → fall back to an open one. Same API, one abstraction, zero vendor lock-in — swap the engine, don't rewrite the app. `flutter_gemma 1.6.5` + `flutter_gemma_builtin_ai 0.2.0` are live on pub.dev. website: https://fluttergemma.dev docs: https://lnkd.in/gx-3deuM #Flutter #FlutterGemma #OnDeviceAI #GeminiNano #AppleIntelligence #LLM #EdgeAI #Dart

Why does your AI coding assistant keep writing 2021-era Dart? 🤖 Over the last few years, the Dart language and Flutter ecosystem have evolved at a blistering pace: • Dart 2.12: Sound Null Safety (?, late, !, required) • Dart 2.17: Super-parameters and enhanced enums • Dart 3.0: Records, pattern matching, switch expressions, and sealed classes • Dart 3.13+: Primary constructors and modern concise shorthands Because LLM pre-training datasets naturally lag behind bleeding-edge releases, AI coding agents (Claude Code, Google Antigravity, OpenAI Codex, GitHub Copilot, Cursor) often struggle with the "training cutoff gap." They frequently reject modern Dart 3.13 syntax as errors, generate excessive boilerplate, or miss the exact minSdk lower bounds in pubspec.yaml. To solve this, I've open-sourced dart-sdk-skills—an authoritative, version-by-version agent skill suite covering Dart 1.0 all the way to 3.14. Using progressive disclosure, it equips AI agents with: 1. Instant minSdk verification for any language grammar feature or core API. 2. Complete guides for modern Dart 3.13+ ergonomics. 3. A 4-stage legacy rescue runbook for migrating older pre-null-safety apps directly into modern Dart 3. Installable globally across any compatible agent with a single command: npx skills add RandalSchwartz/dart-sdk-skills -g Check out the full article and architecture breakdown below: https://lnkd.in/gnNPZzeK #Dart #Flutter #SoftwareEngineering #ArtificialIntelligence #Programming #GenerativeAI

Every Flutter developer eventually wrestles with state management granularity: "How do I balance developer ergonomics against architectural rigor? When is a simple reactive primitive sufficient, and when do I truly need a structured, event-driven pipeline?" For years, developers have swung between two frustrating extremes: 1. The Over-Engineering Trap: Creating 5 separate event classes just to toggle an accordion boolean. 2. The Spaghetti Trap: Using raw, untracked primitives for complex transactional flows, leading to race conditions and untraceable mutations. In my latest article for Google Developer Experts, I break down the definitive 4-Tier State Hierarchy: 🔹 Tier 1: Raw Signals / computed() — Local widget micro-state & derived calculations (0 boilerplate). 🔹 Tier 2: CubitSignal — Feature domain logic & CRUD with direct imperative methods and unidirectional data flow. 🔹 Tier 3: BlocSignal — Event concurrency pipelines (restartable debounce, droppable locks, sequential queues) & OpenTelemetry audit logging. 🔹 Tier 4: Hydrate & Replay — Synchronous Frame-1 persistence and undo/redo stacks. Plus, we’ve launched an interactive State Decision Wizard on blocsignal.dev to help you match your requirements to the ideal container in seconds. Check out the full guide on DEV.to: 🔗 https://lnkd.in/gx52TS5Z #Flutter #Dart #SoftwareArchitecture #StateManagement #MobileDevelopment #TechLeadership

In software engineering, we usually measure framework upgrades by what they *add*: new macros, new APIs, new abstractions. But after decades in software and 8+ years as a Flutter GDE, I've realized that the greatest upgrade in developer experience isn't what new concepts you are forced to memorize—**it’s the mental gymnastics, framework-specific edge cases, and defensive rituals you finally get to unlearn.** For years, I was a vocal, passionate advocate for Riverpod. I recommended it in talks, community spaces, and client architectures. Rémi Rousselet is a pioneer whose work solved real flaws in Flutter's early days. However, over the course of Riverpod's evolution, solving every edge case inside a global declarative provider graph accumulated immense cognitive overhead: • Terminal watchers spinning on `build_runner` after every refactor • The artificial boundary between the "Ref World" and pure Dart domain services • Unexpected `GoRouter` navigation stack wipes • Manual keep-alive retain tokens just to make an async mutation safe from auto-disposal • AI coding assistants hallucinating across conflicting Riverpod versions When you pivot to **BlocSignal**—combining the architectural discipline of BLoC with the synchronous speed and fine-grained reactivity of Signals—that entire cognitive burden disappears. Best of all: if your team is already invested in Riverpod, you don't need a big-bang rewrite. With `bloc_signals_riverpod`, you get a seamless bidirectional bridge to migrate incrementally, feature by feature. Dive into the full breakdown on DEV.to: https://lnkd.in/gMaSPF4C #Flutter #Dart #SoftwareArchitecture #MobileDevelopment #WebDevelopment #Programming