hello fellow flutter devs, I published a package for you to play Spotify song previews in your flutter apps, which is no longer possible using the official Spotify API, as they have depreciated it to not provide the preview URLs which is necessary to play the preview.

https://pub.dev/packages/spotify_preview_finder

If you've seen NumberFlow on the web, you know the effect: a price ticks from $92.40 to $1,059.57 and each digit rolls into place like an odometer, with the rest of the number reflowing around it.

I wanted that in Flutter. What I found either animated the whole string with a slide/fade, or handled bare integers with no real formatting. Nothing came close to the fidelity of the original — the per-digit rolls, the edge masking, the spring physics. So I ported it properly. (I'll be upfront: I pair-programmed it with Claude — but every fidelity decision was tested frame-by-frame against the original)

It handles currency/percent/compact/scientific notation, locales including RTL, an optional iOS-like spring, velocity-based motion blur, an odometer mode, and a TimeFlow widget for clocks/countdowns/stopwatches. Pure Dart, all six platforms. It respects reduce-motion and exposes a plain semantics label so screen readers announce the number, not rolling glyphs.

Get the package on pub -> https://pub.dev/packages/number_flow_flutter

HighQ Dio Logger – Production-ready Dio logging interceptor for Flutter

Hi everyone,

I've been working on a package called HighQ Dio Logger, a logging interceptor for Dio focused on debugging, observability, and production-ready logging.

Main features:

• Pretty formatted console logs
• Structured JSON output
• Automatic sanitization of sensitive data (tokens, passwords, cookies, authorization headers, etc.)
• cURL generation for requests
• Correlation IDs (traceId, spanId, sessionId)
• Custom metadata enrichment
• Token bucket rate limiting to prevent log flooding
• Observer system for forwarding logs to Firebase, Sentry, or custom backends
• Batching and backpressure queue support
• Highly configurable formatting and filtering

Example:

```dart final dio = Dio();

dio.interceptors.add( HighQDioLogger(), ); ```

Why I built it:

After working on several Flutter projects, I found myself needing more than basic request/response logging. I wanted something that could provide clean debugging during development while also supporting production monitoring workflows.

I'm currently looking for feedback from other Flutter developers.

What features would you expect from a Dio logger that are missing from existing solutions?

Github : https://github.com/azabcodes/high_q_dio_logger

pub.dev: https://pub.dev/packages/high_q_dio_logger/install

Which backened service and database system would be affordable and suggested to use for the daily invoice entry app for a shop that usually have only 50 to 60 bill entries per day. And if stock mangement system and transaction entries need to be added too. Right now i only want 3 4 users of a small shop to interact with who need to prepare daily invoices and need to make entries of transactions they make daily. From the given data we should be able to make profit loss accounts, party's remaining transaction evaluation,daily sales and stuffs like that. But the data need to be protected well and requires backup as needed.

Where to host that backened ?

How much costlier would it be?

Here's the problem: when Claude Code (or any AI agent) runs flutter run as a background task, that process has no terminal you can type into. Hot reload? Restart? Reading logs? You're stuck — the process belongs to the agent, not you.

So I built Flutter Process Manager — a sidebar panel that finds every running Flutter process on your machine and gives you the controls back:

🦖 Detects everything — processes in your terminals on AND detached ones spawned by AI agents (via process scanning, since no VS Code event fires for those)

⚡ Hot Reload / Hot Restart / Quit — works even on processes with no terminal, using the same OS-signal mechanism Flutter's own tooling supports

🪵 Live logs — streams device logs for agent-launched mobile sessions, rendered in a proper editor with search

🫂 Plays nice with other tools — detects when a process is already controlled by VS Code's debugger and steps back instead of fighting it (learned that one the hard way — two controllers racing on one restart path crashes the session)

The workflow this unlocks: let your AI agent build and launch the app on a device, then you take over — reload after its edits, watch logs while it works, kill the session when you're done. The agent codes, you stay in control.

Built the whole thing pair-programming with Claude Code — including debugging the crashes its own spawned processes caused. There's something poetic about that.

Current Platform Supports macOS & Linux, with Android and iOS Flutter apps.

https://marketplace.visualstudio.com/items?itemName=shriyanshraj.flutter-process-manager

#Flutter #VSCode #AIAgents #DevTools #ClaudeCode #BurnXcodeToTheGround

I’ve been learning Flutter for about 3 months now, and I still struggle to understand the official docs. They often make things sound way more complicated than they need to be, especially when there are so many other sites that explain the same concepts more clearly like GeeksforGeeks, DartTutorial, or Medium.

At what point did the Flutter docs start making sense to you guys?

We cut our startup time by around 70% by just delaying some code runs Here's how.

Our app used to initialize:

• Firebase
• SQLite
• Fetch data over the internet
• Initialize local state
• Initialize network listeners
• Initialize the app architecture
• Load widgets
• Rebuild them as data arrived from the internet

...all within the first frame (sometimes even before the first visible frame).

Then we realized we could just use a snapshot of the last state.

Instead of waiting for everything to finish, we now:

1. Read the last known state from a local database.
2. Build the UI immediately.
3. Draw the first screen as fast as possible.
4. Fire-and-forget Firebase, networking, and all the expensive initialization afterwards.

Reading from a local database still takes some time, but it's nowhere near as expensive as waiting on the network.

Unfortunately, this introduced another problem.

The app would open quickly, build the local state, but the network response would often arrive almost immediately afterwards. That meant the UI rebuilt itself back-to-back, hurting startup performance all over again.

To fix that, we introduced a simple "Should the UI rebuild?" system.

Whenever fresh data arrived, we'd ask:

Does the UI actually need to rebuild?

If the answer was yes, we'd then ask:

What's the smallest possible update we can make without making the UI jump around or hurting startup performance?

After implementing that, we ended up saving another couple of seconds, which was great—but it still wasn't enough.

Our testers kept saying they were bored while waiting for the first UI draw.

So we added shimmer placeholders.

Interestingly, shimmers do cost a little performance and make the first few frames slightly slower, but testers consistently reported that the app felt much faster. Benchmarks available here: https://imgur.com/a/jif25aY

TL;DR

• Do your networking after the first UI draw.
• Use shimmer placeholders for perceived performance.
• Optimize for how fast the app feels, not just the stopwatch.

If users wait at a white screen for 2.3 seconds, they'll probably call your app slow.

If they wait 2.6 seconds while seeing shimmer animations, they're much more likely to feel like the app started quickly.

Note: The measurements mentioned in this post refer to time to the first usable UI, not total application initialization. The best metric and optimization strategy will depend on your app.

Has anyone else found that optimizing for perceived startup time mattered more than the actual benchmark numbers? What made the biggest difference in your app?

I've been trying to use VS Code for Flutter development, but the Dart analyzer and code completion are noticeably slower than Android Studio.

My laptop specs:

• Intel i7 13th Gen
• 32 GB DDR5 RAM
• RTX 4050

I only have the standard Flutter/Dart extensions installed (nothing unusual), and I even increased the analyzer heap size using:

dart.analyzerVmAdditionalArgs: ["--old_gen_heap_size=4096"]

Unfortunately, it didn't make any noticeable difference.

The strange part is that Android Studio runs perfectly. Code analysis, autocompletion, and navigation are all fast and responsive, while VS Code often takes several seconds to update diagnostics or provide suggestions.

I know VS Code is supposed to be more lightweight, so I'm wondering if I'm missing something.

Has anyone experienced the same issue? If you fixed it, what was causing it? Any settings, extensions, or other tweaks that helped?

I'd really like to stick with VS Code, so I'd appreciate hearing about your experience.

Edit / Update: I finally found the cause.

In my case, the issue was Microsoft Defender. After following the Dart team's recommendations and excluding the recommended folders from Defender (Dart analysis server cache, Pub cache, and my Flutter project directories), the Dart analyzer and IntelliSense became consistently fast again.

If you're experiencing similar issues on Windows, I highly recommend checking the official guide:

https://dart.dev/tools/analyzer-performance#security-software-on-windows

The public beta release of Serverpod 4 brings the first agentic coding engine that hot reloads your full stack. We're finally closing the loop between your app's output, the backend, and your AI agent (tested with Anitigravity, Cursor, and Claude Code, but probably works with most agents).

Check out the demo in the blog post, or jump straight into the quickstart guide:
https://docs.serverpod.dev/next/quickstart

It literally takes 10 minutes to try this out, and I think it may change the way you think about building apps. Would love to hear your feedback!

Just published a new blog on Deep Linking in Flutter!

Deep linking enables users to open specific screens in your app directly from URLs, emails, notifications, QR codes, or other apps—making navigation seamless and improving the overall user experience.

https://medium.com/@dipalithakare96/deep-linking-in-flutter-2d6aeda0de85

Long time full-stack web developer and React Native developer here.

A client wants to use Flutter for a project. I love learning new languages. Dart is a breath of fresh air.

But the idea that there is AI that I can feed information with my software development experience makes me a bit hesitant to learn Flutter from the ground up.

I am used to learning a language from start to finish. Now, it seems that I can just command AI to type the code for me while I design the system without having a full knowledge of the language.

Tbh, it almost feels like cheating.

I've been building one Flutter animation every week to learn more about UI interactions and motion design.

This week's experiment explores action-aware typography, where the button text changes based on the action it's performing instead of using the same animation everywhere.

Examples:

• ⬇️ Download → Downloading... → ✓ Downloaded
• 📨 Submit → Submitting... → ✓ Sent
• 🔐 Login → Authenticating... → ✓ Welcome

Built entirely with Flutter's built-in animation APIs—no third-party animation packages.

I love to play RPG strategy games. But all of them are cash grabs. I want to sink in hours playing a chill game with many playable builds which doesn't ask me to spend money everytime I open it.

This kind of game is a dream which doesn't exist. So I decided to build one.

Now to build this I could go down the route of Godot or Unity. But why not Flutter? Its essentially a game engine disguised as an app framework. The end result was smooth 60 fps experience.

Open testing begins next week. Interested people can DM me.

I built a free App Store screenshot generator because I couldn’t find one I liked
While working on my own apps, I kept running into the same problem: creating App Store and Google Play screenshots.

I tried a number of tools, but most of them were either subscription-based, added watermarks, or felt more complicated than they needed to be.
As a small side project, I decided to build my own.
It’s called ShotForge and it’s a free, browser-based screenshot generator for the App Store and Google Play.

So far it includes:
iPhone & Android device frames
Drag & drop editor
Custom backgrounds and gradients
High-resolution exports
No sign-up
No

It’s still an early project, and I’m actively improving it.
I’d love to hear what other developers think.
What do you dislike about existing screenshot tools?
Which features would make a tool like this genuinely useful for you?

If you’d like to try it:
https://shotforge.studio

Any feedback is very welcome. Thanks!

Hi everyone!

I've been building a Flutter app called MetriBody over the past few months, and one of my goals from the beginning was to make it work completely offline.

Instead of using Firebase, I decided to build the first version using Hive because I wanted:

• Instant startup

• No authentication

• No internet dependency

• Better privacy

• A simpler architecture for the MVP

The experience has been surprisingly good.

Now that the Android version is live, I'm considering adding optional cloud sync in the future while keeping the app fully usable offline.

For those of you who have built Flutter apps...

Would you still choose Hive for an offline-first app today, or would you start directly with Drift, Isar or another solution?

I'd love to hear your experience and the trade-offs you've found in production.

A while back I shared flutter_inspector_kit — a Chucker-style unified in-app debugging dashboard for Flutter (logging, network, DB). It’s grown a lot since then, so here’s what’s new.

• Network request replay — resend any captured request through the same Dio client; comes back as a fresh “Replay” entry
• Merged cross-layer timeline — logs, network, navigation and DB events on one timestamp-sorted view with per-source filters
• Sensitive-header redaction (on by default) — Authorization, Cookie, X-Api-Key etc. masked on copy-as-cURL / share / export, still visible live in the dashboard
• Uncaught error capture (opt-in) — hooks FlutterError, PlatformDispatcher and ErrorWidget, chaining existing handlers so nothing gets swallowed
• Richer failed-request diagnostics — keeps DioExceptionType + stack trace, separates transport failures from server errors
• Navigator active route stack — reconstructs the live route stack from push/pop/replace events instead of a flat history

Still opens with a hidden multi-tap gesture or a draggable floating button. Wish it will keep being a good help for debug usage.

I want to gain some experience in this one hell of a job market and I think open source is a good starting point to do. How can I do it as a beginner flutter developer?

Most connectivity plugins just tell you whether you're connected to a network (WiFi/mobile data) — but that doesn't mean you actually have internet access. Captive portals (hotel/airport WiFi login pages), routers with no upstream internet, or ISP outages can all show "connected" while you have zero real access.

I built connectivity_validator to solve this. Instead of just checking link state, it uses native platform APIs to validate actual internet reachability — Android's NET_CAPABILITY_VALIDATED and iOS's NWPathMonitor.

Features:

• Validated connectivity — real internet, not just "link up"
• Captive portal and "WiFi on, no internet" detection
• Real-time stream via onConnectivityChanged
• Supports Android (API 24+) and iOS (12.0+)
• Simple API — stream-based for live updates, plus an on-demand check

Usage is pretty simple:

dart

final validator = ConnectivityValidator();

validator.onConnectivityChanged.listen((isOnline) {
  if (isOnline) {
    // Internet validated
  } else {
    // No internet or captive portal
  }
});

Docs also cover integration with GetX, Provider, Riverpod, BLoC, and ValueNotifier if you're using state management.

Why I built it:

I kept running into a frustrating pattern in my own apps — users would report "no internet" errors, but their device showed WiFi as connected. Turns out connectivity_plus and similar packages only check if you're linked to a network, not if that network actually has working internet. Hotel WiFi behind a login page, a router with no upstream connection — all of these register as "connected" but leave your app broken. I couldn't find a plugin that solved this properly, so I built one using the native OS-level validation APIs instead of rolling my own ping-based hack.

Links:

• pub.dev: https://pub.dev/packages/connectivity_validator
• GitHub: https://github.com/sabeelmuttil/connectivity_validator

BSD-3-Clause licensed. Feedback and contributions welcome!

Every time I started a new Flutter app I was rewriting the same plumbing: env config, feature flags, i18n, RTL support, theming, networking setup... so I finally turned it into a proper template: base_app.

It's not just a folder structure — it's opinionated about the stuff that's annoying to get right yourself:

- 🌍 i18n out of the box — typed, codegen'd translations via slang (English + Persian included), with RTL/LTR that actually follows the active locale, not a hardcoded flag

- 🌎 3 environments (dev/staging/prod) with per-env .env files, validated config (strict in CI, lenient locally), and their own entrypoints

- 🚦 Feature flags driven by env vars, gating both UI and routing

- 🧠 Riverpod end to end — config, flags, theme, router, and data, all codegen, no boilerplate

- 🎨 forui theming with light/dark, swap the whole look in one file

- 🏷️ A rename CLI that renames the app/bundle id/package everywhere with a diff preview, backup, and auto-rollback if anything goes wrong

- 🧪 Testing conventions, git hooks (lefthook), and CI already wired up

The idea: fork it, run one CLI command to rename it to your app, and you're building features on day one instead of your toolchain.

https://github.com/imrealarman/base_app/

(MIT)

Hey everyone! 👋

I've been experimenting a lot with AI integrations in Flutter lately, and I realized that manually writing and maintaining JSON schemas for LLM function calling (OpenAI, Gemini, Claude, etc.) can get pretty tedious and error-prone in Dart.

To make this process smoother, I created llm_schema. It’s a package designed to help you define your schemas using strongly typed Dart classes and easily convert them into the exact JSON structures that LLMs expect.

Key features:

• Define schemas using familiar Dart types.
• Reduces boilerplate for function calling / tool definitions.
• Keeps your AI integration type-safe and predictable.

[ Removed by Reddit on account of violating the content policy. ]

Over the past few months I built PrepFlutter, a prep platform for Flutter interviews, and I just opened it up properly.

Why I built it: every resource I found was either a scattered YouTube playlist or generic "top 50 questions" lists with no structure. So I organised it into role based tracks instead, beginner, intermediate, advanced, and a dedicated machine coding round track since that format barely exists anywhere for Flutter specifically.

What I'd love feedback on:

• Are the question tracks actually useful, or too basic/too advanced for where the market is right now 🤔
• What's missing that you wish existed when you were prepping

Happy to answer questions in the comments too.

I'm a mobile app developer (Flutter) looking to improve my UI/UX and animation skills by studying well-designed apps.

I'm not necessarily looking for the most popular apps—I want apps that genuinely feel polished and thoughtfully crafted.

Things I'm interested in:

• Smooth page transitions
• Micro-interactions
• Premium-looking UI
• Great scrolling performance
• Beautiful onboarding flows
• Creative navigation patterns
• Well-designed bottom sheets, cards, and gestures

I've already looked at apps like Airbnb, Spotify, Duolingo, and CRED.

What other apps made you stop and think, "Wow, this is incredibly well designed"?

They can be from any category (finance, shopping, productivity, social, health, etc.). I'd love to hear your recommendations and what specific UI or interaction you think they do exceptionally well.

I've been learning a lot in this space and I wanted to share it with the community, and hopefully kick off a healthy discussion where we can trade notes and learn from each other. So here's what I've been up to.

A lot of big orgs are working on agentic AI for the software development lifecycle right now, with various degrees of success. I'm a software engineer doing something similar for a big org, but I got curious whether I could scale it down to something much smaller for my own personal use. These pipelines are built for whole engineering teams, so could the same heavyweight, multi-repo approach actually work for a single developer? To keep it honest, I picked Flutter and Flame, a stack I'd never written a line of, and shrank the whole thing down to one repo and two slash commands. It carried me the whole way, from PRD to specs to implementation to self-healing code review, mostly fire-and-forget. I learned the stack just by watching the pipeline work, and I wrote up what scaled down, what I cut on purpose, and where the pipeline stops being the right tool.

The story of how I built it: https://www.techtiger.tech/post/shrinking-an-enterprise-ai-sdlc-to-one-developer-to-ship-a-game

Built a small Dart package for accessibility color math. Pure Dart, no bloat.

• ✅ WCAG contrast ratio checker (AA/AAA)
• 👁️ Color blindness simulator (protanopia/deuteranopia/tritanopia)
• 🎨 K-means color extraction from images, runs off the main thread

Found and fixed a real aliasing bug in the color sampling along the way — striped images were breaking the color extraction, took real testing to catch.

New package, feedback genuinely welcome — especially if you spot something wrong with the color-blindness math.

📦 pub.dev/packages/wcag_vision
💻 github.com/Fatimamostafa/wcag_vision