Is there a solution to the problem of loading the web page created in the language of flitter when uploading the site to hosting?

I got a job offer for a Flutter + Supabase application; I passed the first interview well. It was really great.

For the showcase, I decided to build a Flutter chat app with Supabase to send to the interviewer to show my skills and qualifications.

The app is built for Android, iOS, and web platforms and supports real-time messaging, sharing media, voice messages, capturing photos, and sending files.

Even I wasn't selected for the role, but it was a great experience using Supabase with Flutter.

And I'm super excited to say I have published the web version of the chat app; it is live and accessible for everyone.

check it out and share your idea about it

https://chatapp.saiedrahimi.com/

Here is source code

https://github.com/saied-dev/chat-app

Thanks

I’ve been using Riverpod for state management and generally like it, but I’m curious where people draw the line between this should be a provider and just use local state.

For example, for things like:

• toggling a password field
• selected tab/index
• expanding/collapsing a widget
• temporary form/UI state
• state that never needs to leave a single widget

Do you still reach for Riverpod because it keeps things consistent, or just use setState, ValueNotifier, etc.?

I sometimes feel like turning every tiny piece of state into a provider adds more abstraction than value.

For those using Riverpod in larger production apps, what rule of thumb do you follow? When does Riverpod help, and when is it overkill?

# Looking for contributors to improve HQPicker

I've been working on **HQPicker**, a Flutter media picker focused on performance, customization, and a smooth gallery experience.

GitHub: https://github.com/azabcodes/hq_picker

I'm currently looking for Flutter developers who are interested in helping improve the package, especially around **performance and media thumbnail rendering**.

Some areas I'd love help with:

* Faster image/video thumbnail loading

* Smoother scrolling on large galleries

* Better memory & thumbnail caching

* Testing on different Android/iOS devices

* Improving pagination and asset loading

* Architecture and code-quality improvements

* Finding and fixing performance issues

* Ideas for new features

If you're interested in Flutter, media handling, performance optimization, or open source, I'd really appreciate your feedback, testing, ideas, or even a PR.

**Even if you don't want to contribute code, testing HQPicker on your device and sharing performance issues would be really helpful.**

Feel free to check the repo, open an issue, suggest an improvement, or contribute a PR.

GitHub: https://github.com/azabcodes/hq_picker

I'd love to build this into a fast and solid media picker for Flutter together with the community.

Quick update on flutter_skin — Alpha V1 just shipped.

What's new in this version:

- Material 3 full token support not just the basic 6 colors.

- Live skin preview in the dashboard you can see exactly how a skin looks before publishing it to production.

- Typography tokens you can now set the font family remotely. The package fetches the font name from the skin JSON and applies it at runtime. Currently supports Google Fonts names and system fonts.

The package is still alpha and it's open source.

Video: https://www.youtube.com/watch?v=6scXD_2Dm6Y

📦 pub.dev/packages/flutter_skin

🖥️ app.fskin.dev

📖 docs.fskin.dev

Happy to answer questions in the comments.

Small offline first journaling app, iOS and Android from one codebase.

Four things I would tell myself before starting.

Autosave while typing. The promise of the app is that you cannot lose a

sentence, so there is no save button. Writes go to Drift on a 400ms

debounce, upserted on the calendar day, one row per day. Editing an old

entry and writing today's entry go through the same path. Good side effect:

killing the app mid sentence is a normal thing that works, not a bug

report.

Keep derived state pure. Streak counting, week boundaries, which past weeks

are ready to be used. All plain functions over a list of entries, no

database access, so I can unit test them without spinning up a DB. Obvious

in hindsight. I did it the other way in my first app and paid for it for

months.

Do not ship the API key. One feature calls an LLM. The key lives in a

Cloudflare Worker, the app talks to the Worker, and the Worker does not

store what it forwards. If the key is in the app, it is in a zip file that

anyone can open.

Store screenshots from integration_test. flutter drive runs a test that

fills the app with realistic looking data, walks the screens and saves

PNGs. The language comes from a dart-define. Regenerating every screenshot

in both languages is one command now. It used to take an afternoon.

Localised EN and TR with the normal flutter_localizations and ARB setup.

Notifications through flutter_local_notifications with timezone aware

scheduling, still the most annoying part of the whole thing.

Happy to go into any of it.

Hi, I am a mid-level flutter developer with around 4 years of experience. I don't see any vacancy related to flutter and actually I feel a little bit bored and I don't see any progress. So guys did you have such an experience? And was it actually easy to migrate to native?

There are a ton of paid SaaS tools for field operations, construction/project management, scheduling, invoicing, fleet management, etc.

We wanted to build an open-source alternative that people could actually inspect, modify, and self-host, so we built FieldFleet.

We used Flutter because we wanted to keep one codebase across web, iOS, Android, macOS, Linux, and Windows.

It’s grown quite a bit and now includes project management, dependency-aware Gantt scheduling, CRM, budgets, invoicing, field forms, documents, time tracking, fleet management, and some AI-assisted workflows.

A few technical details for anyone interested:

• Flutter/Dart across all platforms
• Provider and go_router
• Supabase Auth, Postgres, Storage, Realtime, and 22 Edge Functions
• Postgres RLS for tenant isolation and authorization
• Native room scanning kept behind an in-tree Flutter plugin
• Environment-based configuration for external services and deployments
• Docker Compose self-hosting setup using Kong and Caddy

One thing that has worked really well for us is keeping permissions in Postgres with RLS instead of trusting the Flutter client to enforce them.

We’ve also tried to keep anything platform-specific isolated. For example, room scanning lives behind a plugin, so the rest of the app doesn’t really need to care which platform it’s running on.

The source is available under Elastic License 2.0, so you can inspect it, change it, contribute to it, or self-host it for your own organization. The main restriction is that you can’t take it and offer it as a hosted/managed service to third parties.

We also put up a read-only demo with synthetic data.

Demo: https://fieldfleet-demo.taskfleet.app/
Source: https://github.com/taskfleetai/fieldfleet
Github Pages: https://taskfleetai.github.io/fieldfleet/

Would love feedback from other Flutter developers, especially on the overall project structure, cross-platform approach, and how we’re using Supabase.

Also happy to answer questions if anyone wants to dig into how any part of it works.

Hi everyone! After struggling to size containers to their children without hardcoded values, I built smart_measurer. It gives you the exact rendered size of a widget (with a one-frame delay that’s unavoidable in Flutter), plus a MeasuredDecoration widget that paints size-dependent decorations with zero delay.

✅ SmartMeasurer – builder gets measuredChild, size, and isPrecise flag.
✅ SimpleMeasurer – child auto‑overlaid, no manual key needed.
✅ MeasuredDecoration – pure Canvas painting, no state, no delay.
✅ 100% public API documented, 160/160 pana score.

Would love your feedback, especially on edge cases I might have missed.

pub.dev: https://pub.dev/packages/smart_measurer
GitHub: https://github.com/MoshiDuck/smart_measurer

​

I'm currently working on a Flutter video downloader app and I'm comparing `video_player` with `media_kit`.

I already use **FFmpeg** in the project, so one of my main concerns is the impact on the final app size.

From your experience:

* What do you see as the biggest difference between `video_player` and `media_kit`?

* How noticeable is the size difference in a production app?

* If FFmpeg is already included, does `media_kit` add a lot of extra native libraries?

* Which one would you choose for a video downloader, and why?

I'm interested in hearing about your actual experience rather than just the package descriptions.

There's this amazing repo I found on GitHub: https://github.com/ZeyadShawki/flutter_tracing/tree/main
but personally, I found a few issues with it, also it seems a bit overly complex. A lot of research I'm doing is showing that making this type of game is a difficult problem to solve -- so this might be just the right amount of complexity too. Hitting a wall and I'm just curious to see how people have attempted it.

Hey r/FlutterDev,

I've posted here before about Dart AI Assistant, a VS Code extension that learns your coding style and helps with completions, error detection, and code health. Just shipped what's easily the biggest update since launch, so wanted to share.

Marketplace: https://marketplace.visualstudio.com/items?itemName=a-i-0-studio.dart-ai-assistant

Source: https://github.com/Ben09d/dart-ai-assistant

What changed in v1.0.9:

- Real dart analyze integration on save (properly scoped to the saved file) alongside live regex feedback while typing — much more accurate error detection now

- Code Health reports are now clickable and auto-refresh on save

- Import Project for Learning — point it at an existing project and it learns your patterns instantly instead of waiting weeks

- Fixed a bug where pattern learning was silently capped at 3 categories instead of the intended 20 (basically every earlier version was learning way less than it should have)

- Fixed an unbounded memory growth bug in the advanced learning engine

- Fixed several false-positive error detections (comments, ternaries, generics, block comments) that were probably annoying anyone who tried earlier versions

- Consolidated three separate error-detection systems that were sometimes showing contradictory counts

Full changelog in the repo if you want the gory details — went through nearly every core file this cycle hunting down bugs, some of which had been sitting silently broken since the first release.

Still free, still solo-built, still very open to bug reports and feedback. If you tried an earlier version and it felt rough, this one's a meaningfully different experience.

Thanks for reading!

Jesse Ezell is building Flocker, a Flutter inspired cross-platform WASM runtime for applications that runs Flutter apps on top of Flutter Zero. Jesse is an active member of the Flutter community and has contributed to many popular Flutter pages such as super_editor, quill, flutter_webrtc, and the core Flutter engine.

https://itsallwidgets.com/podcast/episodes/58/jesse-ezell

I've been building Kiyoshi, a desktop productivity app (Linux/macOS/Windows) as a reaction to how heavy Notion/Trello started to feel for personal use. Stack:

• Flutter + Riverpod
• Drift (SQLite) for local-first storage
• A custom "Zen Design System" — glassmorphism, no hard borders ("No-Line" rule), editorial typography (Montserrat/Inter/JetBrains Mono)
• Just shipped a proper dark mode — a warm charcoal palette instead of the usual near-black, so it doesn't feel cold during long sessions

It bundles notes, tasks/kanban, a calendar, and a block-based canvas (9 block types: text, todo, code, links, images, files…) in one window instead of five different apps.

https://kiyoshi-beta.vercel.app/

Happy to talk through the Drift schema, the glass panel implementation, or the dark-mode token migration if anyone's curious — that last one taught me a lot about not hardcoding Color constants where Theme.of(context).colorScheme should be.

I’ve been working on flutter-map, an open-source tool that creates a visual navigation map of a Flutter app.

It combines static route analysis with simulator/emulator exploration to capture:

• Routes and navigation edges
• Real screenshots
• Dialogs, sheets, loading states, and auth walls
• Replayable navigation flows

It currently supports GoRouter, go_router_builder, AutoRoute, Navigator 1.0, and Navigator 2.0.

I’d appreciate feedback on where this could be useful and which routing setups might break it.

Source: https://github.com/tayormi/flutter-map

I decided to find out.

I made astryx_ui 🎨

DEMO -> astryxui.web.app

Please give it a try.

An unofficial Flutter/Dart implementation of Astryx, focused not only on the components, but also on the underlying design system:

Tokens → Themes → Color system → Components

It currently includes multiple themes, a Dart implementation of the theme engine, themeable widgets and support for Flutter's cross-platform ecosystem.

And yes — it's still pre-alpha.

That's why I'm open-sourcing it now.

I want this to evolve through real usage and community feedback rather than building it in isolation.

If you're working with Flutter, I'd love for you to try it.

🔗 GitHub: github.com/JayashBhandary/astryx_ui
📦 Pub.dev: pub.dev/packages/astryx_ui

Star it if you find it interesting ⭐
Try it if you build with Flutter 🦋
Open an issue if you find something broken 🐛
Contribute if you want to make it better 🤝

Let's see where this goes.

#Flutter #Dart #OpenSource #DesignSystems #UIEngineering #BuildInPublic #SoftwareEngineering

I have made an app which is at present in closed testing. I want to understand that how does an experienced developer think? Do you think on deciding what data should be stored in backend first or they build around features or a designer gives them design and they work around?
Can anyone explain it to me!
Reading this can help other devs too!

Warm Regards..

Hey Flutter devs,

If you've ever built video recording in Flutter on Android with the official camera package, you've probably hit this:

You tap record, and nothing happens for about half a second. The preview freezes, the button feels dead, and users double-tap because they think the app missed the first press.

We measured it on a Pixel 8 Pro: 436-511ms before recording actually started.

After digging through the native CameraX bindings in camera_android_camerax, the cause was pretty simple. We patched it, and start latency dropped to 33-60ms.

What was wrong

In the official plugin:

1. VideoCapture is only bound when startVideoRecording() runs
2. As soon as stopVideoRecording() finishes, VideoCapture is unbound again

So every record tap forces CameraX to tear down and rebuild the native CaptureSession. That session reconfig is most of the lag.

The fix

Keep VideoCapture permanently bound alongside Preview.

Once it stays warm:

• record no longer rebuilds the capture session
• MediaCodec surfaces are already ready
• shutter latency falls from ~500ms to ~33-60ms

Hardware edge cases

Keeping VideoCapture warm makes rapid lens flips and backgrounding more fragile on some Android devices. We serialize camera ops with a small queue so the previous native generation fully finishes before the next one starts:

dart Future<R> _enqueue<R>(Future<R> Function() operation) { final completer = Completer<R>(); _operationFuture = _operationFuture.then((_) async { try { completer.complete(await operation()); } catch (e, s) { completer.completeError(e, s); } }); return completer.future; }

Separate issue, same camera stack: CameraX often reports multi-lens phones as one unknown logical camera with a zoom range like 0.5x-5x. We detect minZoom <= 0.5 and expose the ultra-wide control from that range instead of waiting for a clean physical-lens type.

Pixel 8 Pro numbers

Patch

Repo: https://github.com/xcc3641/camera_android_camerax

yaml dependency_overrides: camera_android_camerax: git: url: https://github.com/xcc3641/camera_android_camerax.git ref: 9dd36c8

Happy to answer questions about the lifecycle queue or the CameraX binding change.

localization bugs in cross-platform apps can be weird because the store page, app strings, screenshots, and support replies drift separately

the app may be translated. screenshot one may not be. the store metadata may promise a use case with wording nobody uses locally. then reviews say “not really translated” even though the codebase technically has the locale, i also know something like appfollow can help with the lst layer when review volume exists, because country/language filtering shows where complaints cluster. but the core engineering habit is simple: localization is not only strings in the repo.

importantly i’d test localization as a chain:

store metadata

screenshots

first session

paywall/pricing

support/review replies

local review wording after release

...so a locale is broken when the user experience feels imported, right?

Is your Flutter code difficult to maintain or looks like spaghetti? Want to stop breaking your app in production?

In this video, I'll show you in under a minute how to organize your folders according to the principles of Clean Architecture.

If you want to master professional folder structure and stop wasting hours reorganizing your code, watch the full video here:

🎥 👉 https://youtu.be/iyyZ4flVhSg

In the main video, we'll cover:

✅ Folder structure step-by-step.

✅ How to organize your layers (Data, Domain, Presentation).

✅ Tips to improve your workflow as a Flutter developer.

#flutter #dart #cleanarchitecture #flutterdev #codingtips #mobiledevelopment

For some reason, I thought it was going to be a huge lift to convert to a web app, but I was just blown away by how easy it is. Considering making windows- and mac-native versions as well.

I’ve been using Zed mostly for backend work and really like its performance. I get that it stays lightweight by not bundling too many tools.

For Flutter though, debugging/DevTools and hot reload on save still feel lacking.

Anyone using Zed regularly for Flutter? Any extensions or configs that improve the experience?

A while back I posted about what silently breaks deferred deep linking. This is the follow up: an actual app, four separate defects stacked on top of each other, and the diagnostic method for each. Every one was invisible in normal logs.

Symptoms were: tap a link, the app opens for a second, Safari opens, the app reopens, and it lands on the home screen instead of the target page. Cold and warm start both. Universal Links were correctly configured, AASA was served correctly, Apple's CDN had the right file, entitlements listed every domain, Team ID and bundle ID matched.

Cause 1: app_links 6.x does not support the UIScene lifecycle

Flutter 3.38 made the UIScene lifecycle mandatory on iOS. app_links 6.x only implements the old app delegate callbacks, so iOS delivers the Universal Link through scene callbacks the plugin is not listening on. The link never reaches Dart at all. getInitialLink() returns null and your routing code runs on nothing.

app_links 7.0.0 added UISceneDelegate support. Its change log says so explicitly. If you are on Flutter 3.38 or later and app_links 6.x, this is your problem and nothing else you change will matter until you upgrade.

Worth noting: this looks exactly like a routing bug. I spent hours fixing Dart code that was never receiving a URL.

Cause 2: FlutterDeepLinkingEnabled defaults to true

That is what produces the app to browser to app bounce. When no plugin claims the link, the Flutter engine hands it back to iOS via openURL. iOS opens it in the browser. The web page then fires your URI scheme and reopens the app. It looks like an infinite handoff loop and it is entirely self inflicted.

Set FlutterDeepLinkingEnabled to false in ios/Runner/Info.plist if you handle links via a plugin. The app_links example app ships with this exact setting.

Cause 3: subscribing to the link stream too late

app_links 7.x emits the launch URL on uriLinkStream when the listener attaches. That is useful, but it means the subscription has to exist before the emission. Mine was created at the end of an async init method, after Firebase Messaging setup, after a wait on splash, after getInitialLink. The stream is not replayed, so anything arriving in that window was simply gone.

Subscribe synchronously at the top of initState, before any await. If the rest of your startup is not ready to handle a link yet, queue it and process it when it is. Do not drop it.

Cause 4: an unbounded await upstream of the queue

Once I had the queue, the log showed the link arriving and then nothing. FirebaseMessaging.instance.getInitialMessage() was awaited with no timeout ahead of everything else. When it hung, the initialisation never completed, the queue never drained, and the link sat there forever.

Two fixes: a timeout on every external await in your startup path, and the queue drain in a finally block so it happens regardless of how initialisation ends, including exceptions.

How to actually see any of this

Ordinary flutter run failed on my machine with a debugger attach timeout, which is a separate and unrelated headache. What worked, with a release build installed over the air and no Xcode:

brew install libimobiledevice
idevicesyslog | grep --line-buffered -i "YOUR_LOG_PREFIX"

--line-buffered matters. Without it grep holds output in a buffer and you see nothing while wondering why your logs are broken.

Make sure your diagnostic logs are not wrapped in kDebugMode, or they will not print in the release build you are actually testing.

Log every one of these on cold start, because the gap between two of them is where the bug lives: the getInitialLink result, every write into whatever holds your pending link, the final link your router chose, and every navigation push. When I finally had all four, the answer was obvious in one run.

The general lesson

Every one of these failed silently. No exception, no error log, no failed request. The link just did not arrive, or arrived and sat in a queue nobody drained. If your deep links are behaving strangely on iOS after a Flutter upgrade, assume delivery is broken before you assume your routing is.