**Flutter app, RevenueCat, Supabase backend.**

Sandbox purchase went through. RevenueCat showed the entitlement active. The
app showed the pro badge. And the server still refused to let me start a
session.

Turned out I only called Purchases.logIn(userId) inside my sign in handlers.
Never on app launch. So any returning user with a restored session was
anonymous in RevenueCat. Their purchase got attached to a $RCAnonymousID:...
customer, my webhook couldn't match that to a user row, and never granted
anything.

**Worst part:** the webhook returned 200 the whole time. Zero rows updated, no
error thrown, everything green in every dashboard.

**Fixes**:

\- Call logIn on every app start when a session exists, not just on sign in.
\- Reject non UUID app_user_id in the webhook and log it loudly.
\- Return 5xx when the update matches zero rows.
\- Test with a returning user, not a fresh install. That's the only path I'd
never tested.

\#iOSDev #RevenueCat #InAppPurchase #StoreKit

\#FlutterApp

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!

Hey everyone,

I'm planning to build and publish an app on the App Store, but I'm stuck at the very first step: figuring out what app to actually build.

My main goal is to create something that can:

• Attract real users (not just friends and family downloading it out of pity 😅)
• Have a realistic path to generating income (ads, subscriptions, one-time purchase, freemium — open to any model)
• Be something I can realistically build and maintain as a solo dev / small team

A bit about me:

• I'm still learning to code (mostly beginner/intermediate level with Swift/basic app dev), so I'm looking for something achievable, not a huge project
• I can realistically dedicate around 10-15 hours a week to this
• I have zero marketing/growth experience — this would be my first time trying to actually promote something I built

I've seen a lot of "app idea" lists online, but most of them feel either way too saturated (another to-do list app, another habit tracker) or way too ambitious for one person to build and market alone.

So I'd love to hear from people who've actually shipped something:

1. What kind of app idea worked well for you in terms of getting real users?
2. Looking back, what's a niche or problem that's still underserved on the App Store right now?
3. Any advice on validating an idea before spending weeks building it?

Appreciate any thoughts, even brutally honest ones. Thanks in advance! 🙏

I’m building Airo TV, an open-source Flutter Android TV player. It follows a bring-your-own-content model: it does not provide channels, playlists, subscriptions, or media—users add sources they’re authorized to access.

The engineering problem I’d love feedback on is making TV navigation feel stable when a user imports a very large playlist.

Our current approach:

• Parse M3U and XMLTV data away from the UI thread through worker/native boundaries.
• Keep channel lists and programme-guide views windowed/virtualized rather than building every row at once.
• Make search local and deterministic across imported channels and available guide data—no cloud search requirement.
• Treat playback failures as diagnosable states with bounded retry behaviour, rather than an unexplained black screen.
• Design for D-pad-first interaction, readable TV layouts, and local favorites/smart playlist organization.

For developers who want a public playlist to reproduce import and large-list behaviour, we have tested with the third-party IPTV-org index:

https://iptv-org.github.io/iptv/index.m3u

It is not bundled with, operated by, or controlled by Airo TV. Stream availability can change, and please use only content you are permitted to access.

The open source is here:
https://github.com/DevelopersCoffee/airo

The current Airo TV release and Community Voice roadmap are here:
https://developerscoffee.github.io/airo/tv/

I’d especially value input from people who have shipped Flutter TV, large-list, or media experiences:

1. What has caused the worst focus-loss or rebuild problems in your TV UI?
2. How do you keep memory and scrolling predictable with very large datasets?
3. What playback diagnostics have actually helped users distinguish source, network, decoder, and device failures?

If this project is useful, a GitHub star would genuinely help motivate continued open-source work. You can also follow the project and its builders here:

• https://x.com/DevlopersCoffee
• https://x.com/ucguy4u
• https://www.linkedin.com/in/chauhanuday/
• https://www.linkedin.com/company/developerscoffee/?viewAsMember=true

Thanks for taking a look and sharing honest feedback.

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.

Hi everyone,

I just submitted my first app to the App Store and I'm trying to get a realistic sense of review times from people who've gone through it recently, since I've seen a lot of different numbers online.

A few questions:

1. For your first submission, how long did the review actually take from "Waiting for Review" to "Ready for Sale" (or rejection)?
2. Did it stay in "In Review" for long, or did it move fast once it started?
3. Any tips for first-time submitters to avoid common rejection reasons (e.g. account deletion, privacy details, demo account info)?

Would really appreciate hearing real timelines from the past few months, since I know Apple's review speed changes over time.

Thanks in advance!

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.

hi, im curious if any of you actually puts release notes into your apps?

I have a problem with some feature adoption, since ppl don't really know about some things I deploy, most have auto app updates anyway and don't really read whats changed in appstore/goole play

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.

Hi everyone,

It’s no secret that Flutter Web has a massive blind spot: SEO. Because Flutter renders to a canvas (or complex DOM elements) dynamically, search engine crawler bots often hit a blank wall, resulting in terrible or no indexation.

After all, the whole reason we choose Flutter in the first place is to escape the traditional HTML/CSS/JS triad and build unified, declarative UIs. We shouldn't have to go back to writing dual web apps or complex template mirrors just to satisfy Googlebot.

To solve this without forcing developers to rewrite their apps in Next.js or Jaspr and abandon Flutter's core philosophy, I built flutter_easy_seo.

How it works:

• Generates SEO-friendly HTML directly from your existing widget tree.
• Declarative wrapping: Simply wrap target widgets to flag them for static extraction.
• Serve SEO HTML to bots: Search engine bots get the SEO-friendly HTML while a regular user sees the full Flutter App.
• Ease of Use: Designed to keep usage as simple as possible.

What it supports out of the box:

• Interactive Mode: Built-in UI overlay for manual generation and visual debugging.
• Automated Mode: Headless execution tailored for CI/CD pipelines and scheduled server tasks.
• Localization: Native handling of language codes for multi-lingual indexing.
• Dynamic Paths: Easily handles parametric routing (e.g., product overview and detail pages).
• Flexible Routing: Fully compatible with major routing engines (GoRouter, Beamer, etc.).
• Asynchronous State: Safely awaits async data loading and hydration (e.g., Riverpod providers) before extraction.

Links & Code

• Live Showcase: https://fluttereasyseo.lxandr.at
• Indexed on Google (Proof it works): Google Search Result
• pub.dev Package: https://pub.dev/packages/flutter_easy_seo

Looking for Feedback

I’d love to get your feedback to help push this package further! I’m especially looking for edge cases, use cases, or requirements I might have missed in my own production setups.

If you have any thoughts, feature requests, or architectural feedback, please open an issue or discussion directly on the GitHub repo (linked via pub.dev).

Check out the implementation, and let me know what you think!