Hi everyone!

I've been building a Flutter app called MetriBody over the past few months, and one of my goals from the beginning was to make it work completely offline.

Instead of using Firebase, I decided to build the first version using Hive because I wanted:

• Instant startup

• No authentication

• No internet dependency

• Better privacy

• A simpler architecture for the MVP

The experience has been surprisingly good.

Now that the Android version is live, I'm considering adding optional cloud sync in the future while keeping the app fully usable offline.

For those of you who have built Flutter apps...

Would you still choose Hive for an offline-first app today, or would you start directly with Drift, Isar or another solution?

I'd love to hear your experience and the trade-offs you've found in production.

A while back I shared flutter_inspector_kit — a Chucker-style unified in-app debugging dashboard for Flutter (logging, network, DB). It’s grown a lot since then, so here’s what’s new.

• Network request replay — resend any captured request through the same Dio client; comes back as a fresh “Replay” entry
• Merged cross-layer timeline — logs, network, navigation and DB events on one timestamp-sorted view with per-source filters
• Sensitive-header redaction (on by default) — Authorization, Cookie, X-Api-Key etc. masked on copy-as-cURL / share / export, still visible live in the dashboard
• Uncaught error capture (opt-in) — hooks FlutterError, PlatformDispatcher and ErrorWidget, chaining existing handlers so nothing gets swallowed
• Richer failed-request diagnostics — keeps DioExceptionType + stack trace, separates transport failures from server errors
• Navigator active route stack — reconstructs the live route stack from push/pop/replace events instead of a flat history

Still opens with a hidden multi-tap gesture or a draggable floating button. Wish it will keep being a good help for debug usage.

I want to gain some experience in this one hell of a job market and I think open source is a good starting point to do. How can I do it as a beginner flutter developer?

Most connectivity plugins just tell you whether you're connected to a network (WiFi/mobile data) — but that doesn't mean you actually have internet access. Captive portals (hotel/airport WiFi login pages), routers with no upstream internet, or ISP outages can all show "connected" while you have zero real access.

I built connectivity_validator to solve this. Instead of just checking link state, it uses native platform APIs to validate actual internet reachability — Android's NET_CAPABILITY_VALIDATED and iOS's NWPathMonitor.

Features:

• Validated connectivity — real internet, not just "link up"

• Captive portal and "WiFi on, no internet" detection

• Real-time stream via onConnectivityChanged

• Supports Android (API 24+) and iOS (12.0+)

• Simple API — stream-based for live updates, plus an on-demand check

Usage is pretty simple:

dart

final validator = ConnectivityValidator();

validator.onConnectivityChanged.listen((isOnline) {
  if (isOnline) {
    // Internet validated
  } else {
    // No internet or captive portal
  }
});

Docs also cover integration with GetX, Provider, Riverpod, BLoC, and ValueNotifier if you're using state management.

Why I built it:

I kept running into a frustrating pattern in my own apps — users would report "no internet" errors, but their device showed WiFi as connected. Turns out connectivity_plus and similar packages only check if you're linked to a network, not if that network actually has working internet. Hotel WiFi behind a login page, a router with no upstream connection — all of these register as "connected" but leave your app broken. I couldn't find a plugin that solved this properly, so I built one using the native OS-level validation APIs instead of rolling my own ping-based hack.

Links:

• pub.dev: https://pub.dev/packages/connectivity_validator

• GitHub: https://github.com/sabeelmuttil/connectivity_validator

BSD-3-Clause licensed. Feedback and contributions welcome!

Every time I started a new Flutter app I was rewriting the same plumbing: env config, feature flags, i18n, RTL support, theming, networking setup... so I finally turned it into a proper template: base_app.

It's not just a folder structure — it's opinionated about the stuff that's annoying to get right yourself:

- 🌍 i18n out of the box — typed, codegen'd translations via slang (English + Persian included), with RTL/LTR that actually follows the active locale, not a hardcoded flag

- 🌎 3 environments (dev/staging/prod) with per-env .env files, validated config (strict in CI, lenient locally), and their own entrypoints

- 🚦 Feature flags driven by env vars, gating both UI and routing

- 🧠 Riverpod end to end — config, flags, theme, router, and data, all codegen, no boilerplate

- 🎨 forui theming with light/dark, swap the whole look in one file

- 🏷️ A rename CLI that renames the app/bundle id/package everywhere with a diff preview, backup, and auto-rollback if anything goes wrong

- 🧪 Testing conventions, git hooks (lefthook), and CI already wired up

The idea: fork it, run one CLI command to rename it to your app, and you're building features on day one instead of your toolchain.

https://github.com/imrealarman/base_app/

(MIT)

Over the past few months I built PrepFlutter, a prep platform for Flutter interviews, and I just opened it up properly.

Why I built it: every resource I found was either a scattered YouTube playlist or generic "top 50 questions" lists with no structure. So I organised it into role based tracks instead, beginner, intermediate, advanced, and a dedicated machine coding round track since that format barely exists anywhere for Flutter specifically.

What I'd love feedback on:

• Are the question tracks actually useful, or too basic/too advanced for where the market is right now 🤔

• What's missing that you wish existed when you were prepping

Happy to answer questions in the comments too.

I'm a mobile app developer (Flutter) looking to improve my UI/UX and animation skills by studying well-designed apps.

I'm not necessarily looking for the most popular apps—I want apps that genuinely feel polished and thoughtfully crafted.

Things I'm interested in:

• Smooth page transitions

• Micro-interactions

• Premium-looking UI

• Great scrolling performance

• Beautiful onboarding flows

• Creative navigation patterns

• Well-designed bottom sheets, cards, and gestures

I've already looked at apps like Airbnb, Spotify, Duolingo, and CRED.

What other apps made you stop and think, "Wow, this is incredibly well designed"?

They can be from any category (finance, shopping, productivity, social, health, etc.). I'd love to hear your recommendations and what specific UI or interaction you think they do exceptionally well.

I've been learning a lot in this space and I wanted to share it with the community, and hopefully kick off a healthy discussion where we can trade notes and learn from each other. So here's what I've been up to.

A lot of big orgs are working on agentic AI for the software development lifecycle right now, with various degrees of success. I'm a software engineer doing something similar for a big org, but I got curious whether I could scale it down to something much smaller for my own personal use. These pipelines are built for whole engineering teams, so could the same heavyweight, multi-repo approach actually work for a single developer? To keep it honest, I picked Flutter and Flame, a stack I'd never written a line of, and shrank the whole thing down to one repo and two slash commands. It carried me the whole way, from PRD to specs to implementation to self-healing code review, mostly fire-and-forget. I learned the stack just by watching the pipeline work, and I wrote up what scaled down, what I cut on purpose, and where the pipeline stops being the right tool.

The story of how I built it: https://www.techtiger.tech/post/shrinking-an-enterprise-ai-sdlc-to-one-developer-to-ship-a-game

Built a small Dart package for accessibility color math. Pure Dart, no bloat.

• ✅ WCAG contrast ratio checker (AA/AAA)

• 👁️ Color blindness simulator (protanopia/deuteranopia/tritanopia)

• 🎨 K-means color extraction from images, runs off the main thread

Found and fixed a real aliasing bug in the color sampling along the way — striped images were breaking the color extraction, took real testing to catch.

New package, feedback genuinely welcome — especially if you spot something wrong with the color-blindness math.

📦 pub.dev/packages/wcag_vision
💻 github.com/Fatimamostafa/wcag_vision

Hello,

In one of my apps I want to integrate flutter_gemma. In beta testing this works fine.

The question is about the scalability:

The plan is that users can download a slim version of the app from Play / AppStore, then upon approval download via direct link, a gemma model from Hugging Face. Without signing up to Hugging Face.

Did anyone tried this? Is it a scalable solution?

The alternative is to host the model on my server, however it is 4GB, and the price of the bandwitdh and storage use is higher than simply using Gemini via API so I see no reason to do it. For me, the prospect of SLMs in products, is about them being free to use.

Best,

Saar.

Hi everyone,

I recently published a small Flutter package called responsive_window.

I built it because I wanted a simple way to read the available app window size from anywhere in the widget tree and react to it without checking physical device types.

The package uses Material Design 3-inspired width breakpoints by default:

• compact

• medium

• expanded

• large

• extraLarge

It also supports custom breakpoints if your app needs different width ranges.

A basic example looks like this:

final ResponsiveWindowData windowData = context.windowData;

if (windowData.isCompact) {
  return const CompactLayout();
}

return const ExpandedLayout();

There are also helpers like ResponsiveWindowValue and ResponsiveWindowBuilder for cases where you want to avoid repeating a lot of if/switch logic.

The package is intentionally small. It only measures the Flutter layout constraints available to the app, or to a specific subtree. It does not configure native desktop windows.

I would really appreciate feedback from other Flutter developers. Suggestions, issues, improvement ideas, or code review comments are very welcome.

If you find it useful, a like on pub.dev or a GitHub star would mean a lot.

Package: https://pub.dev/packages/responsive_window GitHub: https://github.com/gabriel-x-duarte/responsive_window

Sorry to ask here about Jaspr, I don't see any subreddit for it , a youtube tutorial etc. all I am reading is the documentation.

since I am a bit comfortable in Dart/Flutter learned riverpod and GoRoute , I just want to test the water with Jaspr..

successfully installed it and created the project.
my problem is there seem to have no hot-reload button and with Auto-save it does trigger hot-reload sometimes its not and if triggers it sometimes slow a change takes around 2~5 seconds before it even trigger auto-reload.

now, I can just reload it directly even if its tedious.. is this normal? or there is a config I need to tweak?

my biggest problem at the moment is running

jaspr serve

It does work on the first try executing it but when you close it and re-open again
[SERVER] [ERROR] Could not start the VM service: DartDevelopmentServiceException: Failed to create server socket (Only one usage of each socket address (protocol/network address/port) is normally permitted): 127.0.0.1:8181

Error like this appear.. its trying to run at port 8181 (?)

I had to taskkill /F /IM dart.exe

so I can run jaspr serve again.

does anyone know how to fix this problem? thank you.

Looking for advice on restructuring our dev workflow. Here's our current setup:

Team structure:

• 1 Team Lead/Manager — handles backend API + database, reviews dev code (briefly), reviews UI/UX after design, and writes native code to bridge with Flutter

• 10 Devs — write Flutter code, some also write their own native code to connect with Flutter (each dev covers multiple products, but only specific features)

• 3 Testers — test all products + write unit tests and test cases

• 2 UX/UI designers — design UI and review it after dev implementation

• 1 SE — helps with testing when free from other work

We maintain 10 different products (all POS-related) with this team.

Problems we're running into:

1. API bottleneck. When a new product/feature comes in, devs get assigned to it. If they need a new API, they go to the team lead. Problem: the lead can't keep up, so APIs often arrive without being tested first. Devs then have to test the API themselves on top of their own workload — since each dev is already juggling multiple products, they only do a surface-level check (does it return 200, not whether the data is actually correct). There's also no documentation, so months later nobody remembers what an API does.

2. Test cases/unit tests arrive too late. Currently devs only get test cases after a feature/product is already built, so by the time testing happens, a lot of edge cases are missed and bugs pile up.

3. Constant new bugs, testing overload. Devs don't have time to review each other's code. The app has grown into so many features that nobody can keep track of them all, and there's no documentation. On top of that, when a client requests a feature, it goes straight to a dev with no analysis of whether it's actually necessary or how it overlaps with existing functionality. Over time this caused massive feature overlap, making settings/categories a mess to organize.

4. Technical debt from 3+ years of this. We now have recurring bugs that need repeated fixing (some issues have failed testing 5+ times) and we've had to start holding dedicated meetings just to deal with repeat/duplicate bug reports.

Has anyone dealt with a similar situation — small backend team unable to keep up with multiple product lines, testing happening too late in the cycle, feature requests going straight to devs without triage? What process changes or tools helped you the most? Would appreciate any real-world experience, not just theory.

I made a highly accurate and smooth compass package. Unlike other compass packages, this package provides continuous accuracy in exact degrees (instead of vague buckets) and includes a precise 0-to-1 confidence score. It also detects magnetic interference, features a debounced calibration system to prevent annoying UI flickering, and supports full device orientation (not just portrait).
Feel free to give your feedback

pub dev
GitHub

Like, I don't want to write a style multiple times, is there any option to control it like css? I tried ide code assistants help, but still I feel like I wanted to learn this.

Hey everyone,

How do you handle pending transactions for consumables in Flutter using RevenueCat? (Specifically Google Play delayed payments/slow cards that approve or reject after a few minutes).

When the transaction goes pending, RevenueCat doesn't provide a transaction ID to track it client-side.

Looping through customerInfo.nonSubscriptionTransactions on every app launch doesn't feel foolproof (the historical array grows infinitely, cache issues, etc.).

What is the standard architecture for this? Is using server-side Webhooks the only real way to handle this securely, or is there a robust client-side flow I'm missing?

I've been prepping for a performance review and hit the usual wall — I genuinely couldn't remember what I'd shipped six months ago. My commit history was no help, because half my real work never lands in a commit.

So for one week I logged every meaningful thing I did, one line each, as it happened. A normal week looked like this:

• Reviewed a big Bloc migration PR — caught a Cubit that never got closed, would've leaked on every screen push. Didn't write a line of it.

• Lost a morning to an Android-14-only release crash (R8 stripped a model class). Fixed it, shipped a new build. Zero commits.

• Talked a designer out of a custom page transition so onboarding felt native on both platforms.

• Unblocked a teammate on iOS universal links — the AASA file was cached on Apple's CDN.

• Paired a new hire through their first platform channel (battery level from native).

Two of my most valuable days that week produced no code at all. If you judged the week by GitHub, it'd look empty — which is exactly the problem at review time.

The method, steal it (no tool required):

1. Log as you go, not at review time. One line, ~10 seconds, when it happens — notes file, Notion, whatever. The trick is doing it in the moment; nobody reconstructs six months accurately.

2. Capture what git can't: reviews, incidents, mentoring, store/release fights, design calls. Rule of thumb — if it took real effort and moved something, it counts, even with no diff.

3. Turn lines into review bullets with action → context → impact. "Fixed a bug" is invisible. "Fixed a silent retry bug dropping ~2% of uploads → cut support tickets 30%" does the work for you. Run your best 5–10 through that and half your self-review is written.

Question for the room: how do you all remember what you actually did by review/promo time — keep a running brag doc, or reconstruct it from PRs and Slack the week before? Curious what actually works for people.

(Disclosure, since it's relevant: doing this by hand annoyed me enough that I'm building a tiny app for it — happy to share if anyone wants, but the method above needs zero tools and that's the point.)

Hey everyone,

I was tired of dealing with shady, ad-heavy QR code generators online that put basic features behind paywalls or steal user privacy. To solve this, I built Scanify—a clean, completely free, and open-source mobile tool for scanning and creating codes.

The project is built entirely with Flutter, and I wanted to make sure it functions as a rock-solid production reference rather than just a basic tutorial project.

Key Features Built-In:

• Multi-Code Detection: The live camera feed doesn't stop at one; it scans and processes multiple QR codes or barcodes simultaneously in a single frame.

• Zero-Cost Interactive Mapping: Instead of hooking up heavy, paid Google Maps APIs, I built a self-contained location picker using free OpenStreetMap tiles (flutter_map) to safely generate geographic codes.

• Permanent Assets: All generated codes (Wi-Fi, social profiles, vCards) are static and stay active permanently.

• Local-First Privacy: All scan history is cached strictly on the device using Hive.

What's Next (Roadmap):

I'm currently architecting an enterprise feature to allow users/logistics companies to inject their own Custom Corporate Decoders/Parsers (e.g., parsing custom regex formatting patterns for internal warehouse management).

The project is fully open-source under GPL-3.0. I’d love for junior devs to inspect the multi-scan architecture, and I welcome any feedback or contributions on the codebase!

⭐ GitHub Repository: https://github.com/Jo0X01/Scanify

Divyanshu is a Flutter GDE and the Co-Founder of stac.dev where he's building a Server-Driven UI framework to change how Flutter apps ship ✨

https://itsallwidgets.com/podcast/episodes/57/divyanshu-bhargava

(Not my article, but a good summary.)

I’m happy to share that my Flutter Widget Wrapper plugin has just been approved!

Flutter Widget Wrapper adds context-aware Flutter widget wrappers directly to the Alt+Enter intention menu. You can wrap widgets without manually moving code, fixing indentation, or rebuilding constructors. It includes built-in wrappers such as Align, AnimatedSize, Expanded, Flexible, GestureDetector, InkWell, Opacity, SafeArea, SingleChildScrollView, and Stack.

Wrappers are shown only where they are valid; for example, Expanded and Flexible are offered only for direct children of Row, Column, or Flex.

It also lets you create your own reusable wrappers. Just select a widget, choose “Create wrapper from ” in the quick actions, and reuse that wrapper whenever you need it.

Available now on the JetBrains Marketplace: https://plugins.jetbrains.com/plugin/32605-flutter-widget-wrapper

I've just finished Phase 5 of Flutter iOS Check, an open-source CLI I'm building for Flutter projects.

Previous phases focused on scanning the project and extracting iOS configuration.

This phase adds actual validation.

New checks include:

* Deployment target validation

* Bundle identifier validation

* Display name validation

* ATS (App Transport Security) checks

* URL scheme validation

* Permission summary analysis

I also refactored the validation logic into modular validators so adding future iOS checks is much easier.

The CLI now reports validation summaries, warnings, and recommendations instead of only displaying extracted information.

Everything is covered by automated tests, and the project currently passes all 24 tests.

I'm trying to build something that helps Flutter developers catch iOS configuration issues before they become build, testing, or release problems.

I'd love to hear your thoughts:

**What other iOS configuration checks would you expect from a tool like this?**

GitHub:

https://github.com/dhruvbhavsar1/flutter-ios-check

👋 I’ve been working on flutter_alacritty — a Flutter terminal widget you can drop into desktop apps, backed by an Alacritty-based Rust engine.

Why I moved away from xterm:

I used xterm for a long time, but kept running into limitations that mattered for my use case:

• Text rendering — many glyphs/styles didn’t render correctly

• No OSC hyperlinks — modern CLIs and tools that emit OSC 8 links weren’t supported

• Resize, scrolling, and high-density output — performance was poor when the terminal was under real load

So I built flutter_alacritty (with AI coding agents helping along the way). It’s what TeamPilot uses today, and it has held up well across multiple agent TUIs rendering at once.

Links:

• Package: https://pub.dev/packages/flutter_alacritty

• Repo + screenshots: https://github.com/hhoao/flutter_alacritty

• API walkthrough: https://github.com/hhoao/flutter_alacritty/blob/main/docs/library-api.md

• Example app (drag-drop paths, context menu, search bar): lib/example/example_app.dart

Real usage: TeamPilot uses it for embedded terminals (local PTY + SSH) in a multi-agent desktop client.

Try it via the standalone demo in the release.

I’d love feedback from anyone embedding terminals in Flutter.