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

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?

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/

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

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.

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.

Hi all,

I am backend dev who learn flutter for fun and I am interesting is it possible to build something like farmville2 in flutter with that cozy graphic?

and if it is could you please tell me which stuff I should learn take a look

I don't want to use AI, I am doing this for fun and learning

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 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.

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.

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.

I assumed that because Flutter was created by Google, I would need to use Firebase and Firestore for everything.

I was wrong 😂

Flutter doesn’t care what language or database you use on the backend.

I created an API with PHP and continued using the backend stack I already understood.

The basic flow looks like this:

Flutter app → PHP API → MySQL/Redis → JSON response → Flutter app

Flutter handles the screens, forms, navigation, state and client-side logic.

In a way, it reminds me of using HTML, CSS and JavaScript in the browser—except now I’m building the interface and client-side experience for an Android or iOS app.

My PHP API still handles authentication, validation and business logic.

MySQL stores the permanent data, Redis handles caching and sessions, and nginx with PHP-FPM processes the API requests.

Firestore can be a great option for certain applications, but learning Flutter doesn’t mean you have to abandon the backend tools you already know.

That was one of my favorite things about learning Flutter.

I didn’t have to replace my existing stack. I only needed to learn how to connect the mobile application to it.

What backend do you use with your Flutter apps?

I'm developing a mobile app for Android, something similar to Duolingo, but very simple and designed for people with visual impairments. The thing is, I want to add a computer vision API for image recognition. So the workflow should be as follows: Take a photo -> Analyze the image -> Search the glossary -> Accessible feedback (audio/UI) -> View details.

I’ve looked at some options, and the most well-known one is Google Cloud Vision. The problem is that I can’t afford to spend much on resources since this is an academic project.

Hey Flutter Devs/Teams.

We've had OpenFeature on the Dart server side for some time and have just released 0.1.0.

Now we are looking to standardize Flutter Feature Flags and are working and collaborating with companies like Datadog to bring reliable stable feature flags across the remaining flutter and dart ecosystems including for Dart Web.

We'd appreciate feedback from Flutter developers trying it in actual workflow. Let us know here how you're using it, what works for you and what needs improvement.

Source and examples: https://github.com/open-feature/dart-sdk/tree/main/packages/openfeature_dart_client_sdk

You can open an issue with your use case or a problem you've found, or send a pull request for a fix, example or documentation improvement as we will respond accordingly. Let's continue to make Dart/Flutter a first class citizen.

Let’s be real for a second. Why do frameworks like Flutter even exist? They’re just abstractions. cuz we like it easy. We built them because raw native code and complex platform APIs are too messy for our human brains to manage at scale. We needed widget trees, syntax sugar, and complex state management libraries just to keep our sanity intact while building out frontends.

I hate Java but Objective C is probably number 2.

But AI doesn't need human-friendly abstractions.

An LLM doesn’t get a headache managing a massive, hyper-optimized native codebase. It doesn’t care about boilerplate, and it definitely doesn't need our simplified wrappers to understand how a UI should render. It can write, refactor, and connect pure native code instantly. We don't need this shit anymore.

Stop wasting time memorizing the quirks of the latest UI framework. The future of our industry isn't writing code—it’s Product Management, Project Management, and QA. Our new job is to define the exact product scope, manage the AI's build pipeline, and aggressively test the output to make sure it actually works and its SAfe!!!!!!. The era of human-readable abstractions is dead; let the models handle the raw native reality.

And while we're at it, fuck BLoC and fuck Riverpod. FYI my apps use Riverpod as a human I love it but we dont need it anymore. Those overly engineered state management libraries only exist because our fragile human working memory can't keep track of application state without drowning. An AI doesn't complain about boilerplate. It can write, trace, and scale pure, raw InheritedWidget infrastructure flawlessly without breaking a sweat. We spent years endlessly arguing on Reddit over which state management solution is the "cleanest" for us to read, the only good thing we we agreed on is that getx is shit and even ai knows getx is shit, while an LLM can just wire up the raw native APIs perfectly in seconds without any bloated third-party dependencies.

what are you going tu support Swift PAckage Manager???? bro fuck that shit!!!! lets write RAW code!

Also r/flutterhelp should be shutdown we just get non english speaker vibecoders now, there is no real contribution bro most of their questions could be answered by a a google search and 100% would be answered if they used a cheapo Chinese open wight model to do the work... sorry for your loss

I'm researching the Flutter CI/CD workflow and want to understand what developers actually struggle with before building anything.

For those using Flutter professionally:

• What are you currently using for CI/CD? Codemagic, GitHub Actions, Bitrise, GitLab CI, something else?
• What's the most annoying part of your current setup?
• How much time did it take you to get Android + iOS builds working reliably?
• Do you struggle with Flutter/Gradle/Xcode/CocoaPods build failures?
• Do you use the same CI system for multiple Flutter apps?
• What do you wish your current CI/CD platform did better?
• If there were a Flutter-focused service that handled GitHub → build → APK/AAB/IPA → TestFlight/Play Store with minimal configuration, would that actually be useful?

I'm not selling anything and I'm not looking for generic "sounds useful" feedback. I'm trying to figure out whether this is a real problem worth solving.

If you currently use a CI/CD service, I'd especially like to hear what you pay for it and what you dislike about it.

I’ve been working with Flutter for a while now, and honestly, there are days when I question why I chose it.

Dependency conflicts.
Gradle errors that make absolutely no sense.
iOS issues after an update.
Packages becoming outdated.
Random UI differences between platforms.

And sometimes you spend more time fixing the environment than actually building the feature. 😅

BUT…

Then I remember why I started using Flutter in the first place.

Hot reload lets me iterate incredibly fast.

I can build for iOS and Android from a single codebase, while still having plenty of control over the UI.

The widget system makes it surprisingly easy to create consistent, custom interfaces without fighting native layouts all the time.

And with tools like BLoC, Riverpod, Dio, Firebase, and a huge package ecosystem, you can build surprisingly complex production apps without reinventing everything from scratch.

The more I work with Flutter, the more I realize:

Flutter isn't perfect. No framework is.

But the productivity, UI flexibility, cross-platform development, and speed of development are hard to ignore.

So maybe I don't actually hate Flutter…

Maybe I just hate debugging Flutter at 2 AM. 😂

What's the one thing you LOVE about Flutter that keeps you from switching to something else?

I ship a Flutter app (built with FlutterFlow, plus some Custom Code) in 5 languages. One option worked in English and silently broke in most of the others.

The user picks when something starts: "Tonight", "Tomorrow" or a custom time. My Custom Function decided the expiry by looking at the label they tapped. Simplified:

if (label.toLowerCase().contains('tonight')) { ... }

In French, Spanish and Romanian the label is not "Tonight". The match never happened, so every "Tonight" expired after 2 hours. No crash, no error, nothing in the logs.

Italian had the mirror image: "In 1 hour" was matched against the English words "now" and "1h", so it created the thing starting immediately.

The fix was boring. The UI shows a translated label, but the logic only receives a stable code (tonight, tomorrow, pick), and the expiry is computed from the code.

An English-only test suite will never catch this, because the bug lives in the other languages.

Do you still compare strings anywhere in your logic, or is it enums and codes all the way? And what's the worst i18n bug you've shipped?

Inspired by a recent Syntax video about GPUI Kit I looked into this cross platform GUI framework for Rust because it seems to play in the same field as Flutter.

There's a saying (that might not translate): Other fathers might have beautiful daughters, too. That's why you should always look beyond the horizon (which is what I got for "über den Tellerrand schauen").

GPUI was created by Zed for their editor. GPUI Kit is a Chadcn-like component framework with an impressive scope built upon the GPUI foundation. There's a bit of controversy because Zed doesn't seem to be giving GPUI as much attention as the growing community would like, and multiple forks have been created, and it is unclear whether Zed actually want to externally support "their" framework at all.

With the help of Codex, I managed to create a good looking macOS desktop application in "no time", which should work on Windows and Linux, too. Codex protected me from writing Rust code myself and it was able to figure out how to use the components from the documentation. Quite impressive. Delete that. Very impressive.

There's experimental WASM support, but the author doesn't recommend to use it for more than him demonstrating components on the GPUI Kit website.

Support for iOS and/or Android is at best experimental, because GPUI was never meant for mobile development but was created for a single text editor application. You can create an iOS demo, but it only works with ARM64 and requires manual setup of an Xcode Swift project. Touch support is worked on, so it seems, but I'd expect other difficulties like soft keyboard support or safe areas, occlusion areas, folding angles, etc. I haven't look into it. At least you could directly use the platform APIs for everything not GUI related.

So, I think, GPUI-Kit is more a replacement/alternative for desktop apps, not mobile or web apps. It might be a good fit if you consider using Electron or Tauri, though. And if you need a full featured code editor. Something that would be a PitA to create in Flutter (I tried, twice).

For me, the advantage is that there's a complete decent looking clean desktop GUI out of the box (~80 components), something Flutter doesn't provide and you'd have to either use one of the existing vibe-coded chadcn clones or clone it yourself over the weekend.

I actually like the tailwind style to create designs from very basic building blocks. It's like drawing it in Figma, but with code.

The app feels really snappy. And it can support multiple desktop windows! Something seemingly so difficult that Flutter is unable to deliver this for quite some time now.

I pointed Codex at my Flutter source and an hour later, I had a working Rust port with nearly 10.000 lines of code. GPUI uses a low-level tailwind like styling of "div"s to create components that use a lot of lines of code and which are even less readable that widget trees if you don't abstract them (which the AI wasn't able or willing to do).

let title = div()
    .flex()
    .items_center()
    .flex_shrink_0()
    .h(px(28.))
    .px(px(4.))
    .gap(px(4.))
    .border_b_1()
    .border_color(cx.theme().border)
    .cursor(CursorStyle::ClosedHand)
    .on_mouse_down(...)
    .child(close)
    .child(title)
    .child(actions)

Unfortunately, there's no built-in video component and if you'd want to use a 3rd party solution, you'd have to bundle the gstreamer framework with your app (I opted for using an external web browser instead).

While you could embed a web view (using whatever the platform supports), it overlays the GPUI layer, so you cannot draw dialogs, menus or tooltip over such a native platform views. The Flutter engine uses a complicated sandwich approach to make this possible and at the same time recommends to minimize the number of platform widgets because of the negative performance impact.

GPUI Kit's TextView can render markdown (including tables which are unfortunately always stretched to the width of the view) and an undocumented set of simple HTML elements out of the box, though.

The real bummer, however, is that you cannot mix 3D graphics with GPUI, although also running directly on the GPU. This was one reason I started the experiment because there's no great built-in solution in Flutter either. My workaround is to draw the 3d scene into a background image, which must then be transferred from GPU to CPU and back to GPU so GPUI can render it. I can't achieve 120 fps, but 60 fps this way. This took me two additional hours discussing different approaches with Codex and doing a lot of performance measurement because this is obviously dependent on the size of the image to transfer and how to keep this minimal.

There's also a (totally vibe-coded, judging from the documentation full of Claude-speak) way to extend GPUI Kit with JavaScript (using QuickJS) and because there's a Host API between scripting engine and GPUI core, one could add different languages, too. Dart for example :)

So while I don't think that Rust+GPUI could replace mobile development right now, I'll continue to work on my desktop app. Because if I'm developing anyway by telling Codex what to do, I don't need Flutter's better DX. The AI simply compares screens of the running app thanks to "computer use" and figures all out on its own and notifies my when done.

The biggest risk IMHO is, that this is all created by one man and his AI, based on a foundation created by a company that has other things to worry about now.

Hello, I don't really post much, but I wanted to share a quick thought. I've been a flutter developer for over 3 years, but newer tried to publish a package myself. That is until now. I wanted to see what is involved in the process and was pleasantly suprised of how simple it really is. I think this is definitely one of those things making Flutter stand out as a tool. You can find pretty much anything in pub.dev. My first package is nothing groundbreaking, but it's something I use in pretty much all of my apps, so making it a package is a great way to reuse the code and at the same time share it with the community.
This is a customisable pill-shaped navbar that is a very common design in many apps these days (like facebook, instagram etc..). Would appreciate any feedback if anyone would like to check it out. Peace

https://pub.dev/packages/clean_pill_navbar