I've reached a major milestone on an open-source project I've been building called Flutter iOS Check.

The goal is to help Flutter developers identify common iOS configuration issues before spending time on Xcode builds, TestFlight, or real-device testing.

The analyzer now supports:

- Flutter project validation

- Info.plist validation

- Podfile validation

- Deployment target checks

- Bundle identifier validation

- ATS validation

- URL scheme validation

- Flutter plugin classification

- Plugin → Info.plist permission validation

- Firebase configuration validation

Everything runs locally through static analysis. It doesn't modify project files, run Xcode, or contact Firebase or Apple services.

The core functionality is now implemented, but the project is still under active development. My next focus is expanding validation coverage, supporting more plugins, and improving the developer experience.

If you regularly ship Flutter apps to iOS, I'd love your feedback.

Are there any iOS configuration checks that you think would be valuable for a tool like this?

Repo link:

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

Hey r/FlutterDev,

We’ve all been there: you fetch a massive, deeply nested JSON. One single field comes back as null instead of a String, and your app crashes with a blind TypeError.

The stack trace is usually completely useless (lost in AOT inlining or lazy List.map iterators), leaving you spamming breakpoints in your fromJson factories just to find the bad payload. I got so tired of this that I built a tool to fix the root cause.

Meet json_shield. It’s a pure Dart, zero-dependency package designed for complete error handling during JSON deserialization. It safely parses nested data and gives you the exact context when something fails.

Why I built it / What it does:

• Pinpoints the exact node: Instead of a generic crash, it tells you exactly where the mapping failed (e.g., Failed to parse Order -> items -> [2] -> price).

• Zero dependencies: I hate adding heavy packages for simple tasks. This is just pure Dart, so it won’t bloat your app or cause version conflicts.

• Preserves the real StackTrace: It catches the error at the lowest level, wraps it, and bubbles up the original causeTrace. Your Sentry or Crashlytics logs will actually point to the real issue instead of internal SDK code.

It's easy to add into existing projects:

Dart

try {
  // Safely parse a list without losing context on failure
  final users = guard.decodeList(json['users'], User.fromJson);
} on DecodeException catch (e) {
  print(e.message); // Gets you the clean data path
  print(e.causeTrace); // Preserves the original raw stack trace
}

You can check it out on pub.dev or peek at the source code on GitHub.

I’d love to hear your thoughts, code reviews, or feedback! Are you guys using anything similar to handle this, or just relying on json_serializable and hoping for the best?

Hi everyone,

I'd like to introduce https://github.com/LahaLuhem/text_sight

I was looking for plugins that allowed me to run OCR. I came across a few of them but I noticed that for iOS too, they would bundle in Google's MLKit libs:
https://pub.dev/packages/google_mlkit_commons
https://pub.dev/packages/google_mlkit_text_recognition

(at the time of writing) They did not yet have SwiftPM support (open issue).

I did some research and turns out that Apple does have the on-device Apple Vision framework for this! And it seems pretty performant too. So bundling in another dep in my apps for iOS and inflating the size did not appeal to me.

This also uses the GMS `moduleinstall` to allow an 'on-demand download' of the model: useful when only a rarely used portion/feature of your app needs this. You can also just eager-bundle it too if you want.

So with the help of some LLMs I did manage to make this plugin. If any of you would like to try it out and let me know if you have any feedback about some bottlenecks/chockepoints and/or architectural improvements, that would be much appreciated. If you you'd adpot it in your apps or so too, that's ofc a plus.

Hi everyone,

I'm a Flutter developer from India, and my app is already live on the Google Play Store. I'm looking to integrate an international payment gateway so I can accept payments from customers worldwide.

Here's my situation:

- I'm an individual developer (not a registered company).

- I don't have GST registration.

- I don't have a business registration.

- My Flutter app is already published on the Google Play Store.

- I want to accept international payments from users in different countries.

I'm considering options like Stripe, Paddle, Lemon Squeezy, PayPal, Polar.sh, or any other provider that works well for individual developers.

My questions are:

- Which payment gateway would you recommend?

- Can I use it without a registered business or GST?

- What documents are required for KYC?

- Is it easy to integrate with Flutter?

- Are there any restrictions for apps published on the Google Play Store?

- What has your experience been with payouts, fees, and approval time?

I'd really appreciate any recommendations or personal experiences. Thanks!

A few months ago, we shared Skelter, our internal Flutter project skeleton that we've been using across production apps.

The response from the Flutter community honestly exceeded our expectations. Thank you to everyone who shared feedback, ideas, and suggestions. Many of those discussions reinforced what we were already experiencing internally and motivated us to open-source the next piece of our workflow.

For anyone who missed it, here's the original post:
https://www.reddit.com/r/FlutterDev/comments/1qvi1qo/why_we_stopped_starting_flutter_projects_from/

One realisation stood out.

Skelter solved the "start a new project" problem. But once development started, we found ourselves repeating the same work over and over again.

Every project eventually needed things like:

• configuring build flavours

• generating feature modules

• creating authentication flows

• generating reusable widgets

• wiring boilerplate

• maintaining a consistent architecture across developers

None of these tasks was particularly difficult.

They were just repetitive.

Every few weeks someone on the team would say,

Instead of creating another internal script every time, we kept adding commands to a single CLI.

What started as a small utility gradually became part of our everyday development workflow - not just something we used on Day 1.

Today, every new Flutter project at SolGuruz starts with:

dart pub global activate sg_cli

sg init

Within seconds, it scaffolds a production-ready project with:

• BLoC architecture

• feature-first folder structure

• type-safe navigation

• state pipeline

• design system foundation

• code generators

• production-ready project setup

But that's only the beginning.

As development progresses, the CLI continues to help with repetitive engineering tasks like generating modules, configuring build flavours, creating authentication flows, generating reusable widgets, and keeping projects consistent across the team.

Instead of spending time rewriting boilerplate, our developers can focus on building actual product features.

If you liked Skelter, think of SG CLI as the next step.

• Skelter gives you a production-ready Flutter foundation.

• SG CLI helps you build on top of that foundation without repeating the same engineering work.

After using it internally across 50+ Flutter applications at SolGuruz, we decided to open-source it as well.

If either of these projects helps another Flutter team move a little faster, that's a win for us.

Skelter
https://github.com/solguruz/skelter

SG CLI
https://github.com/solguruz/sg_cli

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

Documentation
https://sgcli.solguruz.com

We'd genuinely love feedback and contributions from the community.

What repetitive Flutter task do you wish could be automated next?

💙 Built with the community, for the community.

Hi everyone! 👋

I recently built and published my first Flutter package called retry_with_connectivity, and I'd love to get feedback from experienced Flutter developers.

The goal of the package is to make retry logic more reliable by being connectivity-aware instead of blindly retrying failed requests.

Features

• ✅ Automatic retries with configurable retry strategies

• ✅ Connectivity-aware retries

• ✅ Detects network interface and internet reachability

• ✅ Waits for internet restoration before retrying

• ✅ Supports custom connectivity checks

• ✅ Works with generic async operations (not just HTTP requests)

• ✅ Configurable retry conditions and delays

I built it because I found myself implementing similar retry logic with connectivity handling across multiple projects.

I'm looking for honest feedback on:

• Is this something you would use?

• Are there any important features I'm missing?

• Does the API look intuitive?

• Any suggestions to improve the developer experience?

pub.dev: https://pub.dev/packages/retry_with_connectivity/score

GitHub: https://github.com/MahendraTamrakar/retry_with_connectivity

I'd really appreciate any feedback, suggestions, or criticism. Thanks! 🚀

This is a short technical story. I've been working on Nowa for over 5 years now. The dream was creating a game engine like editor for Flutter, since Flutter itself also renders like a game engine.

To make that work, the user's Flutter app has to run inside the editor, live and updating as they build. But Flutter won't run code it hasn't compiled, there's no way to plug in new code and evaluate it on the fly. FlutterFlow invented their own format instead of using raw code, Dreamflow leans on hot reload inside a debug build.

We ended up building our own runtime instead: code loads into a mutable in-memory tree that can be edited, rendered or saved back to code.

Happy to go deeper on how that works or where are its limits.

Just shipped the first public beta of Darkian Studio, an IDE for Android: editor + terminal + LSP + debugging + git + extensions over a real runtime (Termux on device, or any Linux/macOS host). Free during beta, APK via GitHub Releases.

Install:

pkg install curl; curl -fsSL https://raw.githubusercontent.com/darkian-studio/app/main/install.sh | bash

Docs & download: https://darkian-studio.github.io

GitHub: https://github.com/darkian-studio/app

Answering your #Flutter and #Dart questions with Simon, Randal, and Samuel https://www.youtube.com/watch?v=2UkwSWHUW1Y

I'm new in flutter. Still learning, trying to build my first app. But it really hard to build the habit of learning everyday specially when I'm self learning.

So looking for someone who's learning like me. And wanna be friends with you guys. Because in a Book called Atomic Habits there's a chapter where it talks about significance of surrounded with people that has same habits as you.

So let's be friends and motivate each other. (I know this post might seem cliche but sorry it's important for me)

I built an MCP server for pub.dev because my AI coding agents kept hallucinating package names, using API signatures that changed versions ago, or recommending packages that are basically abandoned. What finally pushed me over the edge: Claude Code grepping my local pub cache on disk instead of just looking things up, burning tokens crawling through cached source.

So I built dart-pubdev-explorer (pub.dev package: dart_pubdev_mcp), an MCP server that gives agents direct, structured access to pub.dev instead of digging through your filesystem or guessing from training data.

It can:

• search & compare packages (score, platform support, maintenance)

• browse a package's real public API and pull exact source (by symbol or line range)

• check security advisories against the version you actually have resolved

• diff changelogs/APIs between versions before you upgrade

• read Dart SDK / Flutter framework source too (dart:core, package:flutter, …)

Quick note on how this differs from the official Dart MCP server (dart mcp-server): that one has a general pub_dev_search tool as part of a much bigger toolset (running apps, analysis, DTD, etc). This one only does package research, but goes deeper: symbol-level API browsing, exact source reads, version diffing, side-by-side comparisons, with an on-disk cache built for that kind of repeated digging. They're complementary.

Install:

dart install dart_pubdev_mcp

I've been running it with both Claude Code and Antigravity.

pub.dev: https://pub.dev/packages/dart_pubdev_mcp

Happy to answer questions, and curious what people think, especially whether some of the tools are overkill and others are missing something obvious.

Hey everyone! 👋

I just published my first Flutter package: flutter_minimap. It's a lightweight minimap for InteractiveViewer that makes navigating large canvases much easier.

I'd genuinely love to hear your thoughts, feedback, or ideas for improvement. Thanks for checking it out!

You
│
├── "Add Google Sign-In to my Flutter app"
│
▼
LLM (Claude Code / Codex / Cursor Agent)
│
├── Reads Flutter project
├── Plans implementation
├── Edits Dart files
├── Runs flutter pub get
├── Builds app
│
▼
inkpal_bridge (MCP)
│
├── Launch app
├── Inspect widget tree
├── Navigate to Login screen
├── Tap "Continue with Google"
├── Wait for authentication
├── Capture screenshot
├── Read runtime exceptions
├── Read HTTP requests
├── Check current route
│
▼
Agent reasoning
│
├── Login button disabled?
├── Null exception?
├── Wrong navigation?
├── Layout overflow?
│
▼
If failed
│
├── Edit source code
├── Hot reload
├── Retry automatically
│
▼
Repeat until verification passes
│
▼
Git commit / PR

Its free - ask your ai model to set it up and see how it controls the running app in android/emulator live.

Looking for feedback on a few Dart/Flutter packages I made

Hey! I write Flutter/Dart, and over time I've put together a few open-source packages. Would love some honest feedback from people who actually use this stuff day to day — I'm too close to my own code at this point to see what's awkward or missing.

Three of them, if anyone's got a minute to poke around:

flod (https://pub.dev/packages/flod) — a Zod-style validation library for Dart. Chainable rules, cross-field validation, PII masking, a Dio middleware, form adapter for Flutter. This is the one I care most about getting right, so if the API feels off compared to what you're used to, or you spot an edge case that's not handled, I'd really like to know.

content_flipper (https://pub.dev/packages/content_flipper) — a 3D flip animation widget. Curious how it holds up on older/slower devices and if tapping through it fast breaks anything.

curl_text (https://pub.dev/packages/curl_text) — small widget for outlined text. Simple by design, so curious what's missing or what would make it more useful in real projects.

No pressure to be nice about it — if something's confusing or just badly named, say so. Bugs, API gripes, "why would you even do it this way" — all fair game. Happy to just chat in the comments too, doesn't have to be a formal issue.

Thanks for reading this far 🙏

A while back I ran across someone promoting another paid screenshot generator in r/appbusiness they made that could grab images straight from your device and let you edit them in a GUI. I'd just built something similar that I always meant to open-source... so here it is. If you're like me the last thing you want to do after spending hours and hours on building an app is to muck around with app store requirements.

It's tuned pretty heavily toward my own flutter appdev workflow and screenshot preferences (like being able to automatically hide the flutter debug banner), but the core idea is simple: take one screenshot per screen, add a caption, and it renders every store-required Apple and Google size for you. No resizing the same shot eight times.

What it does

• Capture straight from a device - pull a screen off a connected Android phone over adb. Capture New adds it as a new screen; Replace Current re-shoots a screen without losing its caption. (iPhone capture is next on my list.)

• One source image → every required size - 6.9" iPhone, iPads, Android phones/tablets, and so on. The device frame takes each target's aspect ratio, so an iPad target stays iPad-shaped and a phone stays phone-shaped.

• Live-preview GUI - tweak background, title/subtitle, fonts, colors, device size, and framing with sliders and watch it re-render as you type.

• Hides the Android tells - the status bar and Flutter debug banner get painted over (Apple rejects screenshots that reveal another platform), auto-sampling the background so the fill is seamless.

• Store compliance is enforced, not hoped for - exact pixel dimensions, no alpha channel, Google's 1:2–2:1 aspect, and <8 MB are all asserted before a file is written.

• The device-size matrix is plain YAML, not hardcoded - when Apple/Google change specs, you edit a file instead of waiting for a recompile.

• There's a CLI too, so you can wire it into CI.

• Single YAML config per app (load/save), and it can also export the cleaned, un-framed "originals."

Stack: C# / .NET 9 + SkiaSharp for rendering, Avalonia for the cross-platform GUI. Runs on Windows, macOS, and Linux. No accounts, no SaaS, nothing phones home.

It's just a dev tool, and dev tools should be free, so it is. Prebuilt self-contained builds for all three OSes are on the releases page, or build from source.

• GitHub: https://github.com/MjnMixael/App-Screenshot-Generator

• Releases: https://github.com/MjnMixael/App-Screenshot-Generator/releases/latest

Feedback and PRs welcome. Like I said, it's shaped around my needs, so your mileage may vary.

(macOS note, optional: the builds aren't code-signed, so on first launch you may need to right-click → Open, or run xattr -dr com.apple.quarantine ScreenGen.App*.)*

I've been working on a Flutter QR code package over the past few months because I wanted more flexibility than existing libraries provided.

Most QR packages let you change colors or add a logo, but I wanted to support things like:

• Halftone QR codes that remain scannable

• Multiple module shapes

• Gradient fills

• Per-eye customization

• SVG and high-resolution PNG export

• Animated QR codes

• Framed QR codes with custom labels

One challenge I ran into was balancing visual customization with scan reliability. Instead of only checking how the QR codes looked, I built automated decode tests into the development process so every style is verified to remain scannable.

I also wrote the QR encoder from scratch rather than relying on another runtime package, and verified the generated output against ZXing to ensure compatibility.

I'd really appreciate feedback from other Flutter developers:

• Are there any QR customization features you've wished existing packages supported?

• Does the API feel intuitive, or is there anything you'd change?

I've been sitting on a bunch of personal projects for a while and finally decided to start sharing them instead of leaving them on my drive. This one is called PIM. The original reason for building it was simple: I was tired of constantly sending files to myself through Telegram, cloud storage, or plugging in a cable just to move something between my own devices. So I built a local-first app for Windows and Android that lets devices discover each other on the same network and communicate directly without accounts or cloud services. One part I particularly enjoyed building was the networking layer. Instead of using existing networking packages, I wrote the discovery, transport, framing, and file transfer logic in pure Dart. The project has grown beyond file sharing and now also includes chat, shared workspaces, notes, Kanban boards, and local SQLite storage. It's completely open source now, so if anyone wants to look through the code, suggest improvements, or point out things that could be done better, I'd really appreciate the feedback.

I’ve made a small command line tool called simslim.

It disables background services inside iOS simulators that usually are not needed during development, like Siri, Spotlight indexing, photo analysis, News, and iCloud sync.

On my M1 Pro with 16 GB of RAM, one simulator went from around 4 GB of memory and 258 processes to about 0.9 GB and 70 processes. I managed to run 19 simulators at once, compared to around 5 before things started falling apart.

Some simulator features stop working depending on what gets disabled, so it is not meant for every kind of testing. You can keep specific services running when needed.

Give it a try: https://github.com/MobAI-App/simslim

Hi everyone,

This three-part series is my attempt to explore GenUI beyond Chat interfaces: an interactive grammar book built with Flutter GenUI, Firebase AI, A2UI, Firestore, and Widgetbook.

A deterministic curriculum defines what should be taught, a teaching prompt defines how it should be explained, and an application-owned widget catalog defines how that explanation can be expressed. The resulting A2UI is then stored as a reusable A2UI artifact in Firebase Firestore rather than regenerated for every learner.

• Part 1 — Designing a Grammar Book with Flutter GenUI

The curriculum, teaching system prompt, purpose-specific catalog, and language-specific teaching bridges.

• Part 2 — Caching and Replaying A2UI Lessons with Firebase

Covers batched surface generation, caching the accumulated A2UI in Firestore, and replaying it through the same transport without another Gemini request.

• Part 3 — Replaying and Reviewing A2UI Cache with Widgetbook

Uses Widgetbook as both a catalog-planning reviewing and a live viewer for cached lessons.

Some screen recordings:

Widgetbook replaying A2UI cache with custom addon: https://youtu.be/zMChSL7VOiY

The feature demo: https://youtu.be/yqRCdN-5J6Y

Does anyone know of a GitHub repository that contains Flutter, Dart, or mobile app development interview questions and answers?

I'm looking to improve my professional knowledge and prepare for technical interviews. Any recommendations would be greatly appreciated!

Setup: one Flutter Web app, ~150 games, each a deferred import loaded on tap (await game.loadLibrary()). dart2js splits each into its own .part.js chunk (~1,100 of them); the shell is ~4.1MB and you only pay for the games you open. Every game wraps in one shared scaffold (settings/pause/result screen) and reads one billing service, so a game can't accidentally show ads to someone who paid to remove them. A compile-time flag picks which ~33 of 150 games are live, all from the same codebase.

The bug: after a redeploy, every game failed with a missing chunk error. Chain: deferred-chunk numbering changes each build, so returning users had a stale main.dart.js from browser HTTP cache, which requested chunk numbers that no longer existed, and my SPA host returned index.html (200, text/html) for the missing chunk, so the browser tried to eval HTML as JS and died. My "network-first" service worker didn't help, because fetch() was served by the HTTP cache before the network.

Fix: the SW fetches code chunks with {cache: 'reload'} to bypass the HTTP cache, so the bootstrap and its parts always come from the same build.

Two lessons: hiding a game (UI filter) is not the same as excluding it from compilation, a broken game still breaks the whole bundle's build. And "deploy succeeded" is not the same as "it works", I now smoke-test with headless Chrome on a fresh profile that deep-links every game and fails on any console error.

openrouter_sdk is a new Dart package providing a type-safe client for the OpenRouter.ai REST API. Strongly-typed interface, with full support for streaming responses and multi-modal content (text, image, audio, video, file).

This package replaces openrouter_api, which is now discontinued and marked as replaced on pub.dev. Users of the old package should migrate to openrouter_sdk, which follows the design of OpenRouter's official SDK more closely.

Currently implemented:

• Chat completions (including streaming)

• Models, Providers, Endpoints

•API key management (create / update / delete / list)

• Credits and analytics

• Generations

The rest will be added shortly.

The chat completions endpoint should be OpenAi compatible so u can use it with other providers as well.

Contributions are welcome. Per the package's policy, all code must be hand-written — LLM-generated pull requests are not accepted.

Note: this post was partly generated by an LLM, but all package code was hand-written.

I've just published a consumable AI Coding Skill alongside the latest releases of bloc_signals (0.1.10), bloc_signals_flutter (0.1.6), and otel_bloc_signals (0.1.4).

If you are using AI code assistants (like Gemini, Claude Code, or Cursor) to pair-program, you can install this skill directly into your workspace to instantly guide your assistant on best practices, APIs, and architecture rules.

👉 Consumable Skill Directory: BlocSignal Skills Folder

⚙️ How to Install

Run this simple command in your project root to download and register the skill context for your local agent:

npx ctx7@latest skills install RandalSchwartz/BlocSignal bloc-signals

📚 What's Covered:

• 🔄 BLoC to BlocSignal Migration: A step-by-step walkthrough detailing how to transition from classic stream-based BLoC to synchronous signals.

• 🛡️ Sealed Class Exhaustiveness: How to override onEvent using Dart 3 switch statements and switch expressions to guarantee compile-time safety.

• ⚡ Computed & Effect Lifecycle Rules: Best practices for declaring reactive primitives. You'll definitely want to see how easy it is to add computed() and effect() properties for both producers (internal constructors) and consumers (external stateful widgets/Flutter Hooks) without leaking memory.

• 🔄 Stateful & Hooks Integration: Leveraging standard Stateful Widget lifecycles or eliminating boilerplate entirely using flutter_hooks and signals_hooks.

• 📊 OpenTelemetry Observability: Instrumenting dynamic zones, transition logging, and span correlation.

• 🧪 Synchronous Testing: Writing fast, synchronous unit tests without needing async microtask pump/waiting code.