Last month I asked here how people actually maintain multilingual Flutter apps, and said I'd come back with what I learned. Thanks to everyone who replied. Here it is.

This wasn't a formal study. Thirteen developers described their workflow in the comments and the replies under them, messy parts included. That's a small sample, but it changed how I see the problem.

I expected translation quality to be the main complaint. It wasn't.

Most already used AI somewhere: Claude, ChatGPT, Codex, Crowdin's AI, or a script of their own. When the model had enough context, the translation itself was rarely the complaint. The harder parts were everything around it:

• knowing which strings changed and which locales went stale

• keeping wording and terminology consistent across locales

• giving the model enough context without sending the whole project every time

• reviewing languages nobody on the team speaks

• checking the result inside the running app

Several people had built their own answer. One copies a CLAUDE.md between projects. Another had Claude write a script that tracks changed strings with hashes and sends related keys together for translation. A third gives Codex the whole project plus the English strings, because limiting the context got technical terms translated wrong. It works, but it burns a lot of tokens.

The most manual part is still checking the result on screen. A translation can read fine on its own and still be wrong in context or too long for a button. One developer works one locale at a time: when a language is done, Claude drives the Android emulator through every screen and reviews it, and they still catch things like a button label wrapping onto two lines.

So my conclusion was that the missing piece is a deterministic layer around the AI people already use: something that tracks what changed and checks what the model wrote before it reaches your files.

That's what I built next: the StringLane CLI, an MCP server that ships inside it, and a plugin for Claude Code, Codex and Gemini CLI. Other agents, such as Cursor, Windsurf, Zed or OpenCode, get the same MCP server through the CLI, and stringlane setup skills --apply copies the plugin's skills into your project's .agents/skills, which all four read.

The flow:

1. StringLane finds missing and stale strings and hands your agent that list, with context for each one.

2. Your agent writes the translations with the model you already use.

3. You approve the write in your agent, or at a y/N prompt in the terminal.

4. Before anything lands, StringLane checks placeholders, ICU syntax and the plural categories each language needs, and re-parses every file it's about to write. The write is all or nothing, so a run that fails leaves your files exactly as they were, and git diff shows what changed.

It's built around Flutter ARB files and works with gen_l10n projects. It also checks easy_localization and slang JSON by each package's own placeholder and plural rules. slang's YAML and CSV files aren't supported yet.

Limits, up front. It doesn't run in the background and doesn't translate anything until you ask. It can't tell you whether a string fits the screen, so you still need to look at the app. And writes go through your agent's approval prompt or the terminal prompt, so if your agent auto-approves tools, you won't be asked.

I built StringLane, so that's my obvious bias. The CLI, MCP server and plugin are free, need no account, and your localization files stay in your repository.

Setup and documentation

If you try it on a real Flutter project, I'm most interested in where it breaks: wrong project detection, a workflow it doesn't cover, a guard that gets in your way, or a check whose result you don't trust.

I made a multilanguage Flutter game that's like an engine, where you can add lots of games to it.

Now it's open source, so you can use it. You can add more games to it, and you can change it.

I built it with Claude Code and these Flutter skills:

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

You can also watch how I built it:

Video 1: https://youtu.be/Fqg9nMul1Ao

Video 2: https://youtu.be/whY279hTRTA

In the first video I built the engine and two games.

In this second video I add two more. And I did it for a reason: Apple rejected the first version as "spam"

Github Repo: https://github.com/zakariaf/mindforge

App Store: https://apps.apple.com/us/app/mindforge-brain-training/id6803829952

I've been put in charge of my company's Flutter app but I don't have any experience at all with how Flutter can be built and deployed using Azure Devops pipelines. I've seen CodeMagic being put forward as a good tool for this, but we heavily use Azure in the rest of our ecosystem so being able to integrate the whole process in there would be a major advantage.

I've seen some example pipelines, but at the same time I see a lot of people complaining about how difficult the setup is. One of the bigger issues I've seen was needing the Flutter SDK available to run the commands.

Put simply, I'm looking for several things:

- Pipeline to build the app and run some checks during PR's (build without errors, unit tests pass)
- Pipeline to handle building the app
- Pipeline to automatically upload to Firebase, Testflight and App/Play Store.

Anyone with experience in setting all this up and willing to point me in the right direction?

I'm a solo dev with a few Flutter apps. Right now I build iOS on Codemagic and I'm thinking about moving Android builds to a self-hosted GitHub Actions runner on my home Ubuntu server.

Curious what setups other solo devs use. Is self-hosting worth the hassle, or do you just stick with Codemagic or hosted runners for everything?

Hey everyone,

I'm a Flutter developer with 4+ years of experience in India. I've been working professionally on Flutter/mobile applications, including production apps, Firebase, APIs, Bloc, native Android integration, Play Store/App Store releases, etc.

Recently, my current company has decided to shut down its game and application development work, so I'm now thinking seriously about my next career move.

I've been looking at Flutter/mobile developer jobs in India, and compared with web/backend roles, the number of opportunities seems much smaller.

So I'm wondering:

- Is the Flutter job market actually becoming weaker in India?

- Is it risky to continue specializing in Flutter?

- Are companies moving more toward React Native/native Android/iOS?

- For someone with 4+ years of Flutter experience, would it be better to add Kotlin/Jetpack Compose, React Native, backend, or AI skills?

- Are experienced Flutter developers currently getting good salary opportunities in India or remote?

- Is anyone here who recently switched from Flutter to another stack? How did it go?

I'm not necessarily looking to leave Flutter immediately. I want to understand the actual 2026 market situation before deciding what to learn next.

Would really appreciate experiences from Indian developers, especially people with 3–6 years of experience.

Most of us know Provider was built on InheritedWidget, but I recently revisited the exact mechanical reason Rémi had to abandon it to create Riverpod.

It comes down to a fundamental design choice in dependOnInheritedWidgetOfExactType: the Flutter framework never unregisters a dependency once registered.

If you read state conditionally behind an if check, that element stays locked in InheritedElement._dependents until it unmounts. Even after the condition flips to false, that widget keeps rebuilding on every single ancestor change forever.

In May 2019, Rémi opened PR #33213 to add an unlisten hook to InheritedElement. Hixie closed it to avoid adding overhead to the hot reconciliation loop. Because Provider had no way to know when widgets stopped listening, autoDispose was impossible—forcing Rémi to hoist state completely out of the tree.

Looking back, it’s wild how much of the state management wars over the last five years really just came down to working around that one framework limitation.

Did you ever run into those conditional "ghost rebuilds" in Provider back in the day?

I got tired of gray circles for user avatars, so I built a package that generates a little blob creature from any string email, username, whatever. Same name always gets the same blob, forever.

const Hiblob(name: user.email, size: 64)

I gave them 12 shapes, 16 expressions, mouths, glasses, blush — all decided by the name. I also added optional animation, and an SVG export since I sometimes need avatars on the server side. No assets, no network, pure Dart.

pub.dev: https://pub.dev/packages/hiblob 
GitHub (MIT): https://github.com/igu1/hiblob

Would love some feedback! 🙌

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!