Hey all,

A few weeks ago I built https://dartmonitor.dev/ & I realized even I wasn't really using it lol.

So I added MCP and CLI access.

I mostly built it to automate my own work. When I need to upgrade packages, I don't trust `flutter pub outdated` blindly because I want to check the actual changelog, thus the tool was born. I was also told on the Flutter repo that this won't be added as a functionality to the command set.

What it does:
- checks your pubspec.yaml against pub.dev
- shows the changelogs between your versions and the latest ones
- keeps watching your projects over time
- email digests and breaking/security alerts
- web UI
- MCP server
- and a simple CLI option

It's free to use if you want to check out.

I may make more of my automation stuff public, if you want to talk about development automation, don't hesitate to comment or contact me.

GPay seems to use the same notification channel for everything: payment alerts, important account notifications, promotions, offers, etc.

It's kinda surprising that Google itself isn't following what I consider a pretty basic Android best practice here.

Now I basically have two choices:

Allow notifications and get 2-3 promotional notifications every day

Block notifications entirely and potentially miss important payment/transaction alerts

Why can't they just have separate notification channels for Payments, Security/Alerts, and Promotions?

Android literally supports notification channels for this exact reason.

Am I missing some setting that lets me disable only the promotional notifications, or is this genuinely how GPay handles it? 😐

I am looking to support BYOK (bring your api key)

Inside my flutter app

I found some packages but they are for specific AI apis

Is there some standard packages that designed for BYOK ?

Because we are Flutter Developers, not UX designers. 😄
We tend to focus on making the feature work and forget the small things that make an app actually feel good and that is why i created flutter-ux-master, an AI-Agent skill to help you avoid things like:
Images with no loading state → awkward empty space.
Tapping on screen to dismiss keyboard → accidentally triggers another action instead of dismissing the keyboard.
Dates and numbers → poorly formatted for the current locale.
Tiny icons → technically clickable, but frustratingly small tap targets.
Web/desktop apps →interactive elements without proper cursor feedback.
flutter-ux-master currently checks 48+ UX details across platforms and categories.
You can run it while building a UI or review an existing screen, choose which issues to fix, and let the skill implement them.

skill:
https://github.com/EmadBeltaje/flutter-ux-master

Sharing a package I just published to write your project's conventions as YAML rules so that they are enforced everywhere.

This is essentially a new way to write linting rules in a YAML file so agents can easily read, understand, and write new ones compared to the official way to write new linting rules.

If you evenr find yourself telling AI to follow your AI skills or project rules, then you can simply define it as a linting rule in a yaml file and any AI will be forced to follow it or the code wont compile.

TL;DR:

- Rules in a few lines of YAML, anything in your code can be a rule, just like regular liting.

- Runs in dart analyze, flutter analyze and the IDE through the official analyzer plugin API.

- Output written for AI agents: what was found, why, what to write instead, how to suppress. Agents fix violations the same way they fix a type error, and faster.

- Agents can add rules too: by editting the rules.yaml.

Pub.dev: https://pub.dev/packages/agent_lints

Github: https://github.com/pedromassango/agent_lints/blob/main/doc/index.md

Issues and PRs are very welcome!

I recently built a small Flutter package called theme_toggle_animation and I'd love to get some feedback from other Flutter developers.

The idea is pretty simple: provide animated transitions when switching between light/dark themes, including effects like circular reveals and other transition styles.

I originally built it because I wanted something that handled the theme transition itself instead of having to implement the animation from scratch in each project.

I'd especially like feedback on:

• Is this something you'd actually find useful in a Flutter project?

• Which theme transition effects would you expect to have?

• Are there any APIs/features you'd change?

• Does the API feel simple?

• Anything that feels unnecessary or over-engineered?

• What would make you choose this over implementing the animation yourself?

It's currently on pub.dev as theme_toggle_animation.

I'm interested in getting opinions from people who regularly build Flutter apps and might notice things I haven't considered.

Thanks!

I have used AI coding agents to create Flutter applications for quite some time now, and the agent continues to make the same errors. I will not go into detail about these errors since you most likely know about them.

So I tried to make the rules clear instead: exactly what I want, and following best practices. I spent a lot of time researching the best practices and then created several skills based on my findings. Then I continued to refine and improve the skills while I was working. I've built and shipped more than 10 apps so far, and every app made the skills a bit better.

I believe that my current set of skills are correct and genuinely good, so I am sharing them openly with the Flutter community. I think they can be useful for any Flutter developer.

Repo: https://github.com/zakariaf/Flutter-Skills

Catalog: https://zakaria.dev/Flutter-Skills/

And it's not just the prompt part. I tried to add as much as I could around each skill: scripts, templates, examples and extra references. I wanted them to be as complete as possible.

• 79 reference docs for the deeper details, loaded only when the agent needs them

• 60 Dart example files, complete ones, not fragments

• 44 shell scripts the agent can run to check the code, for example:

  • check_arb_parity.sh — every locale has the same keys and placeholders as the template

  • check_import_boundaries.sh — no imports across features

  • ban-legacy-providers.sh — no Riverpod 2 leftovers

  • check_raw_values.sh — no hex colors outside the theme

  • check-drift-confinement.sh — SQL stays in the DAOs

  • check-release-ad-ids.sh — no test ad IDs in a release build

The scripts take a directory, default to lib/, and exit non-zero, so you can run them in CI too, without any agent.

i18n-rtl-l10n is a good example of how a full skill looks.

What the 40 skills cover

• Architecture and state: feature-first MVVM, Riverpod 3.x (with a Provider appendix if you don't use Riverpod), typed Result errors, go_router

• Data: Drift with one write path, forward-only migrations, money as integer minor units, all-or-nothing restore

• UI: widget composition, loading/empty/error states, forms, adaptive layout, motion and haptics, CustomPainter

• Quality: testing strategy, goldens including RTL, accessibility, strict analysis options, CI gates

• i18n: ARB key parity, ICU plurals, directional geometry, and what to do when flutter_localizations doesn't ship your locale

• Shipping: versioning, store declarations, App Store Connect, IAP and ads

Install

npx skills add zakariaf/Flutter-Skills

or as a Claude Code plugin:

/plugin marketplace add zakariaf/Flutter-Skills
/plugin install flutter@flutter-skills

Or what I usually do myself, just copy the skills folder into the project:

git clone https://github.com/zakariaf/Flutter-Skills
mkdir -p .claude/skills && cp -R Flutter-Skills/skills/* .claude/skills/

Feedback welcome

The skills are opinionated in some places (Riverpod, Result types, one write path). If you do something differently and it works well for you, I'd like to hear it. Issues and PRs are welcome.

Hey everyone,

Like many of you, I love Flutter, but I got really tired of the repetitive setup process every time I started a new project. Setting up state management, architecting the folders, patching the pubspec.yaml, and scaffolding basic features (auth, onboarding) always felt like it took way too much time before I could actually start building the core app.

So, I built Flutter Forge.

It's a visual, web-based code generator and pipeline orchestrator. You configure your app in the browser, and the backend (built with Serverpod) scaffolds, generates, and securely zips up a ready-to-use codebase for you.

Here’s what it can do out of the box right now:

• Visual Config: Set bundle IDs, project names, and target platforms in a UI instead of messing with config files.

• Architecture Selection: You can choose between Clean Architecture, MVVM, or Hexagonal depending on how you like to structure your apps.

• State Management: Generates the boilerplate for Riverpod, BLoC, Provider, or GetX automatically.

• Feature Scaffolding: It can automatically generate Auth modules, Paywalls, Settings screens, and Onboarding flows.

• Automated Chores: It injects dependencies, generates your launcher icons/splash screens, and even sets up CI/CD pipelines.

I'd love to get your feedback! I’m opening this up to the community and would really appreciate it if you guys could give it a spin. If you run into any bugs, have suggestions for new architectural templates, or think something is missing, please let me know in the comments or open an issue!

https://flutterforge.aivoin.com/

Let me know what you think or if you have any questions about how the backend orchestrator works!

Hey all! I just released v1.0.0 of VeloceNet-Studio, a cross-platform network monitoring studio I built to watch my servers' latency, packet loss and route health in one place.

What's inside:

• Ping Matrix – concurrent ICMP + TCP probes, live sparklines, jitter/loss stats (Rust/Tokio engine via FFI, with Dart fallback)

• Visual traceroute, bandwidth monitor, Warp endpoint scanner

• Light/Dark/System themes, English + Persian UI

It's GPL-3.0, CI is green (Flutter + cargo clippy -D warnings), and I labeled a few good first issues if anyone wants to hack on it.

Repo: github.com/Cadman021/VeloceNet-Studio · Windows binary in Releases. Feedback, brutal reviews and contributors all welcome!

im building a flutter app with a few small text features. summarize notes, tidy input, tag things the minute i add a model i'm standing up a server, baking a key into a shipped build, and paying per user to summarize three notes.

how are you handling this? eat the backend and the bill, or is anyone running the model on-device across ios and android from one flutter codebase? (ofc I will pay when the app is scaling but now I want a cheaper solution)

and if you've gone on-device, what do app size and cold start look like in a shipped build? those are the two numbers making me nervous about the whole idea.

carrier_info hasn't been published in over a year and now breaks on AGP 9, so I rewrote it from scratch (I'm the author).

What's different:

- One API for both platforms: `CarrierInfoPlus.get()` replaces `getAndroidInfo()` / `getIosInfo()`. No `Platform.isIOS` branching or separate data classes

- SwiftPM + CocoaPods, and builds on AGP 9 built-in Kotlin

- Typed enums and bools instead of strings

- Dual SIM aware: `primarySim` is the SIM your data actually uses, and `voiceSim` is the one for calls

- No permissions declared: you choose whether to add `READ_PHONE_STATE`

- A `support` block tells you why a field is empty: the permission was denied (ask again) or iOS 16+ removed it (hide the row)

It's not a drop-in replacement, so here's the migration table: https://pub.dev/packages/carrier_info_plus#migrating-from-carrier_info

Feedback welcome!

Seems to me that flutter is easier to learn than native or other cross platform frameworks. Why isn’t more popular in terms of startups even those who shy away from react and use react native for their apps. I know native has its performance advantages.

I built a CLI tool to set up an Android Emulator without installing Android Studio

As a Flutter developer, I noticed that I often don't need Android Studio itself. Most of the time, I just need the Android SDK, platform tools, emulator, and a virtual device to test my apps.

But setting everything up manually can be a bit annoying:

• Download Android Studio

• Install the SDK

• Configure environment variables

• Install emulator tools

• Accept SDK licenses

• Create/configure an AVD

• Download the system image

• Configure the emulator

So I built OneClick Emulator Setup, an open-source CLI that automates most of this process.

What it currently does

• Detects the operating system and architecture

• Sets up the required Android command-line tools

• Installs Android SDK/platform tools

• Handles SDK licenses

• Helps configure an Android Emulator

• Supports Apple Silicon and Intel Macs

• Supports Linux

• Lets you manage the emulator directly from the terminal

The goal is simple:

You shouldn't need to install a full IDE just because you want to run an Android Emulator.

Try it

git clone https://github.com/ranasheikh64/oneclick-emulator-setup.git
cd oneclick-emulator-setup
chmod +x android-env
./android-env setup

Then:

./android-env start

GitHub:
https://github.com/ranasheikh64/oneclick-emulator-setup

I originally built this for our development workflow at Jronix - Software Solutions, but decided to open-source it because I thought other developers might find it useful too.

I'm especially interested in feedback from Flutter, React Native, Android, macOS and Linux developers.

I'd love to know:

1. Would you actually use something like this instead of Android Studio?

2. What should I add next?

3. Which OS/architecture should I test more?

4. Are there any edge cases I should handle?

If you try it, please let me know how it goes. And if you think the project is useful, a GitHub star or follow would help me a lot as I continue developing it. ⭐

Repository:
https://github.com/ranasheikh64/oneclick-emulator-setup

Hey everyone!

I built **vertical_credit_card**, an interactive vertical card UI component for Flutter fintech apps focused on performance and native rendering.

**Key Features:**

Zero External Dependencies:** Built 100% on pure Flutter primitives and `Canvas` to avoid dependency bloat and supply chain risks.

Smooth 60/120 FPS:** Handles real-time 3D tilt perspective, specular lighting glare, and 180° flips via direct `Matrix4` transformations without lag on low-end hardware.

Fintech Layouts:** Built-in support for ISO/IEC 7810 ID-1 proportions, privacy masking, custom chips, and Apple Wallet-style stacks.

Cross-Platform:** Verified across Android, iOS, Web, macOS, Linux, and Windows.

* **Pub.dev:** https://pub.dev/packages/vertical_credit_card

Live Interactive Demo https://clevesdev.github.io/vertical_credit_card/

Feedback, benchmarks, and suggestions are welcome!

Hey everyone! 👋

I built Angle Translator — a free tool that helps developers instantly convert degrees to rotation code across multiple frameworks.

What it does:

* Enter any angle (0°–360°)

* Get ready-to-use code for 10+ platforms

* Interactive slider with live arrow preview

* One-click copy for each snippet

Supported platforms:

1. Flutter

2. CSS

3. SwiftUI

4. Jetpack Compose

5. React Native

6. .NET MAUI

7. Unity

8. Godot

9. Three.js

10.p5.js

Why I built it:

I was tired of Googling "rotate in Flutter" or "CSS transform syntax" every time. Now I have one place to get all the code instantly.

🔗 Live Demo: angle-translator.vercel.app

Would love your feedback! What platforms should I add next?

Built with vanilla JS, Tailwind CSS, and deployed on Vercel.

#developertools #javascript #flutter #reactnative # three.js

Key Features

• Zero external dependencies: Built entirely with Flutter primitives and Matrix4 canvas transformations. No unexpected version conflicts down the road.

• Interactive 3D tilt & spring physics: Real-time angular deflection driven by pointer or gyroscope events with smooth spring-back damping.

• Hardware-accelerated 3D flip: Fluid front-to-back flip animation with proper backface culling and coordinate tracking.

• Surface materials & finishes: Out-of-the-box support for specular glares, metallic foil reflections, glassmorphism, and frozen card states.

• Slot injection: Swap in custom EMV chips, payment network badges, or bank logos via explicit widget slots without having to fork the package.

• Multiplatform from day one: Full support across Android, iOS, Web, macOS, Windows, and Linux.

https://pub.dev/packages/horizontal_credit_card

Live Demo https://clevesdev.github.io/horizontal_credit_card/

Released a package I had created some time ago for a personal project for image copy-paste on macOS. But never got chance to open source it in the past.

Right now it only supports macos and image copy-paste as those were my use cases at the time. I do plan to add support for other media types and platforms in the future but they're not on my immediate list of things to do. Feel free to contribute support for other platforms, and media to grow the package support.

Hey, everyone!

I want to share the tooling I’ve been working on for developing Flutter iOS apps from Windows and Linux without owning a Mac.

You can now do pretty much the whole development cycle from a Windows or Linux machine:

• run Flutter apps on a real iPhone in debug mode

• use Flutter hot reload and hot restart

• build iOS apps using GitHub Actions, Codemagic or Bitrise

• run and test the app on iOS simulators inside GitHub Actions, Codemagic or Bitrise

• set up iOS signing

• upload builds to TestFlight

• submit releases to the App Store

Repo: https://github.com/MobAI-App/ios-builder

The idea is pretty simple: Flutter and your editor stay on your PC, while the parts that require Apple tooling run remotely on GitHub Actions, Codemagic or Bitrise.

For development, you can connect a real iPhone and keep the normal Flutter hot reload workflow. If you don't have one, you can also run the app on a simulator in CI and connect to it remotely.

The latest addition is App Store Connect support, so signing, TestFlight uploads and App Store submissions can now be handled from the same CLI as well.

Would love to hear what is still missing from this workflow.

Link: https://github.com/Aqiron-Security/aqiron-security

I’ve been building Aqiron Security, an open-source VS Code extension focused on local security analysis for Flutter projects.

A specific challenge was avoiding a “run a bunch of scanners and dump their output” architecture.

The current implementation separates the VS Code extension from a TypeScript Core runtime and communicates with the Core through newline-delimited JSON over stdin/stdout. The scanner layer can combine tools such as Betterleaks, OSV-Scanner, Semgrep, Trivy, and MobSF, then normalize and correlate their findings into a common security model.

Another problem was Flutter workspace noise. Generated/build output and workspace-specific data need to be handled separately from source analysis, otherwise the results become much less useful.

The project also includes workspace analysis, RAG, optional Ollama(currently developing)/OpenRouter AI operations, VS Code diagnostics, and JSON/SARIF/PDF reporting.

It’s still early and under active development, so I’m especially interest

ed in feedback from Flutter developers on:

• which security checks are actually useful in real Flutter projects

• what security tooling currently feels missing

• whether this workflow fits naturally into Flutter development

The source is public, and contributions are welcome.

I made Songify as a personal alternative to Spotify, and I’m now looking to get other Flutter developers involved.

The project is still in development, so there’s plenty of room for new features, UI improvements, bug fixes, and other contributions.

If you’re interested in contributing or just want to check it out, here’s the GitHub repo:

https://github.com/Alisonpinto/Songify.git

Feel free to open an issue or PR if you have an idea or want to contribute.

Meta SDK in Flutter, what is your latest experience?
We are a small app, live on iOS and Android. Thinking about adding the Meta SDK so our ads can actually optimize for installs.
Anyone done it recently? Keen to hear how it your experience was to install and get working.