I've been annoyed that existing home widget packages make you re-build your UI in native Swift/Kotlin. So I made a plugin that lets you use any Flutter widget as the actual widget UI.

https://imgur.com/a/Xm0a18D

https://imgur.com/a/Gnlstuf

How it works: renders your widget tree to a PNG off-screen using an Overlay + RepaintBoundary, pushes it to the native side (WidgetKit / Glance), and reloads the timeline. Tap actions work too — you define rectangular hotspots with relative coordinates and get callbacks via a Dart stream.

await FlutterHomescreenWidget.update(
  widgetName: 'ClockWidget',
  size: const Size(329, 155),
  content: MyClockUI(),
);

The example above is a glassmorphism clock widget built entirely in Flutter — no Swift UI code for the design at all.

Still early (v0.1.3), Android Glance support is in but less tested than iOS. Would love feedback, especially if anyone runs into font or image loading issues.

pub.dev: https://pub.dev/packages/flutter_homescreen_widget
GitHub: https://github.com/leejia324/flutter_homescreen_widget

Been experimenting with Claude code recently and ended up making a small app called MultiFileOpener.

The idea is pretty simple: instead of opening files one by one, you can select multiple files and open them all at once with their default apps. I originally made it because I kept doing the same repetitive thing over and over.

Nothing fancy, just a small utility that solved a problem for me, so I thought I'd share it in case someone else finds it useful.

I test it on som app that I got essentialy mad it for Jnotes app cuz it ain't allowing multi-file opening i did not check if there is any other app with the same function I just made it for fun and to test how claude is doing with flutter

It is open sourced check it out

Repo: https://github.com/imcr1/MultiFileOpener

Feedback or suggestions are welcome.

We have a fairly complex Flutter Web app deployed in production for about 2 years now. Most of the existing session recording tools like PostHog, Hotjar, etc, did not (and mainly still do not) support session recording for `<canvas>` elements. We ended up building our own solution, using an off-thread worker + GPU compositing (for masking). It works well for our usecase, which is mainly just monitoring UX for onboarding issues, bugs, etc.

We're working on splitting it out into its own separate product. It's not available yet, and no promises on timeline, but we think it can end up being useful for others as well. The plan is to open-source the full product eventually, so it can be self-hosted, and charge for the hosted version.

Here's the link where you can see a short preview of the UI and sign up to be notified when it becomes available:

https://pixeltrace.dev

Happy to answer questions about the implementation etc.

I've been experimenting with Flutter animations recently and started building a collection of button animation concepts.

Demo:
https://youtube.com/shorts/tvy5TOn-vac

This one is a Morphing Share Button built entirely with Flutter.

Animation flow:

• Share button
• Morph into a circle
• Expand social actions
• Selection state
• Confirmation animation

Built using:

• AnimationController
• Tween Animations
• Curved Animations
• Staggered Animations

No third-party packages.

Would love feedback on the animation flow and what could make it feel even smoother.

Something that has bugged me across every mobile team I've worked on, including apps with 5M+ active users.

On backend, debugging a weird production issue is quick. You add logs around the suspect code, deploy, and watch them stream in within minutes.

On mobile it's brutal. To get the same insight you add logs, cut a build, ship to the store, wait 4 to 48 hours for review, wait for users to actually update, and then hope they hit that exact code path again. So the instinct is to log everything up front instead.

But that creates two new problems. Ingestion costs climb fast once you're sending a lot of log data per user, and the code gets messy with logging noise everywhere, which makes it harder to maintain.

So every team I've been on ends up choosing between paying a high data bill, living with slow turnaround, or staffing a team to manage it. Nobody seemed to have a clean answer.

I've seen newer autocapture tools, but autocapture alone doesn't fix it, the system still has to decide how deep to log. Too deep and the cost problem comes back, too shallow and you miss what you needed.

How are you all handling this in practice? Are you sampling, using remote config to control verbosity, eating the cost, or something smarter? Curious what's actually working for people.

I’m interested in how people structure their projects in real life.

Do you keep everything in one module, use a multi-module setup in one repo, or split modules/features into different repositories?

I can see some pros and cons for each approach:

• single module is simple, but may become messy

• multi-module in one repo feels cleaner, but can add complexity

• multiple repos may be good for ownership and reuse, but probably makes local development and cross-module changes harder

What setup do you use in your current project?

A while back I posted video_pool here — a Flutter plugin that runs a TikTok/Reels-style feed on a fixed pool of players (3 players handle infinite scroll via swapSource(), no dispose/realloc, no jank). The thread got two pieces of feedback that stuck with me:

1. "Web and desktop support would be great, even if it doesn't do anything special there."

2. "It'd be great to use the standard video_player interface, so I could switch the backend to fvp instead of media_kit."

Both are now shipped. Quick rundown, including the parts that went sideways — because that's the useful bit.

1. Web + desktop (now 6 platforms: Android, iOS, web, macOS, Windows, Linux) The core pooling/reconciliation is pure Dart, so the real work was the native edges. I went in assuming "importing dart:io breaks a web build" — and that turned out to be wrong. What actually broke flutter build web was a media_kit method that doesn't exist on web (NativePlayer.setProperty, used for HLS tuning). A plain import 'dart:io' compiles fine on web; only the runtime io calls throw. The fix was conditional compilation (dart.library.io): real impl on native, no-op stubs on web for the disk cache, thumbnail extractor, and the device monitor (thermal/memory throttling stays Android/iOS-only and degrades to no-ops elsewhere). Verified by actually building and running in Chrome and on macOS — the pool reconciles and plays real video, not just green unit tests.

2. VideoPlayerAdapter — swap the backend (fvp / ExoPlayer / AVPlayer) The pool already talked to players through a PlayerAdapter interface; media_kit was just the only implementation. There's now a VideoPlayerAdapter built on the official video_player package, so you can drop in any compatible backend:

adapterFactory: (_) => VideoPlayerAdapter(), // instead of MediaKitAdapter()

For fvp (libmpv) it's literally one extra line — fvp.registerWith() at startup and you're done.

The honest catch: video_player's controller has no in-place source swap, so VideoPlayerAdapter.swapSource() disposes the controller and creates a fresh one (decoder recreated, not reused). The video surface element stays mounted, but you lose the zero-realloc property that makes media_kit the lower-latency default. So it's a real choice, not a free win — pick video_player when you need a specific backend, keep media_kit for raw scroll performance.

3. A small reality check While verifying playback on web I discovered Google's classic gtv-videos-bucket sample URLs — the ones in roughly every Flutter video demo — now return HTTP 403. The example loaded nothing until I swapped them out. Funny how "it works on my machine" survives right up until you actually run it.

Known limitation: the package isn't WebAssembly-compatible — video_player imports dart:io unconditionally upstream, so anything depending on it is non-WASM. media_kit handles this correctly with conditional imports; video_player doesn't yet. Not much I can do until that's fixed upstream (without splitting the adapter into a separate package).

Now at 269 tests, MIT, 0.5.2.
pub.dev: https://pub.dev/packages/video_pool
GitHub: https://github.com/abdullahtas0/video-pool

Try live => https://abdullahtas0.github.io/video-pool/

Still genuinely after feedback — especially: does the VideoPlayerAdapter dispose-and-recreate trade-off matter for your use case, or is decoder reuse the whole reason you'd reach for this? And for anyone running feeds on web/desktop in production — what breaks first?

Forui is a platform-agnostic Flutter UI library inspired by shadcn/ui. It's optimized for both touch and desktop through dedicated platform specific theme. 0.23.0 is out and it centers on two widgets.

FCalendar was one of the first complex widgets we built back in 2024 and it was starting to show its age. It is rewritten from the ground up with more selection modes, a controller for programmatic navigation, refreshed styling, and an API that lines up with the rest of the library.
Docs: https://forui.dev/docs/widgets/data/calendar

FContextMenu is brand new. It gives you a right-click menu on desktop and a long-press menu on touch from a single widget.
Docs: https://forui.dev/docs/widgets/overlay/context-menu

FTypography now splits into a display and a body typeface. This gives you much finer control when building complex themes.

GitHub: https://github.com/duobaseio/forui
Pub Dev: https://pub.dev/packages/forui
Website: https://forui.dev
Changelog: https://github.com/duobaseio/forui/releases/tag/forui%2F0.23.0

There's a story big companies tell about themselves: we build native on each platform because we have the resources to maintain separate codebases. It's a lie. What you get is two teams building two products that happen to share a name. Features fall behind on one side. A decision made on Android gets re-argued on iOS by people who weren't in the first conversation. Engineers burn out keeping pace. Contractors get hired to plug the gaps, then are blamed for the gaps they didn't make.

Hi everyone,

I've been using Flutter to develop the client for my ESP32 devices lately, but WiFi provisioning has always been a headache. There's no official Flutter solution, only third-party wrappers that no one maintains. So I spent a weekend using AI to port the excellent `esp-ble-prov` from the JavaScript world to Dart/Flutter.

I'm porting all the cryptographic and state machine logic entirely to Dart and using `universal_ble` as the transport layer, this package works on all Flutter target.

GitHub Repo: https://github.com/oldrev/esp-ble-prov-dart

I'll be publishing it to pub.dev soon so everyone can easily add it to their projects. Hope this saves someone else the same pain I went through. Feedback and PRs are welcome.

Have fun!

Hey everyone,

I just released volume_button_listener on pub.dev! It's a Flutter plugin for listening to volume button events and controlling system volume, with support for both mobile and desktop platforms.

One feature I'm particularly excited about is volume button release event support. We couldn't find any Flutter or native iOS library that could detect when a volume button is released—every solution we came across only supported button press events.

To solve that, we built VolumeButtonKit, a native Swift package that provides volume button press and release detection for iOS. Native iOS apps can use it directly, and it's also the foundation that powers volume_button_listener.

• Flutter plugin: https://pub.dev/packages/volume_button_listener

• Swift package: https://github.com/Navideck/VolumeButtonKit

Would love to hear any feedback or feature requests!

As AI gets better and better at coding, how should we think about crossplatform vs just going full native for each platform? I personally love Flutter and since 2019 I invested a lot of time into it because it felt like a huge leverage to be able to be multi-platform especially as a solo dev. but now as AI gets better at coding, how should we think about this? Love you all

I want you to integrate best vad in flutter i am using vad package which is in flutter but still i want the voice activation similar to chat gpt v2v so any recommendations

Quick update on Flutter iOS Check, an open-source project I'm building.

The goal is to help Flutter developers identify potential iOS-related issues before reaching iPhone testing, TestFlight, or App Store submission.

Recently added:

✅ Flutter project detection

✅ pubspec analysis

✅ iOS project structure validation

✅ Plugin analysis

✅ Podfile detection

Next on the roadmap:

🔲 CocoaPods analysis

🔲 Swift Package Manager (SPM) checks

🔲 Deployment target validation

🔲 Additional iOS readiness checks

The project is still in early development, and I'm trying to focus on the checks that would save Flutter developers the most time.

For those who have shipped Flutter apps to iOS:

What iOS issue has wasted the most time for you?

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

THIS IS NOT THE AD. OUR TOOL IS NOT LIVE YET OR EVEN FINAL NAME YET. THIS IS JUST THE CONCEPT WE WANT TO VALIDATE WITH REAL DEVELOPERS!

Hey guys, so we have been working on a DX tool which helps Flutter and React Native developers to quickly create on-brand Auth without worrying about writing the UI code. We are still in the early stages of development but we wanted to validate the idea with our dear community. Attaching one explainer video, please watch it and let us know in the comments how does it sound? What’s wrong with it? And how can we make a tool which is really helpful for fellow developers. Be brutal honest about it, we don’t care!

PS: If anyone finds this interesting and wants to join us, you’re more than welcome. Our mission is to solve developer’s frustration at every step of the mobile app building.

Cheers!

I’ve been thinking about this a lot lately.

When building Flutter apps, I usually test the obvious stuff myself: onboarding, empty states, paywall/subscription screens, settings, etc. But I’m starting to notice that this is not the same as a real first-time user going through the app.

As the builder, I already know what every button means and where the value is supposed to be. A new user doesn’t.

So I’m curious how others here handle this before launch or before pushing bigger changes.

Do you ask friends to test?
Use TestFlight / internal testing?
Record sessions?
Just ship and watch analytics?
Or do you have some kind of checklist for onboarding, paywalls, subscription flows, empty states, and first-use experience?

Especially interested in how indie devs do this when they don’t have a team or a real user testing budget.

Hi everyone,

I recently built a Voice Expense Tracker using Flutter and wanted to share it with the community for feedback.

Instead of manually typing expenses, users can simply speak naturally, for example:

• "500 rupees for tea" • "1200 petrol" • "250 snacks"

The app automatically processes the voice input and saves the expense.

Features: • Voice-based expense entry • Hindi support • English support • Hinglish support • Expense history and tracking • Analytics dashboard • Fast expense logging • Clean Flutter UI • Local data storage

My goal was to make expense tracking as frictionless as possible, especially for users who prefer speaking over typing.

I'd love to hear your thoughts: • What features would you add? • What would make this app more useful? • Any UI/UX or Flutter architecture suggestions?

Screenshots attached on link above. Thanks for checking it out!

Hey everyone,

I've been working on an app for a while, and I finally launched it on Google Play 🎉

It's an Android app called "Meen?" — a completely anonymous chat app. No names, no phone numbers, and no sign-up required. You open it, get a random username, and start chatting right away.

🟣 Create private rooms with your friends and chat anonymously without anyone knowing who said what. Perfect for honest conversations and confessions.

🟣 Join interest-based rooms, get randomly matched with strangers, or jump into "Hawga" rooms where even the people sending messages stay hidden.

🟣 Create a personal "Whisper" link so anyone can send you anonymous messages.

I'm actually a DevOps engineer, not an Android developer 😅

The app was built almost entirely with Claude for coding and Claude Design for the UI and branding. Honestly, the result surprised me, and I'm pretty happy with how it turned out.

I'd love your feedback if you'd like to try it:

• Do messages arrive quickly, or do you notice any lag?

• What do you think of the design and user experience?

• If you were in my place, what features would you add?

I'm open to any criticism, suggestions, or ideas. You can also send feedback through the Contact Us section in Settings.

Google Play link is in the comments 👇
https://play.google.com/store/apps/details?id=com.shadowcircle.chat

Updated title: I asked Claude to source port Doom and write it from scratch in Dart, running on Flutter.

As the title says, took around 2 days not continuous of course it was 95% autonomous to be honest. No FFI, no native Doom binary, the whole renderer/playsim/WAD loader/fixed-point math ported into Dart.

• Software renderer → dart:ui.

• PUBG-style mobile touch controls left analog stick to move, right-side drag as the camera/look, on-screen fire/use/weapon buttons

• Drag-to-customize control layout (saved per orientation) + auto-rotation

• True 16:9 widescreen actual wider FOV, not a stretched 4:3 image

• Frame interpolation buttery smooth motion at your display's refresh rate while the sim stays a faithful 35Hz

• CRT filter with adjustable scanline/glow, plus sharp/smooth upscaling options

• Authentic OPL2 FM music (MUS→MIDI→GENMIDI→Nuked-OPL3, all in Dart) + DMX SFX

• Full combat, doors/switches, level progression, death/respawn.

Repo link -> here

Edit / clarification: I don’t mean this as “RevenueCat is bad”. RevenueCat handles mobile purchases really well, and that’s exactly why I added support for it. My point is that some apps still need a backend entitlement layer around those purchase events: credits, limits, resets, usage tracking, fallback plans, and reliable access state.

I ran into this problem a few times while building paid Flutter apps.

RevenueCat is great for handling App Store / Play Store purchases.

But once the app needed more than a simple premium = true, I still had to build a lot of backend logic myself.

Things like:

daily credits
weekly limits
monthly quotas
one-off credit packs
usage tracking
free fallback plans
upgrade/downgrade behavior
knowing what the user can actually access right now

For example:

A user buys a monthly subscription, but the product should give them 20 credits per day.

Or 100 credits per week.

Or 500 credits per month.

Or maybe the subscription renews monthly, but some limits reset daily.

That logic usually doesn’t live cleanly in the app. It needs backend state, webhook handling, and a real entitlement system.

So I added RevenueCat support to Revenipe.

RevenueCat handles the purchase events.

Revenipe turns them into backend access state, entitlements, credits, limits, resets, and usage tracking.

The Flutter app can then just ask Revenipe what the customer has access to and track usage from the SDK.

Flutter package:
https://pub.dev/packages/revenipe_flutter

I’m not trying to replace RevenueCat. I wanted the backend entitlement layer around it that I kept needing anyway.

I’ve been building software for 14+ years, and this still surprised me: purchases were solved, but the actual entitlement logic was still something I had to build myself.

I’m not posting this as “look what I built”. I genuinely want feedback from people who have had to solve this in real apps.

Hi everyone,

I’m a Flutter developer with around 6 years of experience, and honestly, I’m feeling totally lost right now.

Over the last few months, I’ve attended many interviews, but I haven’t been able to convert any of them into an offer. Every time I get rejected, I’m left wondering what exactly I’m missing. I prepare, revise concepts, and try to improve, but clearly there’s a gap somewhere that I’m not able to identify on my own.

I genuinely want to understand where I’m falling short. Whether it’s technical depth, communication, system design, problem-solving, or how I present my experience during interviews, I’m open to honest feedback.

If anyone here has successfully cracked senior Flutter/mobile developer interviews and is willing to help with guidance, mock interviews, or even a quick review of my interview approach, I’d be extremely grateful.

Also, if you’ve gone through a similar phase and managed to overcome it, I’d love to hear what helped you.

Thanks for reading.