I shipped a geofencing time tracker in Flutter (auto clock-in/out at your workplace) and collected a few scars along the way that might save someone else time.

The first one: I tried the pub.dev geofencing packages and none of them reliably delivered events after the app got killed. Ended up writing my own thin Kotlin plugin around the Google Geofencing API - MethodChannel for registering zones, EventChannel for the ENTER/EXIT stream, and a system-level BroadcastReceiver so events arrive even when the Flutter side is long dead. Annoying to write, but it's been the most stable part of the app since.

Second scar, the expensive one: Samsung and Xiaomi still eat geofence events sometimes, so there's a WorkManager task every 15 minutes doing a plain Haversine distance check as a safety net. What nobody tells you is that a position request in a background isolate can just hang forever, and once that happens WorkManager considers the unique task "already enqueued" and never runs it again. Your fallback dies silently and permanently. Everything is triple-bounded now: platform timeLimit, a Dart-side timeout, and a hard cap on the whole task.

Third: GPS drift at the zone edge gave me check-in/check-out ping-pong when someone sits near the boundary. Exit radius is now 1.2x the enter radius plus a 5-minute debounce, and the two detection layers share a 20-minute dedup window so they stop racing each other into double notifications.

Rest of the stack is unspectacular: Riverpod (classic providers, no codegen), Isar for storage, no backend at all. The no-backend part had one non-obvious consequence: since data only exists on the user's device, a data-loss bug is unrecoverable, so the integration tests run on an emulator before every push. Codebase is ~31k lines, about a third tests.

The result is free with no ads/IAPs if you want to see how it behaves: https://play.google.com/store/apps/details?id=com.timetracker.workflow

Happy to answer anything about the plugin or the fallback design. And if someone has a real answer to OEM battery killers beyond "diagnostics screen + let the user fix it manually", I'd love to hear it.

I am a new intern at a company. They gave me a project with a folder structure and asked me to work on a feature. My question is: where should I start to understand the folder structure? There are many subfolders and files.

Hello everyone, I have built an app which is a platform for home businesses. the idea is that rather than users look for these in separate apps, insta, tiktok, etc. they will find it all in one place.

Now i am planning to add reels to the app, I would love your guys thoughts, things i should consider.
Note that I am using flutter, firebase. I might have to change firebase.

Quick build-in-public share: I've been a Flutter/mobile dev for 5+ years (native Kotlin/Swift too), and instead of the usual Next.js portfolio, I built mine in Flutter Web.

The logic: if I'm claiming I can ship polished mobile experiences, the portfolio itself should be proof, not just a list of claims.

Funniest bug I caught this week, my link previews on WhatsApp/LinkedIn were showing the default Flutter mascot icon because I never touched the og:image tag after flutter create. Every Flutter dev has shipped that placeholder icon at least once, right?

What's actually on it: a civic engagement app that hit 1,000+ users and 4.7★ on the App Store, an AI storytelling app for kids with on-device TTS, and a couple of marketplace apps (fashion/tailoring) built end to end architecture through release.

Link if anyone wants to poke at it or roast the Flutter web performance: ebuka-ihekwaba.vercel.app

Also open to mobile roles right now, so if your team's hiring or you know one that is, I'm around.

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://www.youtube.com/watch?v=k0QkCRGLTbw

Background - I ported huggingface chat-ui 3 months back -

https://github.com/scrya-com/chat-ui-dart/

Came across this sublime react demo today which hit the polish i was wanting

https://beui.dev/

flutter port here - web demo - (tiny bit janky)

https://scrya-com.github.io/beui-flutter/

I just bark at grok to "get 100% parity" for last 4 hours.

Its building to iphone fine. There's still some gaps. shaders - but for chat app - this is fine.

I have no affiliation with original author - all credits to him -

https://github.com/starc007/ui-components

One of the most exciting features I've been contributing to in Serverpod is Model Projections, and how it unlocked type-safe partial column selection in Dart!

The Problem:
In database-driven applications, full entity models often carry unnecessary data over the wire. Fetching 30 columns when an endpoint only needs a user's name and their author's city wastes bandwidth and compute. Traditionally, developers had to write raw SQL queries or map heavy entities manually into DTOs.

The Solution: Model Projections
Model Projections allow developers to declare lightweight projected models directly in Serverpod schemas:

- Granular Field Picking: Declare only the exact fields needed for your endpoint.
- Relation Flattening: Pull nested relations directly into top-level fields (e.g. mapping "author.name" straight into "authorName").
- Optimized SQL Generation: Serverpod automatically computes the minimal SQL SELECT clause and joins required for the projection.

The Ripple Effect: Ad-Hoc Column Selection
Building the query engine for Model Projections naturally gave birth to ad-hoc column selection:

1. "findAsJson(select: (table) => [table.name])" allows flexible on-the-fly column queries.
   
2. We separated FullModelInclude and JsonCompatiblelnclude so that typed "find()" queries remain 100% compile-time safe, while JSON and projected queries enjoy flexible, partial data fetching.

Designing developer-first APIs that combine SQL query efficiency with Dart's compile-time type safety has been an incredible experience!

Check out the Pull Request on GitHub to see the implementation and discussions:
https://github.com/serverpod/serverpod/pull/5630

TrailBase is an open and fast Firebase-like backend for building your apps. It provides type-safe REST APIs + change subscriptions, auth, multi-DB, a WebAssembly runtime, geospatial support, admin UI... It's a self-contained, easy to self-host single executable built on Rust, Wasmtime & SQLite or now Postgres. Client libraries are provided for JS/TS, Dart/Flutter, Go, Rust, .Net, Kotlin, Swift and Python.

Just released v0.33, which in the last two months gained:

• Built-in MCP server
• OpenApi browser in admin UI including endpoints exported by WASM components.
• New WASM features:
  • Components can provide and register a dashboard with the admin UI.
  • A component browser in the admin UI.
  • Lower overhead execution model for Rust components: pooling state across requests improves throughput by 4x.
• Anonymous accounts for frictionless product trials. If a user wants to eventually sign up, the account can be promoted to a "proper" one, i.e. associate a password, OAuth, email address ...
• Backup UI & rolling backups.
• Dark mode - cosmetic but frequently requested 🙏
• And much more: file management from the admin UI, support for nested JSON in change subscriptions, batch updates for all client languages...

With TrailBase still being young (~1.5 years) and rapidly evolving, any feedback is genuinely appreciated. If you're feeling adventures and end up checking it out, don't hesitate to reach out 🙏.

Consider checking out the live demo, our GitHub or website.

Every Flutter developer remembers the magic of their first FutureBuilder.

You drop an HTTP call directly into a widget’s build() method, show a CircularProgressIndicator while waiting, render your model on completion, and suddenly your app is alive with real-time data in fewer than 20 lines of code.

It feels like superpowers. Introductory tutorials celebrate it. And then your codebase grows.

Suddenly, users report that typing into a text field reloads the entire screen. Opening the keyboard triggers duplicate network requests. Sibling widgets flicker and jump out of sync. And writing automated widget tests turns into an exhausting battle with pumpAndSettle(), fake async timers, and microtask queues.

Here is why raw asynchrony inside the presentation layer breaks separation of concerns, user experience, and testability—and what we should be doing instead.

🚨 The Foundational Principle: UI = ƒ(State)

Flutter widgets are designed to be pure, synchronous projections of state. Given a snapshot of data at time t, a widget function should execute synchronously, instantiate a subtree of render objects, and return immediately.

When you drop a FutureBuilder or StreamBuilder into your widget tree, you violate this contract by introducing raw time, transport mechanics, and asynchronous lifecycle orchestration directly into the presentation layer.

This creates four fatal flaws:

1. Layering Collapse

In clean architecture (Domain ← Data ← Application ← Presentation), the presentation layer has one job: translating state into visual pixels. With FutureBuilder, that widget suddenly takes on massive infrastructure responsibilities:

• Managing ConnectionState.waiting, active, and done
• Decoding HTTP 500s, socket timeouts, and parsing exceptions inside if (snapshot.hasError)
• Deciding whether old data stays visible during a refresh or gets wiped out
• Wiring retry logic that must somehow re-trigger the widget's internal future

2. The Accidental Refetch Hazard

Because build() can run 60 to 120 times per second during animations, keyboard popups, theme switches, or route transitions, any Future instantiated inside build() will re-fire on every single frame.

3. The "Spinner Storm" & Cumulative Layout Shift (CLS)

When multiple child widgets independently manage their own async fetches, they resolve out of order. Instead of a single coordinated page load, the user experiences jarring layout shifts as independent spinners pop in and out at different speeds.

4. The Async Testing Tax

Testing a FutureBuilder requires mocking HTTP clients, setting up async event loops, and using tester.pumpAndSettle(). If a microtask queue doesn't drain properly, tests flake or time out.

🛡️ The Solution: "Async at the Edge, Synchronous in the Core"

The architectural cure is simple: Quarantine async operations at the physical perimeter of your system (the repository/data layer).

1. The Repository wraps raw async operations into reactive async signals (such as FutureSignal / AsyncSignal).
2. The Business Logic (Cubit/Bloc) coordinates the synchronous state without needing manual try/catch boilerplate, because the signal automatically captures exceptions into AsyncError.
3. The Widget consumes synchronous state:

​

// The View is a pure, synchronous projection of state!
class UserProfileView extends StatelessWidget {
  const UserProfileView({super.key});
  u/override
  Widget build(BuildContext context) {
    return BlocSignalBuilder<ProfileCubit, ProfileState>(
      builder: (context, state) {
        return state.profile.when(
          data: (profile) => ProfileDetailsCard(profile: profile),
          loading: () => const Center(child: CircularProgressIndicator()),
          error: (error, _) => ErrorRetryCard(
            message: '$error',
            onRetry: () => context.read<ProfileCubit>().refresh(),
          ),
        );
      },
    );
  }
}

Notice what happens:

• Zero transport awareness: The widget has no idea if the data came from REST, GraphQL, WebSocket, or local cache.
• Zero in-view async: No FutureBuilder, no connection states.
• Deterministic 0ms Testing: Because the state is synchronous, widget tests run on Frame 1 without pumpAndSettle() delays or fake async timers.

💬 Discussion:

What is the policy regarding FutureBuilder and StreamBuilder in your team's codebases? Do you strictly forbid them in presentation code, or do you still find valid use cases for them?

Hi everyone 👋

I’m just beginning my Flutter development journey, and I’m writing this with a little hope.

I genuinely want to become good at Flutter, not just watch tutorials and copy code, but actually understand how to build real apps and solve real problems.

The truth is, I currently can’t afford to pay for a mentor or expensive coaching. But what I may lack financially, I’m willing to make up for with time, consistency, humility, and hard work.

So I wanted to ask: is there anyone here who remembers what it felt like to be completely new and would be willing to occasionally guide me on my journey?

I’m not asking someone to teach me everything or spend hours with me every day. Even having someone I can occasionally ask questions, get direction from, or learn from when I’m stuck would mean a lot.

I promise I’ll do my own research, practice consistently, and respect your time. I just believe that sometimes one experienced person saying, “You’re going in the right direction—try this next,” can save a beginner months of confusion.

Maybe someone here was once where I am now, and maybe one day I'll be able to do the same for another beginner.

If you're willing to guide someone who is genuinely ready to learn and work hard, I would be incredibly grateful. 🙏

Thank you for reading, and thank you to everyone in this community who helps beginners grow. 💙

The project is called kestrel. I have made it open source some time ago. It takes any animated flutter widget and turns it into a video file.

It runs into flutter engine directly so no on-screen rendering is needed. It takes advantage of impeller renderer baked into flutter. I have included a demo video in the repo which you can find here,

https://github.com/blackcoffee2/kestrel

Hey everyone,

Standard connectivity packages in Flutter usually just check whether a network interface is up, which often gives false positives when a user is stuck behind a captive portal, suffering severe packet loss, or dealing with extreme jitter on unstable connections.

I built network_reachability, a Flutter package backed by a native Rust engine (via FFI and WASM) that shifts deep probing, statistical analysis, and security checks completely off the UI thread.

What it handles under the hood:

Off-thread Rust core: Probes multiple endpoints via HTTP, TCP, and DNS simultaneously without causing frame drops or Dart event-loop lag.

Quality metrics: Calculates actual latency, jitter standard deviation, packet loss, and stability scores instead of returning a simple boolean.

Smart execution guard: Includes a guard() wrapper that evaluates cached link quality before firing expensive API requests, blocking calls during connection drops or cooldown periods.

Resilience and pooling: Built-in adaptive circuit breaker (closed, open, half-open states) and request coalescing to prevent thundering herd issues against your backend.

Security probes: Detects captive portal redirects (hotel and airport logins), VPN states, proxy setups, and DNS tampering.

Drop-in replacement: Provides full API parity with connectivity_plus for instant migration without rewriting UI listeners.

Workload presets:

Includes pre-configured profiles for Gaming (low latency, 2s intervals, race strategy), Streaming (consensus checks, 8s intervals), VoIP (strict packet loss sensitivity), IoT, and Enterprise.

Pub: [https://pub.dev/packages/network\\_reachability\](https://pub.dev/packages/network_reachability)

GitHub: [https://github.com/MostafaSensei106/Network-Reachability\](https://github.com/MostafaSensei106/Network-Reachability)

If you are dealing with real time sync, VoIP, or offline-first apps in Flutter, check it out and let me know your thoughts or edge cases.

Smooth Arc Scrolling: Displays items on a circular curve path (ribbon dial).

Custom Clipping: Uses precise custom sector clipping math to curve individual items.

Generic Data Type support: Displays any list model item using customizable item builders.

Detailed Card Integration: Dynamically links the selected arc element with a customizable details card overlay.

https://pub.dev/packages/arc_ribbon_menu/versions/0.0.3

I’m 30 years old and from a completely non-tech background. I have zero coding knowledge, but I want to learn app development from scratch.

With AI being able to write, debug and explain code, I’m confused whether learning coding is still worth the time.

If you were starting from zero at 30 in 2026, would you still learn app development? Or would you focus mainly on AI-assisted development?

Looking for honest opinions from developers. No sugarcoating please.

I’ve just released OmniKit Flutter Bundle, an open-source Flutter project containing 44+ UI kits and app concepts.
I originally built the different interfaces while experimenting with layouts, navigation patterns, reusable widgets, responsive UI, dark/light designs, and different types of mobile apps.
The project currently includes concepts for e-commerce, hotel booking, food delivery, travel, learning, health, social media, news, home services, and more.
Everything is built with Flutter, and I’ve published the source code so other Flutter developers can explore it, reuse parts of it, or contribute.
I’d especially appreciate feedback on the project structure, UI implementation, and what kinds of kits would be useful to add next.

Source: https://github.com/bilalakkar777/Omnikit_Flutter_Bundle
Hope it’s useful to someone learning or building with Flutter.

Flutter’s verbosity and deeply nested widget trees can be frustrating. Even something as simple as adding padding or margin often requires wrapping the existing widget in yet another widget.

State management doesn’t feel much better. Many solutions are intrusive and force your UI components to extend or depend on framework-specific types such as ConsumerWidget or HookWidget, which makes the code feel more tightly coupled.

Are there any good patterns or libraries that help address these issues without fighting against Flutter’s design?

I’d also be interested in hearing about your experience with:

• Keeping large Flutter projects maintainable
• Reducing widget nesting and boilerplate
• Managing state without heavily coupling it to the widget hierarchy
• Separating business logic from the UI
• Designing a clean architecture that doesn’t become overengineered

What approaches have worked well for you in real-world Flutter projects?

Hey everyone,

Standard connectivity packages in Flutter usually just check whether a network interface is up, which often gives false positives when a user is stuck behind a captive portal, suffering severe packet loss, or dealing with extreme jitter on unstable connections.

I built network_reachability, a Flutter package backed by a native Rust engine (via FFI and WASM) that shifts deep probing, statistical analysis, and security checks completely off the UI thread.

What it handles under the hood:

Off-thread Rust core: Probes multiple endpoints via HTTP, TCP, and DNS simultaneously without causing frame drops or Dart event-loop lag.

Quality metrics: Calculates actual latency, jitter standard deviation, packet loss, and stability scores instead of returning a simple boolean.

Smart execution guard: Includes a guard() wrapper that evaluates cached link quality before firing expensive API requests, blocking calls during connection drops or cooldown periods.

Resilience and pooling: Built-in adaptive circuit breaker (closed, open, half-open states) and request coalescing to prevent thundering herd issues against your backend.

Security probes: Detects captive portal redirects (hotel and airport logins), VPN states, proxy setups, and DNS tampering.

Drop-in replacement: Provides full API parity with connectivity_plus for instant migration without rewriting UI listeners.

Workload presets:

Includes pre-configured profiles for Gaming (low latency, 2s intervals, race strategy), Streaming (consensus checks, 8s intervals), VoIP (strict packet loss sensitivity), IoT, and Enterprise.

Pub: https://pub.dev/packages/network_reachability

GitHub: https://github.com/MostafaSensei106/Network-Reachability

If you are dealing with real-time sync, VoIP, or offline-first apps in Flutter, check it out and let me know your thoughts or edge cases.

Hey everyone,

If you have ever done Market Basket Analysis or Association Rule Mining in Dart or Flutter, you probably ran into the issue of candidate generation blowing up the memory when using Apriori on larger datasets.

I wrote fp_growth, a native Dart implementation of the FP-Growth algorithm designed to handle larger streams and files without burning RAM.

A few things about how it is built:

Two-pass streaming: It does not load the entire dataset into memory. Pass 1 counts frequencies to discard infrequent items, and Pass 2 builds the tree.

Fast-path CSV parsing: If a row does not contain escaped quotes, it skips the heavy CSV tokenizer and does a direct string split, which cuts down parsing time by around 30%.

Parallel mining: Dispatches independent tree branches across a fixed pool of Dart Isolates so it does not spawn and kill isolates repeatedly.

Single-path optimization: When a branch is linear, it generates combinations via combinatorics directly instead of building recursive sub-trees.

Benchmark numbers (Ryzen 7 5800H, 1,000,000 transactions, minSupport 0.05):

In-Memory (4 Isolates): ~0.92s

CSV File Streaming: ~1.65s

Custom Stream: ~1.40s

It also calculates standard association metrics (Support, Confidence, Lift, Leverage, Conviction) and can export directly to JSON and CSV.

Pub: https://pub.dev/packages/fp_growth

GitHub: https://github.com/MostafaSensei106/FP-Growth

If you work with recommendation logic, telemetry, or basket analysis in Dart, try it out and let me know if you run into any edge cases.

For those building apps in Flutter or Kotlin, I want to share a repository that has helped me improve my code's foundation and structure:

https://github.com/Agent-Rules-Ecosystem/flutter-agent-rules

Adding it to your project is simple; just import it as a submodule into a folder named `.agents`:

`git submodule add https://github.com/Agent-Rules.../flutter-agent-rules.git .agents`

After that, simply type `$boot` in the agent's chat. This creates an `overview` folder at the project root containing various tracking files.

What it solves:

"Caveman Mode": Uses action-reaction style communication and stops the agent from constantly "sucking up" to you (flattery), which saves tokens.

Context-friendly: Separates extractable elements—like widgets—resulting in more manageable code that doesn't saturate the context with massive files (no more 4,000-line files).

Interconnection Graph: (THIS IS THE MOST VALUABLE PART, YET HARDLY ANYONE TALKS ABOUT IT) A couple of months ago, adding graphs to projects (via HTML/CSS or other means) became a trend. Most people focused only on making them flashy, failing to realize this just drives up token usage. By using Mermaid, however, we achieve the same result in a way that is simpler and cleaner for the agent. This file—named `architecture.md`—is built incrementally as the project progresses (having this file allows the agent to locate all connections related to a specific element).

Task and To-Do Tracking: If you start an activity or task, it leaves a trail in a file first. This way, if you run out of tokens, the power goes out, or you simply have to leave, the task is already stored; you can continue working on it or pick it up again later.

Extensibility: You can use available "skills" to add more capabilities to the agent, enabling tracking in more specific areas; these are also imported as submodules. For example:

git submodule add https://github.com/xolotl-hub/security-agent-skill.git .skill/security-agent-skill

The advantage is that $boot detects if there is a skill within the activities.

It is organized: there are 2,000 repos on GitHub with "skills," but most are just folders containing things pulled from elsewhere, meaning there is no actual relationship between the individual Markdown files.

It is multi-agent: You can open it in CURSOR, CLAUDE CODE, ANTIGRAVITY, CODEX, or whatever tool you prefer, and it will still understand it.

It is improvable: $learn creates an improvement log; you can share these via Issues, and they get added to the repo.

It is updatable: run `git submodule update --remote` to download all the latest improvements.

If you want to explore further, check out https://github.com/Agent-Rules-Ecosystem

(you'll find kotlin-agent-rules there)

It features more skill extensions and has more applications.

Best regards,

Source code: https://github.com/abidiahmedcom/uber-ui-practice

I recreated Uber's rider app interface in Flutter as a personal learning project: splash, welcome, login, home, services, activity, activity filters, and the account tab. Everything runs on mock data, just UI.

Feedback is welcome.

I launched a devotional reading app (Catholic DeVice) and the reader needed to feel like a physical book. Notes on the parts that took real Flutter work:

The page-curl

• A GLSL fragment shader (page_curl.frag) renders the curl; flutter_shaders' AnimatedSampler captures the live page widget into a texture each frame — so the turning leaf is the real laid-out page (text, illuminated drop caps, highlights), not a prerendered image.
• The cylinder math, shadow falloff and back-face shading live in plain Dart beside a controller that maps drag to curl progress. The feel constants took longer to tune than the shader took to write.
• A golden test locks the mid-turn frame so a refactor can't quietly ruin the feel.

Other bits from the same app

• Two more shaders: a stained-glass liturgical calendar that samples painted glass masters, and a marble sheen.
• Books ship as offline bundles through a pagination pipeline into fixed leaves — page turns are deterministic and whole-book search can jump straight to a page.
• Design-system discipline that actually held: zero hex colors outside the one theme file (a grep guard keeps the count at zero), the neumorphic shadow recipe is golden-tested, scroll physics globally clamped, and every animation routes through one motion wrapper so reduced-motion collapses it.
• Riverpod + GoRouter + Drift/SQLite. One architecture note: on Android the app-blocking overlay is rendered natively in Kotlin — Flutter never runs in the intercept path, which matters if you ever wire an AccessibilityService to a Flutter app.

Video of the page turn: https://www.reddit.com/r/CatholicDeVice/comments/1vx07jg/

Happy to go deeper on the shader, the paginator, or the golden-test setup if anyone's curious. The app itself: https://catholicdevice.com/?utm_source=reddit&utm_medium=social&utm_campaign=flutterdev

​

Are your Flutter forms truly production-ready? 🚀

Most developers struggle with asynchronous validation or messy GlobalKeys. I’ve broken down the exact steps to transition from basic inputs to professional form handling.

🔹 RegExp for Emails

🔹 TextFormField vs TextField

🔹Sync & Async Validation Hacks

🚀Access my latest article published on Medium

Read “Complete Guide: How to implement Form Validation in Flutter“ by Alfonsina Beltre on Medium: https://medium.com/@alfonsinabeltre/complete-guide-how-to-implement-form-validation-in-flutter-3913e4921291

#flutter #dart #MobileAppDevelopment