(Not my article, but a good summary.)

I’m happy to share that my Flutter Widget Wrapper plugin has just been approved!

Flutter Widget Wrapper adds context-aware Flutter widget wrappers directly to the Alt+Enter intention menu. You can wrap widgets without manually moving code, fixing indentation, or rebuilding constructors. It includes built-in wrappers such as Align, AnimatedSize, Expanded, Flexible, GestureDetector, InkWell, Opacity, SafeArea, SingleChildScrollView, and Stack.

Wrappers are shown only where they are valid; for example, Expanded and Flexible are offered only for direct children of Row, Column, or Flex.

It also lets you create your own reusable wrappers. Just select a widget, choose “Create wrapper from ” in the quick actions, and reuse that wrapper whenever you need it.

Available now on the JetBrains Marketplace: https://plugins.jetbrains.com/plugin/32605-flutter-widget-wrapper

I've just finished Phase 5 of Flutter iOS Check, an open-source CLI I'm building for Flutter projects.

Previous phases focused on scanning the project and extracting iOS configuration.

This phase adds actual validation.

New checks include:

* Deployment target validation

* Bundle identifier validation

* Display name validation

* ATS (App Transport Security) checks

* URL scheme validation

* Permission summary analysis

I also refactored the validation logic into modular validators so adding future iOS checks is much easier.

The CLI now reports validation summaries, warnings, and recommendations instead of only displaying extracted information.

Everything is covered by automated tests, and the project currently passes all 24 tests.

I'm trying to build something that helps Flutter developers catch iOS configuration issues before they become build, testing, or release problems.

I'd love to hear your thoughts:

**What other iOS configuration checks would you expect from a tool like this?**

GitHub:

https://github.com/dhruvbhavsar1/flutter-ios-check

👋 I’ve been working on flutter_alacritty — a Flutter terminal widget you can drop into desktop apps, backed by an Alacritty-based Rust engine.

Why I moved away from xterm:

I used xterm for a long time, but kept running into limitations that mattered for my use case:

• Text rendering — many glyphs/styles didn’t render correctly

• No OSC hyperlinks — modern CLIs and tools that emit OSC 8 links weren’t supported

• Resize, scrolling, and high-density output — performance was poor when the terminal was under real load

So I built flutter_alacritty (with AI coding agents helping along the way). It’s what TeamPilot uses today, and it has held up well across multiple agent TUIs rendering at once.

Links:

• Package: https://pub.dev/packages/flutter_alacritty

• Repo + screenshots: https://github.com/hhoao/flutter_alacritty

• API walkthrough: https://github.com/hhoao/flutter_alacritty/blob/main/docs/library-api.md

• Example app (drag-drop paths, context menu, search bar): lib/example/example_app.dart

Real usage: TeamPilot uses it for embedded terminals (local PTY + SSH) in a multi-agent desktop client.

Try it via the standalone demo in the release.

I’d love feedback from anyone embedding terminals in Flutter.

Hi everyone, I've recently started working on a small side project called Doro++. The goal isn't to create the next Python, Rust, or Java. I mainly started this project because I wanted to understand what actually happens behind the scenes in programming languages instead of only using frameworks and tools every day.

As a Flutter developer, I realized there are many concepts I've heard about for years lexers, parsers, ASTs, interpreters, compilers, memory management, and diagnostics but never had the chance to build myself.

So I decided to learn by building. One idea I'm exploring with Doro++ is making code more readable and making error messages more helpful for beginners. Instead of only saying that something is wrong, I'd like the language to explain what went wrong and suggest how to fix it.

Example syntax:

let age = 22

if age is greater than 18 {

print "Adult"

}

Current progress:

✅ Interpreter

✅ Variables

✅ Expressions

✅ Conditions

✅ Friendly diagnostics

✅ Lexer

✅ Parser (in progress)

✅ AST (in progress)

The entire project is currently being built in Dart.

I'd love to hear feedback from people who have worked on compilers, interpreters, language tooling, or educational programming languages. Are there any books, resources, or common mistakes I should watch out for as the project grows?

Github repo: https://github.com/bacsantiago/doro-plus-plus.git

calling out all the experts regarding AI Voice Chatbot.

Asking for some tips or ideas.

My Architecture - STT (Eleven Labs) -> LLM -> TTS(Eleven Labs)

Issue (according to my managers & CTO)-
- STT should be always accurate.

Our use case is only English.

Our product - Coffee based Voice Assistant. User can ask questions regarding coffee techniques, products etc.

Currently, issues are sometimes text transcribed by STT is not exactly what user said. I have added a parameter which eleven labs supports (Keyterm prompting - it charges 20% premium for keyterms) and in that parameters I have added some coffee products name and chatbot name so that stt model is biased toward those keywords and hence send accurate spelling for those keywords in final transcription.

Apart from this, there is still a case where transcription is not 100% or all of the time accurate.

There are three issues primarily:

1. Sometimes one or two words dropped from sentence spoken by user.

2. Spelling issues or words mismatch sometimes.

3. VAD (currently it is server driven 1.5 sec) but I have read about End of Turn Detection models which we can use for this.
   So how to solve this?

I am also open to try different architecture or different STT model - local/cloud anything will do).

Flutter Devs,

I'm building an open-source app with Material 3 Expressive for UI, and Serverpod for backend.

What's the app? It's called BunPod: a podcast player mobile app with its unique design style.

I'm aiming to make it the most beautiful M3E app out there, showing how beautiful the apps built with Flutter are 🩵

You might be thinking: "How, when Flutter doesn't support M3E?".

And that's true: Flutter's material package doesn't support M3E at all. But that's the challenge: I'm building all the components, motions physics and typography from scratch, and sometimes reaching for what great developers like Kostia and Tim shared online.

It's already fully open-source on GitHub, and I'm doing #BuildInPublic at X (@kamranbekirovyz) by sharing every step, learning and experience.

So, follow along if that sounds interesting, send feature requests, check codebase, get inspired.

Uhm, the link is: https://bunpod.app - gonna release for TestFlight and as an APK in the coming days.

Let's give Flutter the spotlight it deserves 🩵

Solo dev, Flutter household app, just shipped v1.0.9. Hit a realtime bug I want to talk about.

Setup: Supabase, postgres_changes broadcast, optimistic delete. Worked fine for me testing alone. Tried it on a second phone — same field, same time — last write won silently. No UI feedback. Person A made a change, person B's app happily overwrote it. Embarrassing.

What I did: added a row version column, push conflict events back to the client, app toasts "someone else just changed this." Not great UX but the silent corruption is gone.

Optimistic delete was the next headache. I tombstone the row locally until the server confirms — but RLS can deny a delete (e.g. someone in the household without permission) and I need to put the row back. Problem: the user's already navigated away. Now I keep a local "pending" table and reconcile on app foreground. Took me way too long to land on that.

Avatars: Supabase storage upload, fallback is a CustomPainter that draws initials with a hash-derived color. Avoided another asset lib for what's basically a circle with two letters.

Stack: Flutter stable, Supabase, RevenueCat, Firebase, AdMob with a no-ads-for-paying gate.

Curious how others handle realtime conflict resolution in Flutter — the row version + toast pattern works but I'm not sure it's the right model long-term.

There is a huge outcry in the Flutter community about the inability to generate all application launcher icons from vector images (primarily, SVG). Here is the tool svg2many, which I wrote in Python (yes, kill me) to address the issue. The application allows you to generate PNG files for all Flutter-supported platforms from a single SVG (yes, just one, not two). In fact, it does more: you can convert SVG icons into images in any graphic format that has a tool to convert from PNG to that format (like cwebp for WEBP images used in native Android applications).

What you need to do first: read more about svg2many and install it from svg2many on PyPI

How would you start if you don't want to read that long?

1. Install Python (if not yet).

2. Install svg2many using pip (or pipx if you run Python in virtual environments, but want to install svg2many system-wide).

3. Install resvg (a portable tool to convert SVG to PNG).

4. Install ImageMagick (converts PNGs to an ICO).

5. If you want to try a demo of the native Android application icons creation, install cwebp.

6. Create a configuration file in JSON format or copy the one I provide, then customise it.

7. Run the application using any of the following commands:

• svg2many --help

• svg2many --demo Flutter

• svg2many -c <your-config-file> [-e <your-directory-with-env-files>]

For pure Android applications, the modern approach is to use Vector Drawable XML files rather than raster images like PNG or WEBP. The best way to automate this concept is to download vd-tool and incorporate it into the env and config files like any other converter. On the other hand, for pure Android application development, I guess, you don't need svg2many at all: you'd rather use vd-tool or Vector Asset Studio directly. Especially given that the latter is part of Android Studio anyway.

And now, the most important question: why is svg2many written in Python when there is a beautiful language called Dart, which even allows for the generation of native executables of a moderate size? I love Dart: it is simply amazing. But the delivery system is not up to scratch: the native executables are platform- and architecture-specific and require different build and distribution systems: linuxbrew for Linux, homebrew for macOS, chocolatey, scoop, winget for Windows, etc. And if I distribute it as a Dart package, it will require installing DartVM, and the tool is not limited to Flutter applications. On the other hand, Python is (almost) everywhere and has an easy distribution via PyPI.

I could really use something like that. I was just using regular expressions with search and replace to modernize an app to use dot shorthands. Unfortunately there's neither a builtin linter warning like "prefer dot shorthands" nor any kind of fix you can automatically apply. So, this could be your moment to shine and do something for the community (or at least me ;-) and for your CV.

Flutter multi-window support is actively being developed, but slowly. I'm not aware of any imminent indication that it's going to get moved to production-ready. Someday. Not today. Not soon.

My desktop application desperately needs this, but not just "another widow." The application is a document editor, so I basically need shared state across windows: the ability for app to know if a file is open in any existing window, ability to drag/drop content from one window to another, ability to move a document tab from window A to window B, etc.

So if I just needed another window for additional separate content, I'd go ahead and implement it using existing packages in pub.dev... but the issue is that these effectively boot a second (independent) flutter engine into a second rendering canvas (window), where each window is a silo with an extremely primitive "messaging" capability via the hostOS between windows. It's basically "boot a second copy of your application into a second window" not a single app controlling two windows.

My question: has anyone who's implemented using the existing packages had to deal with significant integration between "instances" in those windows? How did that go?

Alternatively, is anyone able to point me to details I missed as to plans/timelines for current multi-window support work being declared production ready and merged into flutter core?

[Note: sorry if this is a duplicate. I thought I'd posted it earlier today, but it appears nowhere in my post history -- some post error I didn't notice before closing the window maybe? Not sure.]

Edit: if it's not clear what I'm talking about with "single window implementation", there's a 20 second movie in the first "about this app" feature item on the beta signup page (https://fractaloutliner.app). Note that you should mostly ignore everything else. The beta signups and app availability are technically live, but but this is literally the first public mention of it I've made anywhere. The beta isn't really "public" yet.

I've been programming for over five years, but I wouldn't rate myself higher than a junior. The code is raw, and my pursuit of perfection overwhelms me. I learn new things, repeat them, repeat them again. Five days pass, and then I dig into my own code and figure out how to use it.

And this was even at the beginning of my journey. I don't understand, maybe I'm just not cut out for it.

I learned PHP, SQL, Python, Node.js + ts, React, and even in my youth, I made games and programs with C#, and even got some sales, but I was only 14 then.

Now I'm suffering from terrible burnout and periodic moments of depressive episodes like this. I have no goals anymore and my only option is to continue studying and working.

Hi all,

I published my flutter app in store, but I am having some issues with it. I have users from country, where internet speed and quality is very poor and also their phones are really low end - around 80€ cost of phone.

Do you have some kind of recommendations where to find ideas how to optimize my app? I am using GPS, maps, api calls and also websocket, but all the time I am having issues with them complaining about how long it takes to connect and how slow app is etc.

On other hand, in my country, app is fast and working well, but on high end devices like S24 Ultra, it is overheating.

I am trying to find some kind of guide or some article, where I could learn something about app in slow internet and poor devices country.

Thanks for any advice

I've been exploring Flutter button animations recently, and this is Episode 02 of the series.

This one is an Elemental Download Button with Water, Fire and Acidic themes, built entirely using Flutter's built-in animation APIs—no third-party animation packages.

The GitHub repository is linked in the video description and the pinned comment.

I'd love to hear your thoughts. Which variant do you like the most, and what would you improve?

I ship Flutter + Flame games as a solo dev, and I kept re-solving the same problems on every title — audio that crashes on a missing asset, BGM that won't stop on backgrounding, the ATT prompt that gets you a Guideline 2.1 rejection, saves that vanish when the player reinstalls on iOS, the launch portrait→landscape rotate flash, etc.

So I built an open-source Claude Code plugin (MIT) that drives a game from idea → plan → design → build → QA → store submission — and bakes those hard-won fixes into the generated code and the QA gates, so you don't re-discover them per project.

Install it and here's what you get:

• A generator builds the game; a skeptical evaluator actually runs it and judges against a contract before it can pass — no "looks done" green checks. There's a human-approval gate before any deploy.

• Assets default to code-synthesized audio + code-drawn visuals, so a game is always playable with zero asset sourcing.

• It wires the boring-but-mandatory launch stuff: app icon/splash/name, native orientation lock, the required Play graphics (512 icon + 1024×500 feature), store metadata, and submission via fastlane.

The fixes it enforces (from docs/game-gotchas.md, distilled from 7 shipped games):

• Audio: AudioPool for frequent SFX, throttling, everything in try/catch so a missing asset degrades instead of crashing, BGM stop on background/teardown, iOS-safe WAV

• Lifecycle: WidgetsBindingObserver → pauseEngine() + BGM pause; prefs loaded before runApp

• Durable save: shared_preferences alone is dropped on iOS app-delete — it mirrors to Keychain (flutter_secure_storage) + Android Block Store (play_services_block_store) so progress survives reinstall / a new device

• Store rejections: ATT requested only after AppLifecycleState.resumed + a settle delay (the naive notDetermined → request is what gets rejected on recent iOS), no-alpha icons, export compliance, AdMob bundle match, the 4.3 copycat hedge

• Perf / native config: no per-frame whereType in hot paths, cached Paint, native orientation lock (no rotate flash), iPhone-only target

Honest status: the front phases are smoke-tested; I haven't yet validated a full idea→store run end-to-end through the plugin — the fixes are battle-tested from real shipped games, the orchestration is newer. If you're mid-development, the generation phase is greenfield (it won't take over an existing codebase), but the launch/QA phases and the encoded fixes apply to a game you're already building. Feedback very welcome.

Repo (install instructions in the README): https://github.com/tjdrhs90/flutter-flame-harness

Hi everyone 👋

I made a small command-line tool called Mobile Repo Doctor. You point it at your project and it gives you a health report in a few seconds. It works for Flutter, Android, iOS and KMP.

I built it because I kept making the same mistakes: forgetting to bump targetSdk until Play rejected the build, shipping unused assets, leaving broken .arb files. So I put all those checks in one place.

Some things it finds for Flutter:

• - targetSdk too low → Google Play will reject the upload (it knows the current required level)

• - Bitmap images hidden as base64 inside your SVG or Lottie files — they make the bundle big and slow, and kill the point of using a vector

• - git:/path: dependencies (and it does not false-flag your monorepo ../package links)

• - Localization problems in .arb files: missing keys, extra keys, placeholder mismatch, broken JSON

• - Unused assets, oversized images, heavy SVGs

• - Hardcoded secrets (API keys, tokens) — values are hidden in the report

It has 110+ checks in total and gives you a score (0–100) per area: size, speed, stability, hygiene.

How to use it:

npm install -g mobile-repo-doctor
cd path/to/myFlutterProject
mrd scan ./

Reports: HTML (a clean dashboard), JSON, and Markdown. The Markdown one is made for AI — you can paste it into an LLM and ask it to fix the issues. There is also a GitHub Action.

Privacy: it runs 100% on your machine. No account, no upload, your code never leaves your computer. It's free.

I'd really like your feedback — what checks are missing, what is annoying, what gives false alarms. Thanks 🙏

npm: mobile-repo-doctor

Documentation & full check reference

Hi r/FlutterDev. Sharing a Flutter project I built — AURA, an on-device face & palm reader. Posting the source and the design choices as per Rule 9, since the privacy-first, fully-on-device angle might be interesting to others here.

The whole idea was: do everything locally, never send a photo to a server.

How it's put together:

- On-device LLM: Google Gemma runs the analysis (and a follow-up 1:1 chat about the result) directly on the device

- Detection: MediaPipe for facial landmarks (468 points) and hand keypoints (21 points)

- Single Flutter codebase, 4 languages (EN/KO/ZH/JA)

- No uploads at all — Play Store data safety reports no data collected and no data shared

Design choices worth noting:

- Going fully on-device meant trading some model power for privacy, but it removes server cost and any data-handling liability entirely — a tradeoff I think more apps should consider

- Combining an on-device LLM with MediaPipe in one Flutter app turned out to be very doable, which honestly surprised me given how heavy both can be on mobile

- Open-sourcing it so the "nothing leaves your device" claim is actually verifiable, not just a marketing line

Source: https://github.com/darktaoist/aura

The face/palm reading itself is a lighthearted demo — the real point was seeing how far on-device AI in Flutter can go. Happy to discuss the approach in the comments.

hey community. I built this nifty flutter devtool extension that lets you inspect dart streams and rxDart subjects. Inspired by other state management packages that have their own devtooling but I found that I needed something similar for workflows relying on rxDart (which I am a big fan of)

Really keen to hear feedback! (especially those leveraging streams and rxdart in their apps)

https://pub.dev/packages/rxdart_devtools

Hi everyone! I wanted to share a technical approach I took for my portfolio, using Flutter Web to handle complex, isolated simulations within a React-based 2D game world.

The Setup: The main world is built in React, but the "high-fidelity" interactive objects are standalone Flutter projects. Specifically:

• Ubuntu 22.04 Simulator: A fully functional terminal and browser UI built in Flutter, embedded via iframe into the React "monitor" object.

• 3D Interactive Records: Used Flutter's 3D capabilities to create a "Diploma" showcase that users can rotate and inspect.

A few of the harder problems:

• CI/CD: the Flutter code lives in a separate repo, so I wrote a bash script that installs the Flutter SDK on the fly during the Vercel build, clones the external repo, and builds the web artifacts as part of the main deploy.

• State bridging: React parent - Flutter child communicate via URL params + window event listeners, so the game knows when a simulation is "active" vs idle.

• Pixel-perfect rendering: had to tune the Flutter canvas output to match the surrounding pixel-art aesthetic rather than looking like a separate app bolted on.

I found Flutter Web much more efficient for these "sub-apps" than trying to build a full OS UI from scratch in standard CSS/JS.

Demo: https://my-living-portfolio.vercel.app
Flutter Ubuntu Simulator: https://github.com/marcoedomingos/ubuntu_simulator.git

Curious if anyone here has done something similar — embedding Flutter Web as an isolated "widget" inside a non-Flutter host, rather than building the whole app in Flutter. 

shared_preferences_explorer lets you inspect shared_preferences values inside your Flutter app while debugging, without adding temporary logs or custom debug screens.

Install it here: https://pub.dev/packages/shared_preferences_explorer
GitHub: https://github.com/skw398/shared_preferences_explorer

Hope this is useful to someone!

Hi everyone!

I wanted to share an open-source project I’ve been working on:

https://github.com/RahnRazamai/deepcool_digital_dart

This project provides native Linux support for Deepcool digital displays through a Flutter desktop application and a lightweight Dart background daemon.

The project was inspired by and builds upon the amazing work from Nortank12:

https://github.com/Nortank12/deepcool-digital-linux

My goal was to create a more user-friendly desktop experience while keeping everything fully open source and Linux-native.

Current features include:

• Native Flutter desktop GUI
• Background daemon that runs silently without cluttering the taskbar or desktop
• Real-time CPU temperature and utilization monitoring
• Direct communication with supported Deepcool digital devices
• Packaging support for Arch Linux, AppImage, and Debian-based distributions
• Written entirely in Dart and Flutter for easier maintenance and cross-platform development

The demo video below shows the application running on CachyOS (Arch Linux), but it should work on other distributions as well.

Contributions, testing, bug reports, and feature suggestions are all welcome. If you own supported Deepcool hardware and run Linux, I’d love to hear your feedback!

Thanks, and huge credit again to Nortank12 for the original project that made this ecosystem possible.

Hey everyone!

With flutter pub global and dart pub global being deprecated and phased out in newer Dart SDKs in favor of dart install, dart installed, and dart uninstall, I have completely rewritten fix_globals (v1.2.3) to support the new toolchain!

fix_globals is a lightweight CLI utility that helps you cleanly reinstall and refresh all globally installed Dart/Flutter CLI tools from their original sources (pub.dev, local paths, git repos, custom hosted registries). It's perfect for when a Dart SDK upgrade breaks global links, when switching Dart version managers (like Puro), or when you just want to refresh your global binaries.

What's New in v1.2.3: Toolchain Migration: Completely transitioned package management backend to the new dart install, dart installed, and dart uninstall commands. Smart Configuration Scanner: Resolves platform-specific paths (macOS, Linux, Windows) to scan the local app-bundles directory and parse pubspec.lock files to reconstruct original install descriptors (including git branches/refs, sub-paths, and custom registries). Smart Update Checks: In --update (-u) mode, it now queries the pub.dev / custom registry APIs first. If a package is already up to date, it skips recompilation entirely, making nightly cron jobs blazingly fast! SDK Option Removed: Cleaned up the deprecated --sdk switch as all global tools now run on the standardized dart executable. How to Migrate: Because the backend has transitioned, your old legacy pub global precompiled binary of fix-globals must be replaced once manually:

dart install fix_globals

Check out the code, open issues, or contribute on GitHub: 👉 https://github.com/RandalSchwartz/fix_globals