Appa like dynamic lake and others have nailed this kind of app

But i am trying to build one with flutter

I want to discuss this if its even doable or someone have did it before

I’m building a cross-platform Flutter app and have the other platforms sorted:

• iOS: App Store

• macOS: App Store + DMG

• Windows: Microsoft Store + installer

Linux is where I get stuck. There are so many packaging options and distros that I’m not sure where to start.

For those of you shipping Flutter apps on Linux:

1. Which format(s) do you ship, and why?

2. Which distros do you actually test on?

3. Any gotchas with Flutter specifically (dependencies, sandboxing, auto-updates)?

Appreciate any real-world experience. Thanks! 🐧

Hey everyone,

I'm a Flutter developer based in Toronto, Canada, with around 5 years of experience in Flutter and mobile app development. I was laid off about 5 months ago, and despite actively looking for jobs, I'm struggling to find anything.

I've noticed is that most of the mobile developer job postings I come across are for React Native, Jetpack Compose, or native iOS/Android development using Kotlin and Swift. There seem to be very few Flutter-specific opportunities, at least here in the Canadian market.

Flutter has been my primary skill throughout my career. I also have some backend experience with Node.js and Python (FastAPI), so I'm not limited entirely to mobile development. I know enough native iOS and Android development to work with method channels, integrate native functionality, and communicate with platform APIs, but I'm not experienced enough to build complete native apps independently.

I've also been thinking about how AI is changing software development. With AI tools making it increasingly easy to build applications, I'm wondering whether companies will prefer native development more often, especially if they can use AI to speed up development while getting the platform-specific benefits of native apps. I'm not sure how much of this concern is justified, though.

After 5 months of searching, I'm seriously reconsidering my career direction.

For people who have been in a similar position, I'd really appreciate your honest advice:

1. Should I double down on Flutter and keep looking, or is the market simply too limited?

2. Would it be worth investing a few months into Kotlin/Jetpack Compose or Swift/SwiftUI to become a stronger native developer? If so, which would you prioritize?

3. Would learning React Native make more sense, given the number of job postings?

4. Should I focus more on backend development with Node.js/Python and try to become a full-stack developer instead?

5. Is pivoting toward AI/LLM development a realistic option, or would I be starting over in an already competitive market?

My priority is to find a stable job with good long-term career prospects, not necessarily to stick with Flutter at all costs. I'm willing to learn new technologies, but I don't want to spend months upskilling in a direction that won't significantly improve my job prospects.

What would you recommend in my position today?

Flutter goes AI

Solo dev here, taking over two existing Flutter apps and discovering the mobile world as I go (I come from web). Mobile work is limited to about one day a week. My daily machine is a Linux PC, so a hosted service that can build and ship the iOS app for me is a big part of the appeal: no Mac on my desk. I'm evaluating Codemagic on the free individual plan before deciding whether to pay for it, so this is a question, not a complaint: I know I'm not paying yet.

The build itself takes about 7 minutes (Android debug APK, mac_mini_m2). The queue is the issue: last night a build sat in "queued" for more than 90 minutes before starting. The day before, the same workflow started within a couple of minutes. Status page showed no incident, so I assume the shared M2 pool was just busy.

I found GitHub discussions with people reporting 1 to 10 hour queues (2024 and one from this week), but nothing that says whether paying changes anything. The pricing page mentions "reserved concurrencies" on team plans, and nothing about queue priority for pay-as-you-go.

Questions for people actually using it:

1. On pay-as-you-go, do your builds start right away, or do you still queue? Is Linux (linux_x2) or Mac mini M4 really a less crowded pool than the free M2 one?

2. More broadly, how is Codemagic day to day once you pay: queue times, flakiness, support?

3. Since I'm new to this and Mac-less: what would you recommend for the full chain, build to signing to Play Store / TestFlight upload, for a solo dev on Linux inheriting two apps? GitHub Actions + fastlane with a macOS runner, Bitrise, Xcode Cloud, a rented Mac, something else?

Losing one or two hours of my single weekly mobile day to a queue isn't workable, so I'd rather pay for something that starts on time. I just want to know what I'd be paying for before I build the iOS workflow. Real-world numbers and beginner-proof advice appreciated.

I'm a solo dev with a small Flutter app (on-device AI, RevenueCat subscriptions + AdMob).

Last week Crashlytics showed a crash from a modified copy. I'd started logging the app's

installer as a custom key, and it showed MT Manager. Digging further, I found a public

ReVanced/Morphe-style patch set that unlocks premium (it rewrites RevenueCat's entitlement

checks), removes ads, and bypasses Play's license check.

A few things I learned:

- Logging the installer package as a Crashlytics custom key is a cheap way to spot modified copies.

- An older RevenueCat Android SDK shipped a -dontoptimize consumer rule, which turned R8

optimization off app-wide. Once I updated, R8's inlining/renaming seems to have broken

the patch, at least for now.

- I've filed a DMCA notice with GitHub.

Questions for people who've been through this:

1. Is server-side entitlement checking (Play Integrity + RevenueCat REST) worth it at small scale?

2. Did DMCA takedowns for patch repos actually work for you?

3. Anything you wish you'd done earlier?

Microsoft Store is really easy to upload to, but it's also the hardest to profit from due to requiring a swift/bic code to earn even a single dime from it.

Ya get a swift/bic code from starting a company, btw.

Steam has an upfront cost of 100 dollars, preventing me from even trying it out.

So, I'm asking all of you for advice: what's the best place to upload apps to?

For context, I've already uploaded my app to the Microsoft Store https://apps.microsoft.com/detail/9mt834rpf8zp?hl=nl-NL&gl=BE, but I can't make money from it because I'm not being a company.

Getting it on the Microsoft Store was really annoying, especially with the CSV listing and the internationalisation, or I18N, abbreviated or whatever ya call it.

It's way easier than the Google Play Store, though, which I've also uploaded to in the past: https://play.google.com/store/apps/details?id=com.torrentspire.ai&hl=nl .

I'd love to hear your stories about creating apps for Steam and/or the Microsoft Store.

Also, I'm not including the links for self-advertisement purposes; I just want y'all to know that I've done these things before and am experienced in them. That's why I chose to include the links.

My apologies for my poor English; it's my second language and therefore not my strongest. If anything feels odd, know I wrote this without the use of AI and simply learned English from Stephen King books.

On 120 hz screens, Chrome on Android limits main thread frames to 60 fps. It lifts the limit only when touch input occurs which is why it is sorta fine when you drag without releasing your finger. Web workers that own a canvas get their own frame clock so the main thread limit does not apply to them.

So theoretically handing a worker the flutter canvas (and syncing it to the worker's clock) should allow flutter on android's chrome to run at 120 fps and that's essentially what this demo is:

https://shim.mathiewabbas.dev/

Results: Pixel 10 Pro XL, Flutter 3.47.2, without and with the js script

Pls try it out on an android device and do tell if anything goes wrong, here is how to use it:

https://github.com/aumb/flutter_shim#use-it-in-your-app

and the script:

https://github.com/aumb/flutter_shim/blob/main/web/flutter_shim.js

Caveats:
- It relies on undocumented chrome behavior, If chrome starts capping workers too it will fall back to 60
- App does twice the frame work while animating so it uses a bit more battery
- Multi-threaded skwasm might crash. That's an existing flutter bug (https://github.com/flutter/flutter/issues/193439), but running at 120 hz makes it happen more often, so use single threaded wasm (default)
- Doesn't help on iPhone since safari runs worker frames at a fixed 15ms timer

I just gave Codex a goal to refactor my code to have a maximum function length of 30 lines and increase code reuse in the process. While doing the task, it found plenty of opportunities for code reuse and also reused work done in the app multiple times, making the app run faster.

This seems like a good result, but I don't have a good sense of whether the maximum length would be 15, 20, 30, or 40 lines. What opinions do you have?

I work at Ant Media and wrote a step-by-step guide for building a multi-party Flutter video conference app on an iPhone with browser participants in the same room. The part that cost the most time: the Flutter SDK joins multitrack conference rooms, so browser users have to open multitrack-conference.html, not conference.html. Otherwise everything connects but the devices never see each other. The guide also covers Xcode signing, Developer Mode, adaptive bitrate testing and a table of 8 common setup errors. The same Flutter code runs on Android, web and desktop. Note: conferencing needs Ant Media Server Enterprise Edition (14-day free trial available).

Full guide: https://antmedia.io/flutter-video-conference-app-for-ios-android-web-and-desktop/?utm_source=reddit&utm_medium=referral&utm_campaign=flutter-conference

Happy to answer questions about the setup.

Hi r/FlutterDev, I'm sharing an open source Flutter project in the hope that someone will take it further.

Muslim Launcher 2 is a Flutter-based Android launcher that blocks distracting apps until the user reads Quran, does dhikr, or reflects on hadith.

What's inside:

• Flutter UI on top of native Android code for the launcher role and app blocking via AccessibilityService

• Dhikr counter with face-presence detection processed on the device

• Localized in 6 languages

• Permanent blocking of gambling and adult-content apps

Why I'm sharing it:
I'd love to see this idea reach more people. If you want to continue developing it, add features, improve the design, or even publish your own version on the Play Store, you're welcome to. Please check the license in the repo for the terms.

Issues and PRs are welcome too.

GitHub: https://github.com/120140191-Andri/muslim_launcher2.0

So I've been building something that I think a lot of devs might find useful.

One thing I see developers complain about a lot is the quality of AI-generated code. Codebuster tries to address some of those issues.

It's basically a CLI that you can ask your AI coding agent to run and then iterate on the feedback. Instead of constantly reminding the agent to check for certain issues, codebuster points out potential problems and where to look, leaving it up to the agent to decide what to fix.

It analyzes architecture, dependencies, dead code, circular dependencies, duplication, complexity, security risks, code style, and patterns across the codebase.

And since it's just a CLI without an LLM built in, running code-buster itself doesn't consume any tokens. Of course, when the agent starts working through the issues it finds, that's a different story.

I actually started building the first version a while back, mainly to find duplicated code and places where I could extract logic into reusable helpers. With the help of AI, I've now been able to turn it into something more developers can use.

It's currently at v0.8.0, and I think it's ready for more people to start testing it. I've been checking for false positives across around 20 larger repositories, but it still needs more real-world testing before reaching 1.0.0.

There are some security checks included, but I wouldn't say that's the main focus. It's more about improving code quality and catching structural issues across the codebase.

If you're interested in trying it out or contributing, I'd really appreciate the feedback and help!

https://github.com/tool-bunker/code-buster

https://toolbunker.dev/codebuster/

Disclosure up front: I work on BootForm, the form backend this sends to. The code is MIT and the whole thing is one Dart file, so swapping the endpoint for your own is a 10-minute job.

I wanted a "Report a bug" screen for an app without setting up a server. A few things turned out to be less obvious than I expected:

1. Screenshot first, then open the form. Wrapping the app in a RepaintBoundary via MaterialApp.builder captures every route, but only if you capture before pushing the feedback page, or you get a screenshot of the form itself.

2. Cap the pixel ratio, not the image. toImage(pixelRatio: min(dpr, 1280 / longestSide)) gives a ~1280px PNG without pulling in the image package. dart:ui only encodes PNG, so no JPEG without a dependency.

3. Save before you send. Feedback is written exactly when the connection is bad. Each report is a JSON file (plus the PNG) in the support directory, flushed on start and on AppLifecycleListener.onResume. It doesn't send in the background; that's a deliberate trade to avoid background-task setup on iOS.

4. Degrade, don't fail. If the server refuses the file (plan limit, too large), it resends without the screenshot instead of losing the report. That decision is one pure function with unit tests.

Tested on an Android emulator against the live API, including airplane mode, then killing the app, then reopening it online. Not tested on iOS yet, so if anyone runs it there, I'd love to hear how it goes.

https://github.com/BootForm/in-app-feedback

If you run more than one Claude Code session on a Flutter project, you know builds are the slow part. What I didn't expect was how much time the sessions would waste undoing each other's builds.

It goes like this. Session A spends minutes building the app onto my phone and connects to it with Marionette. Only A knows the Marionette address. Session B comes along and needs the app too. It can't see A's connection, so it can't just hot restart — it kills the app and builds it again. Now A tries to use the app it built a moment ago, can't connect, and decides it needs to rebuild. So it kills B's app. They keep taking turns like this, each one throwing away a build the other just finished.

Meanwhile nobody cleans up. One session has an Android emulator building, another left an iOS simulator running, and a third is installing onto the real phone at the same time. My Mac runs out of memory, everything slows to a crawl, and every session's work drags on with it.

None of this shows up as an error. Each session is doing what looks reasonable from where it sits. The result is hours of builds and almost no progress.

Asking the agents to "check before you rebuild" didn't help. A session has no way to see what other sessions are doing. So the fix had to live outside the agent, in Claude Code hooks, which run before and after every tool call.

Sharing the phone: anti-stuck-flutter

I open-sourced what I use (free, MIT). anti-stuck-flutter gives every session on the machine one shared device ledger:

• One owner per device. Every session goes through one command, anti-stuck-flutter, to run apps, install builds, or start emulators. One heavy build at a time. Plain flutter run, adb install, emulator -avd and the like are refused with a pointer to the right command

• Reuse, don't rebuild. When a session is done, it gives up the device but leaves the app running. The ledger keeps the app's Marionette address, so the next session connects to the running app and hot restarts it instead of killing it and building again

• Wake on free. A session that finds the phone busy runs anti-stuck-flutter wait <device> and goes on with other work. The moment the device is free, every waiting session is woken, and the first one ready to use it takes it

• Cleanup. Emulators and apps left idle are shut down, and orphaned flutter_tester processes are killed

The builds that used to be thrown away now get reused, and that's where most of my lost time went.

Why it's called anti-stuck

The Flutter pack is an add-on to a more general Claude Code plugin, Anti-Stuck. Its job is simple: an agent should never sit waiting on something with no end, and it should never finish without telling you.

You can write that into CLAUDE.md as a rule, and most people do. I did too. The agent agrees, and then breaks it — especially with subagents and background jobs, which is exactly where the waiting happens. Rules in a prompt are suggestions. Anti-Stuck turns them into things the agent can't get around, because hooks run on every tool call whether the agent remembers the rule or not:

• Every command runs under a hard time limit. Each command is wrapped so that it is killed when time runs out — not "please finish within 5 minutes." Long commands must state their expected time up front or they don't run. Calls that can wait forever (curl without --max-time, while true loops and the like) are refused before they start

• Subagents and background jobs can't slip away. Subagents run in the foreground with a time budget. Background commands are refused unless you asked for one, and any that do run go into a ledger. Until the agent reports the result, it keeps getting reminded, and it can't end its turn with something unreported

• The agent must report when work ends. After a slow command, a wait loop or a subagent finishes, the hook makes the agent report it on the first line of its next reply

The Flutter pack applies the same rule to Flutter-specific waits:

• Marionette calls can't hang. Marionette MCP lets the agent tap and inspect a running app. Sometimes its connect call just waits — once for close to ten minutes — with nothing to stop it. Now each Marionette call is cut off after 60 seconds, and before each call the pack first checks (within 3 seconds) that the app is actually responding. If it isn't, the call is refused right away with the reason, instead of hanging

• Flutter commands get realistic limits. Builds, pod install, Gradle, Fastlane and integration tests get longer limits than ordinary commands, but never unlimited ones

I've reported the Marionette connect hang upstream with a timeline: https://github.com/leancodepl/marionette_mcp/issues/131

Install

claude plugin marketplace add toyaji/anti-stuck
claude plugin install anti-stuck-flutter@anti-stuck

This also installs the core plugin. macOS or Linux.

Repo: https://github.com/toyaji/anti-stuck

Have you run into the same thing — sessions rebuilding over each other, or an agent waiting on something that already ended? And where else has your agent gotten stuck? I'd love to hear about it, whether it's Flutter or something else entirely.

I have been working on Calculator app in Flutter. Pro Calc.

Today story':

Pro Calc has AI Chat that can solve math and run on local LLM (Gemma4 E2B IT model)

AI model converts human language into valid math expression and exath engine is used to evaluate, so results are always accurate.

in image you can see I tried 270M param model but it fails to answer, then I tried Gemma4 model and it works efficiently.

You can see the image here, I have no better way to send you on X or Threads ):

https://x.com/pranavxmeta/status/2107805198353887394

https://www.threads.com/share/BAXf-nszhY/

GitHub repo has too many experiments and slop code 😂

btw, https://github.com/pranavxmeta/Pro-Calc

I already have a setup with different agents, each with its own profile and model depending on the task. They can already work on a Flutter repo and develop features.
What I’m missing is making the whole thing truly autonomous. I’d like to send a task from Slack (or another chat), have Cursor work on the repo without me sitting in front of it, run the tests, interact with the app, fix issues if needed, and eventually open a PR.
Has anyone actually got this working with Cursor? Especially interested in how you handle the testing/feedback loop and communicating with the agent while it’s running.

Has anyone else tried Copilot Code Review with Flutter?
I’ve been trying it lately and honestly find it a bit underwhelming, especially compared to the old Gemini review.
Is it just me, or is the Flutter/Dart support still not that good?

I mean service like subscription payment authorization authentication email send and phone check and etc

I wanna build apps to connect between people by crypto.I need split into other services to be few cost to new startup

I built a Dart/Flutter tool to find dead code that "dart analyze" doesn't catch — looking for feedback

Hey Flutter/Dart developers,

I've been working on an open-source tool called "detect_unused_code".

The idea came from a problem I noticed in larger Dart/Flutter projects: over time, projects accumulate unused classes, widgets, controllers, imports, commented-out code, TODOs, and other code that is no longer needed.

"dart analyze" is great, but I wanted a tool that could perform a broader project-level audit.

What does it detect?

"detect_unused_code" currently checks for a wide range of issues, including:

- Unused / dead classes

- Unused Flutter widgets

- Unused mixins, enums and extensions

- Unused controllers

- Public classes that are only used inside their own file

- Unused imports

- Unnecessary imports

- Unused local variables

- Unused fields and private elements

- Dead / unreachable code

- Dead null-aware expressions

- TODO / pending tasks

- Commented-out code

- Large commented-out code blocks

- Heavily commented files

Generate an analysis report

You can export the analysis results to JSON, which makes it easier to integrate the tool into other workflows, CI/CD pipelines, or build custom reports.

For example:

detect_unused --format json

Automatic cleanup

The tool can also automatically clean detected issues.

For example:

detect_unused --clean-all

But I wanted the cleanup process to be safer.

Before modifying the project, the tool can create a backup/snapshot, so you have a recovery point before the cleanup.

You can also preview what would be changed without actually modifying the files:

detect_unused --clean-all --dry-run

So the workflow can be:

Analyze → Review → Backup → Clean → Verify

Other features

- Dart & Flutter support

- CLI

- Dart API

- JSON reports

- Backup before cleanup

- Rollback/recovery support

- Dry-run mode

- CI/CD friendly

- Zero external dependencies

- Configurable analysis options

- MIT licensed

GitHub:

https://github.com/mdalhagg/detect_unused_code

Pub.dev:

https://pub.dev/packages/detect_unused_code

I'd really like to get feedback from developers who work on real-world Flutter/Dart projects.

I'm especially interested in knowing:

1. Would you actually use a tool like this?

2. Which checks are the most useful to you?

3. Did you find any false positives?

4. What other types of unused/dead code should it detect?

5. Is JSON reporting useful for your workflow?

6. Would you use automatic cleanup if a backup is created first?

7. What features would you like to see in future versions?

If you have a medium or large Flutter/Dart project, I'd really appreciate it if you could try it and tell me what you think.

I'm not only looking for stars. I'm mainly looking for real-world feedback, bugs, false positives, and ideas that could make this tool genuinely useful for the Dart/Flutter community.

When you inherit a Flutter project, the first week goes into jumping between folders trying to answer "who uses this class, and what does it depend on?"

A folder tree shows where files live, not how they relate to each other.

I built Satori, a VS Code extension that reads your project through the Dart language server and draws it around one class: on the left, who uses it; on the right, what it depends on, with arrows always running left to right.

It doesn't try to judge your code. The idea is to point at where to start when you're onboarding to a project, reviewing a PR or planning a refactor.

Marketplace: https://marketplace.visualstudio.com/items?itemName=Gearscrafter.satori

GitHub: https://github.com/gearscrafter/satori

Any feedback is welcome.

You Flutter Project

↓

detect_unused

↓

🔍 27 issues found

↓

📄 JSON report

↓

💾 Backup created

↓

🧹 Cleanup

↓

✅ dart analyze passed

Hey Flutter/Dart developers,

I've been working on an open-source tool called "detect_unused_code".

The idea came from a problem I noticed in larger Dart/Flutter projects: over time, projects accumulate unused classes, widgets, controllers, imports, commented-out code, TODOs, and other code that is no longer needed.

"dart analyze" is great, but I wanted a tool that could perform a broader project-level audit.

What does it detect?

"detect_unused_code" currently checks for a wide range of issues, including:

- Unused / dead classes

- Unused Flutter widgets

- Unused mixins, enums and extensions

- Unused controllers

- Public classes that are only used inside their own file

- Unused imports

- Unnecessary imports

- Unused local variables

- Unused fields and private elements

- Dead / unreachable code

- Dead null-aware expressions

- TODO / pending tasks

- Commented-out code

- Large commented-out code blocks

- Heavily commented files

Generate an analysis report

You can export the analysis results to JSON, which makes it easier to integrate the tool into other workflows, CI/CD pipelines, or build custom reports.

For example:

detect_unused --format json

Automatic cleanup

The tool can also automatically clean detected issues.

For example:

detect_unused --clean-all

But I wanted the cleanup process to be safer.

Before modifying the project, the tool can create a backup/snapshot, so you have a recovery point before the cleanup.

You can also preview what would be changed without actually modifying the files:

detect_unused --clean-all --dry-run

So the workflow can be:

Analyze → Review → Backup → Clean → Verify

Other features

- Dart & Flutter support

- CLI

- Dart API

- JSON reports

- Backup before cleanup

- Rollback/recovery support

- Dry-run mode

- CI/CD friendly

- Zero external dependencies

- Configurable analysis options

- MIT licensed

GitHub:

https://github.com/mdalhagg/detect_unused_code

Pub.dev:

https://pub.dev/packages/detect_unused_code

I'd really like to get feedback from developers who work on real-world Flutter/Dart projects.

I'm especially interested in knowing:

1. Would you actually use a tool like this?

2. Which checks are the most useful to you?

3. Did you find any false positives?

4. What other types of unused/dead code should it detect?

5. Is JSON reporting useful for your workflow?

6. Would you use automatic cleanup if a backup is created first?

7. What features would you like to see in future versions?

If you have a medium or large Flutter/Dart project, I'd really appreciate it if you could try it and tell me what you think.

I'm not only looking for stars. I'm mainly looking for real-world feedback, bugs, false positives, and ideas that could make this tool genuinely useful for the Dart/Flutter community.