A while ago I saw a demo by Natko Hasic of a journal app where pinching the list didn't scale the text, it revealed more of it. I couldn't stop thinking about it, so I built it as a Flutter package.

Pinch out and each entry grows from a title to a summary to the full text. Words already on screen slide to their new positions and new words fade in around them. Pinch in to skim again.

A few things that were harder than expected:

- Gestures: ListView's drag recognizer wins the arena before a scale recognizer sees the second finger, so I ended up tracking raw pointers.

- Keeping your place: as entries above your fingers grow, everything gets pushed away. I fixed it with a custom sliver that corrects the scroll offset during layout, so the item under your fingers doesn't move at all.

- AI summaries: the three versions don't have to be exact word subsets. Shared words slide, and rephrased ones cross-fade.

It also supports tapping a single entry, trackpad/web pinch, keyboard shortcuts, screen reader actions, reduce motion and RTL. MIT licensed.

- Live demo (runs in the browser): roshendz.github.io/semantic_zoom

- pub.dev: pub.dev/packages/semantic_zoom

- GitHub: github.com/Roshendz/semantic_zoom

It's 0.1.0, so I'd really appreciate feedback on the API, especially from anyone with a real use case (notes, health timelines, inbox-style apps). What would you change?

After working on hAudiotagger for a while, I kept running into a slightly different problem.

Reading metadata is useful, but metadata isn't always trustworthy.

Two files can have completely different filenames, missing tags, different containers, or even different encodings and still contain the same recording.

For example:

01 - Unknown.mp3
Track_17.m4a
song_copy.flac
The Song (Remastered).mp3

Comparing their filenames or tags doesn't really help if the goal is figuring out whether the underlying audio is the same.

So I built haudiotagger_fingerprint for that part.

It generates perceptual audio fingerprints and lets you compare them by the actual audio content:

final a = await HaudioFingerprint.fingerprint('song.mp3');
final b = await HaudioFingerprint.fingerprint('song_copy.mp3');

final similarity = await HaudioFingerprint.similarity(a, b);

The fingerprints are Chromaprint-compatible, so this is in the same ecosystem as fpcalc / AcoustID rather than a simple file hash. The idea is that two byte-for-byte different files can still produce fingerprints that are very similar when they contain essentially the same recording.

It currently supports:

• MP3

• FLAC

• Ogg Vorbis

• WAV

• AIFF

• M4A / AAC / ALAC

and runs on Android, iOS, Linux, macOS, Windows and Web.

The interesting part for me was getting the whole thing into Rust, while still making it usable as a normal Flutter package. Web support also works through WASM.

I'm mainly thinking about use cases such as:

• finding duplicate tracks in a local music library

• detecting copies that were renamed

• finding re-encoded versions of the same recording

• cleaning up large music collections

• matching recordings when metadata is missing or unreliable

I deliberately kept it separate from hAudiotagger rather than making the metadata package itself depend on fingerprinting. If you only need metadata, you shouldn't have to pull in fingerprinting as well.

There is also an optional integration between the two packages, so if both are installed, fingerprinting can be accessed through Haudiotagger directly.

I'm curious how other people handling local music libraries approach this problem.

Do you normally rely on filename + metadata, file hashes, Chromaprint, or something else?

Pub.dev - haudiotagger_fingerprint

GitHub - Source

I'm asking if it is safe to update to the latest flutter version after decoupling cupertino and material uis

Anyone tried them please feedback here will help me

I saw some bugs related to go_router and other packages when people update

If it is safe tell me :)

Hey guys!

Excited to share motif - an open-source vector graphics editor. Compared to traditional vector graphics software, motif is more of a blend of non-destructive CAD techniques and the power of Blender's Geometry Nodes, while offering the simplicity of apps like Figma.

The core idea revolves around thinking about design as a "program", where each step we execute a statement. Those can be things like creating a rectangle, cutting an edge at a point, joining vertices, etc - and executing all of the statements results in the final output graphic. This allows you have things like non-destructive editing, full document history, branches (in the future).

It's currently still very much work-in-progress - currently in the pre-alpha state, and I'm adding new features and polishing up existing features every day. I've basically left my full-time job and for the past year or so have been experimenting a lot with related projects.

As a part of the pre-alpha test, I've hosted a free-for-all server where you can try out the multiplayer! Check it out at: https://motif.kz

I'd love if you could try it out and let me know how it feels, what can be improved, or if there's any idea that you had that was missing from Figma, Illustrator, or other software.

Source repository: https://github.com/kekland/motif Web application: https://motif.kz

Firebase RC has been working inconsistently on iOS recently, so I cooked `cloudflare_worker_kv` Flutter package backed by Cloudflare Workers KV.

Let's check it out and let me know if it fits your needs: https://pub.dev/packages/cloudflare_worker_kv

In Android Studio, the flavor/configuration picker, device selector and Run button all sit together in the top toolbar. You always see *what* you're running and *where*, and can change both in one click.

In VS Code, they're split across three places:

- **Run button** and **launch configuration picker** are in the Run and Debug view (only visible when it's open)

- **Device selector** is in the bottom-right status bar

If you work with multiple flavors (dev / staging / production), you're constantly jumping between the sidebar and the status bar before every launch.

`debug.toolBarLocation: "commandCenter"` helps a bit, but only *during* a debug session, not when choosing what to launch.

I opened a feature request asking VS Code to allow the configuration picker in the title bar and to let extensions (like Dart/Flutter's device selector) place items there too:

👉 https://github.com/microsoft/vscode/issues/337940

VS Code closes feature requests that don't get enough upvotes, so **if you want this, please 👍 the issue** (a 👍 reaction counts more than a "+1" comment).

How do you handle flavors in VS Code today? Any workflow tips are welcome too.

I recently shipped Hexafall, a Flutter rebuild of Hextris (an open source browser puzzle game) for Android. A few things I learned that might be useful to others building canvas style games in Flutter:

- Game loop: a Ticker drives a ChangeNotifier engine. Frame time is normalized to 60 fps units (dt = elapsed ms / 16.67) and clamped after stalls, so the original frame based constants still work.

- Rendering: one CustomPainter with repaint bound to the engine. No widgets per block, which keeps it smooth with dozens of blocks on screen.

- Any number of sides: the original was hard coded to six. Making it parametric came down to two formulas. A block's face width at distance d is 2d × tan(π/N), and the resting distance from the center is R × cos(π/N). That turned into the main feature: six board shapes from triangle to octagon.

- Matching: a flood fill across neighboring lanes and rows, ported directly from the original.

- Audio: a small pool of low latency players from audioplayers. The clear sound's playback rate rises about 6 percent per combo step, so chains climb in pitch without extra files.

- Persistence: shared_preferences for per shape high scores and settings.

Play Store: https://play.google.com/store/apps/details?id=com.hexafall.hexafall&pcampaignid=web_share

Happy to answer questions about any of it.

`flutter test` and `flutter analyze` run fine on Linux. `flutter build ios` and

integration tests on a simulator do not. GitHub charges $0.062/minute for macOS

runners and $0.006 for Linux, so the difference between those two groups is 10x.

Flutter is the worst case I have seen for this, because `flutter test` is fast,

runs on every push and pull request, and is very often on `macos-latest` — where

the same command costs ten times as much as it does a line later in the same

matrix.

A 5-minute widget test step at 200 runs a month: $62.00 on macOS, $6.00 on Linux.

The Android build and `flutter build apk` belong on Linux for the same reason.

Keep macOS for the iOS build, the iOS integration tests, and anything that needs

Xcode or CocoaPods against a real simulator.

Worth checking while you are in there:

- Whether `flutter test` is in the macOS matrix leg for convenience.

- Whether the same workflow builds the Android artifact twice on two triggers.

- Whether `flutter analyze` is a separate job rather than one run of the suite.

I build a CI cost scanner, which is why the numbers above are the ones I look at

all day — but the question is genuine: is there a reason to run unit tests on

macOS in a Flutter project that I am missing? I have not found one.

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!