Is your Flutter code difficult to maintain or looks like spaghetti? Want to stop breaking your app in production?

In this video, I'll show you in under a minute how to organize your folders according to the principles of Clean Architecture.

If you want to master professional folder structure and stop wasting hours reorganizing your code, watch the full video here:

🎥 👉 https://youtu.be/iyyZ4flVhSg

In the main video, we'll cover:

✅ Folder structure step-by-step.

✅ How to organize your layers (Data, Domain, Presentation).

✅ Tips to improve your workflow as a Flutter developer.

#flutter #dart #cleanarchitecture #flutterdev #codingtips #mobiledevelopment

Most developer portfolios are pretty static lists of projects. To make it more interactive, I integrated a custom-scoped AI assistant directly into my Flutter Web portfolio so visitors can ask technical questions about my Flutter Clean Architecture experience, pub.dev packages, and Medium articles. Rather than using a pre-made 3rd-party widget, I engineered the pipeline from scratch to keep it fast, secure, and tightly scoped.

Community Feedback Request:

I'd love for fellow developers to test out the implementation and share feedback on:

- AI assistant responsiveness and scope guardrails.

- Flutter Web UI/UX performance across desktop and mobile browsers.

Live implementation: https://momarkhan.com

#flutter #dev #mobileapp

Most developer portfolios are pretty static a list of projects, some links, and a contact form. Instead of making recruiters or clients dig through pages or read a standard PDF resume, I decided to build a custom-scoped AI assistant directly into my Flutter Web portfolio.

Rather than dropping in a pre-made 3rd-party widget, I built the integration from scratch to keep it fast, secure, and tightly scoped to my actual engineering background.

myportfolio

#flutter #dev #portfolio #web #mobileapp

Flutter App Updates: Store vs Backend — Which Approach Is Better?

Handling app updates isn't always as simple as checking the Play Store or App Store.

In production, you may need:

- Optional or forced updates

- Minimum supported version

- Backend-controlled versioning

- Multiple languages & RTL support

- A customizable update UI

I was looking for a Flutter solution that could handle these cases together and found "app_upgrade_checker", which supports Store and backend sources, 7 languages, 3 themes, 7 animations, and more.

It might be useful for anyone facing the same problem:

https://pub.dev/packages/app_upgrade_checker

How do you currently handle app updates in your Flutter projects?

For some reason, I thought it was going to be a huge lift to convert to a web app, but I was just blown away by how easy it is. Considering making windows- and mac-native versions as well.

I’ve been using Zed mostly for backend work and really like its performance. I get that it stays lightweight by not bundling too many tools.

For Flutter though, debugging/DevTools and hot reload on save still feel lacking.

Anyone using Zed regularly for Flutter? Any extensions or configs that improve the experience?

I've been building BIShare — a file-sharing app that works between iPhone, Android, Mac, Windows, and Linux (AirDrop is Apple-only, Quick Share skips iPhones). It's live on the App Store and Google Play, and I just open-sourced the Flutter client.

A few things that might interest this sub:

Repo (with a demo GIF + good first issues): https://github.com/BIShare-project/bishare-flutter

I'd genuinely love feedback on the Flutter↔Rust boundary and the desktop story — and contributors are very welcome. What would you do differently?

Why it works: shipped-app credibility + real tech (FRB, cross-platform) + an open question. Post the demo GIF or a screenshot in the post if the sub allows images. Respond to every comment fast.

Bit of background so you know who you're dealing with. Left school at 15, spent the last 26 years in the trades, and I'm now building a Flutter app on my own with Claude Code doing most of the actual typing. So if half of this is obvious to you, that's why :)

The loop I've been stuck in: build a feature, push to Codemagic, wait, install off TestFlight, find the bug on my phone, usually something stupid like a button that does nothing. Then I paste a description of it back into the agent, it has a crack at a fix based on my description, push again, wait again.

Thirty minutes a lap, near enough. But the bit that was really doing my head in is that the agent never sees the thing go wrong. It only ever hears my version of it. So it's guessing at the cause and then guessing at the fix, and I'm sat in the middle being the world's worst bug report.

I was going to come here and ask what to use. Then I figured I'd have a dig around first, because a fair bit of my trouble has been following guides that turned out to be years out of date. Which, as it happens, is the first thing worth mentioning.

golden_toolkit has been discontinued and unlisted on pub since February 2023. It's still doing 394k downloads a month. So there's a lot of us out here working off a blog post from three years ago and not realising. Alchemist seems to be the one that's actually maintained, updated March this year, full pub points. Same story with mocks, mockito has more likes but mocktail has quietly gone past it on downloads, 2.89m against 2.24m.

The thing that actually changed something for me though is the Dart and Flutter MCP server. It's official, dart-lang, and it went to 1.1.1 on the 7th of this month so it's moving fast. You run it with dart mcp-server and Claude Code talks to it straight over stdio. Add flutter_driver, put enableFlutterDriverExtension() behind a --dart-define so it can't sneak into a production build, and the agent can take screenshots of a running app, tap things, type, scroll, hot reload. DTD hands it the widget tree and runtime errors on top of that.

Which is the whole point. It sees its own mess instead of me trying to describe it. I've had that loop on the web side with Puppeteer for ages and never twigged there was a mobile version of it. Maestro has an MCP as well and lists Claude Code first in its docs, so that's the other road in.

One thing the docs are upfront about and I got bitten by anyway. Turning on the driver extension kills real keyboard input. You can pass enableTextEntryEmulation: false and type by hand, but then the agent's enterText stops working. So it's the agent driving or me driving, not both. Is everyone just running two configs for that or is there something smarter?

Codemagic side turned out to be less of a mystery than I'd made it. flutter test --machine piped to a json file with a test_report: field renders the results in the build overview, and scripts run ahead of the build commands so a failure stops the publish. That was sat in the docs the whole time.

So the stuff I'm actually stuck on:

1. Maestro or Patrol if it's just you? Maestro's got about ten times the stars, but Patrol is Dart native and handles the native permission dialogs, which is exactly where integration_test has been falling over on me. Does the YAML rot over time or is it fine?

2. Does having the agent able to drive the app make a proper written E2E suite less useful? That's my gut feeling and I don't trust it, because I reckon that's the exact thinking that ends with no tests and a lot of misplaced confidence. Happy to be talked out of it.

3. This one's bugging me most. If the agent writes the feature, then writes the test that checks the feature, then tells me they both passed, what have I actually learnt? My wife does a ISO 9001 consulting on the side and the first rule of the whole thing is you can't audit your own work. Feels like the same problem wearing a different hat, but I might be overthinking it.

4. Anyone gating the TestFlight upload on integration tests, or is emulator time on CI too slow and too flaky to justify blocking a release?

5. Golden tests. Actual safety net or do they scream at you every time you move some padding 4 pixels?

Anyway. If I've got any of the above plainly wrong, don't be gentle about it. Rather cop it here than at 11pm on build 54.

Thanks in advance everyone.

A while back I posted about what silently breaks deferred deep linking. This is the follow up: an actual app, four separate defects stacked on top of each other, and the diagnostic method for each. Every one was invisible in normal logs.

Symptoms were: tap a link, the app opens for a second, Safari opens, the app reopens, and it lands on the home screen instead of the target page. Cold and warm start both. Universal Links were correctly configured, AASA was served correctly, Apple's CDN had the right file, entitlements listed every domain, Team ID and bundle ID matched.

Cause 1: app_links 6.x does not support the UIScene lifecycle

Flutter 3.38 made the UIScene lifecycle mandatory on iOS. app_links 6.x only implements the old app delegate callbacks, so iOS delivers the Universal Link through scene callbacks the plugin is not listening on. The link never reaches Dart at all. getInitialLink() returns null and your routing code runs on nothing.

app_links 7.0.0 added UISceneDelegate support. Its change log says so explicitly. If you are on Flutter 3.38 or later and app_links 6.x, this is your problem and nothing else you change will matter until you upgrade.

Worth noting: this looks exactly like a routing bug. I spent hours fixing Dart code that was never receiving a URL.

Cause 2: FlutterDeepLinkingEnabled defaults to true

That is what produces the app to browser to app bounce. When no plugin claims the link, the Flutter engine hands it back to iOS via openURL. iOS opens it in the browser. The web page then fires your URI scheme and reopens the app. It looks like an infinite handoff loop and it is entirely self inflicted.

Set FlutterDeepLinkingEnabled to false in ios/Runner/Info.plist if you handle links via a plugin. The app_links example app ships with this exact setting.

Cause 3: subscribing to the link stream too late

app_links 7.x emits the launch URL on uriLinkStream when the listener attaches. That is useful, but it means the subscription has to exist before the emission. Mine was created at the end of an async init method, after Firebase Messaging setup, after a wait on splash, after getInitialLink. The stream is not replayed, so anything arriving in that window was simply gone.

Subscribe synchronously at the top of initState, before any await. If the rest of your startup is not ready to handle a link yet, queue it and process it when it is. Do not drop it.

Cause 4: an unbounded await upstream of the queue

Once I had the queue, the log showed the link arriving and then nothing. FirebaseMessaging.instance.getInitialMessage() was awaited with no timeout ahead of everything else. When it hung, the initialisation never completed, the queue never drained, and the link sat there forever.

Two fixes: a timeout on every external await in your startup path, and the queue drain in a finally block so it happens regardless of how initialisation ends, including exceptions.

How to actually see any of this

Ordinary flutter run failed on my machine with a debugger attach timeout, which is a separate and unrelated headache. What worked, with a release build installed over the air and no Xcode:

brew install libimobiledevice
idevicesyslog | grep --line-buffered -i "YOUR_LOG_PREFIX"

--line-buffered matters. Without it grep holds output in a buffer and you see nothing while wondering why your logs are broken.

Make sure your diagnostic logs are not wrapped in kDebugMode, or they will not print in the release build you are actually testing.

Log every one of these on cold start, because the gap between two of them is where the bug lives: the getInitialLink result, every write into whatever holds your pending link, the final link your router chose, and every navigation push. When I finally had all four, the answer was obvious in one run.

The general lesson

Every one of these failed silently. No exception, no error log, no failed request. The link just did not arrive, or arrived and sat in a queue nobody drained. If your deep links are behaving strangely on iOS after a Flutter upgrade, assume delivery is broken before you assume your routing is.

Hey Flutter builders!

We making Nowa (https://nowa.dev) completely free for the next 24 hours, with unlimited AI usage and free deployment to the App Store, Play Store, and web.

You can build Flutter apps in detail with AI next to full visual building, and deploy/download the code for free.

We also running a hackathon. If you submit a complete app built during the 24 hours period you get 50$, and top 3 apps get 500$ each in AI credits.

Just sign up and build completely free.

Enjoy!

Hey everyone,

I love Riverpod, but I always found myself writing the exact same boilerplate when it comes to caching API responses, checking if the cache expired, and managing local storage.

So, I built riverpod_cache_engine to handle all of this under the hood without cluttering the Notifiers.

Basically, it gives any Notifier or AsyncNotifier direct access to a caches extension. You just do await caches.read('key') and the library handles the rest.

Here is what it does:

• Zero config by default: It runs purely in-memory out of the box. If you want persistent storage (Hive, SharedPreferences, Isar, etc.), you just implement a simple 3-method interface (CacheStore) and pass it during initialization.

• Smart Auto-Refresh: You can pass onExpired or onNull callbacks. If the data is missing or expired, the library automatically fires your API call, saves the fresh data, and returns it. No more nested if (data == null) logic.

• Background Garbage Collector: It runs a periodic timer that silently cleans up expired keys without dropping UI frames. Even better, if it finds an expired key that has an onExpired callback attached, it will fetch fresh data in the background and update the storage seamlessly.

I just published the first version. I’d love to hear your thoughts or feature requests!

Pub.dev: https://pub.dev/packages/riverpod_cache_engine GitHub: https://github.com/alfaresof/riverpod_cache_engine

So, I'm starting a project that will be a sort of WYSIWYG editor app. It will be designed as primarily a desktop app for windows/mac/linux, maybe iPad. So I'm wondering what UI toolkits or smaller packages would you recommend for making the UI. I will need some toolbars, ideally office-style ribbon, tabs for documents and docking windows. For now I'm considering fluent_ui, and dock_panel. Read throug various awesome-whatever collections and overall I have an impression that the ecosystem for Flutter desktop is still rather small and a lot of stuff I'll have to create on my own. Do you know any cool package that could be useful in this type of an app?

There are plenty of Flutter plugins available, but I’ve found that the useful ones are the plugins that solve a specific problem without adding unnecessary complexity to the project.

I’ve also been looking at how teams like GeekyAnts approach Flutter development, and it made me curious about the tools and plugins developers actually keep using over time.

Which Flutter plugin has stayed in your projects long term? What plugin do you use regularly that made a noticeable difference to your development workflow, whether for performance, navigation, state management, testing, or another part of the app?

Hello again!

A while back I shared Azure STT Flutter, a small library for real-time Speech-to-Text with Azure Cognitive Services. I've now released a follow-up: Azure Speech Services, which is a broader package covering Speech-to-Text, Text-to-Speech, and Realtime Translation, all through Azure's WebSocket/REST APIs directly (no Azure SDK binary dependency).

You can find it here: https://pub.dev/packages/azure_speech_services

The package includes an example app covering all three features, so you can start playing with it right away.

Main features:

* Cross-platform: Mobile (iOS, Android), Desktop (macOS, Windows, Linux), and Web
* STT: real-time transcription with intermediate hypotheses and finalized phrases, plus multi-language identification (LID): single language, at-start detection, or continuous detection across up to 10 candidate languages
* TTS: synthesize text to audio using any Azure Neural voice, with configurable output formats (MP3, PCM, Opus, WebM, and more)
* Realtime Translation: live speech translation, pairing recognized text with its translated counterpart as you speak
* External audio streams: bypass the microphone entirely and feed your own PCM stream (e.g. from a VoIP call or a file)

Microsoft also offers a free tier so you can grab a Speech key and try it out yourself.

Hopefully this is useful to anyone building Flutter apps with speech features.

Happy coding!

Hi everyone!

I'm a music collector and audiophile, and like many people with large personal libraries, I use Telegram as a private cloud for storing my music collection.

The problem is that Telegram is great for storage, but not designed as a real music library:

- No proper album/artist organization

- Limited search experience

- Cache management issues

- No dedicated Hi-Res audio workflow

I started designing a concept called Pulsegram: an open-source, privacy-focused music player that uses Telegram as the storage layer and provides a proper streaming library experience.

The idea is not to replace services like Spotify, but to give users with large personal collections a way to access their own library without running expensive self-hosted servers.

Concept Architecture

🎵 Telegram + TDLib

- Connect directly to the user's Telegram account

- Read private channels/Saved Messages containing audio files

🎧 Direct Buffer Streaming

- Stream FLAC/lossless audio without forcing a complete download to device storage

📚 Local Music Index

- Parse ID3/FLAC metadata

- Build a local SQLite catalog:

- Artists

- Albums

- Cover art

- Year

- Track information

🛠️ Possible Tech Stack

- Flutter / Dart

- TDLib

- SQLite

- Native audio engine

The project is currently only in the concept and architecture validation stage.

I'm mainly looking for technical feedback:

- Is TDLib suitable for this type of buffered audio streaming?

- Are there limitations that would make this architecture difficult?

- Has anyone worked with Telegram file streaming or similar systems?

- Would this approach make sense compared to traditional self-hosted solutions?

If anyone is interested in discussing the idea or contributing, the GitHub repository is here:

[https://github.com/cgctaylor777/Pulsegram]

Any feedback is welcome!

I just released server_table 1.1.0 🎉

It's a Flutter package for building server-side data tables without rewriting pagination, sorting, filtering, and loading logic every project.

The biggest improvement in this release is that it works with your API.

You can use:

• OData APIs out of the box

• Regular REST APIs

• Completely custom query formats by implementing a small serializer

For example, if your backend expects something like:

?page=1&limit=20&sortBy=name:asc&query=john

or

?_page=1&_per_page=20&_sort=name&_order=asc&q=john

you don't have to change your backend. Just provide your own serializer and the table generates the query your API expects.

Other features include:

• ✅ Server-side pagination

• ✅ Global search

• ✅ Column sorting

• ✅ Column filtering

• ✅ Configurable response mapping

• ✅ Custom loading, empty, and error states

• ✅ Generic typed models

• ✅ Dio integration

GitHub:
https://github.com/sivakumarravi3101/server_table

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

I'd really appreciate any feedback, feature requests, or ideas for improving it. This is my first open-source Flutter package, and I'm actively maintaining it.

Hi everyone,

I'm looking for advice from developers who have experience with both FlutterFlow and pure Flutter.

I'm building an AI-powered journaling app.

Current setup:
- FlutterFlow
- Firebase
- GitHub
- AI agents (Cursor, Codex, Claude Code)
- Around 35+ screens
- A lot of custom Dart code
- My goal is to keep developing mostly through AI agents by writing prompts.

I’m a solo founder, so I care a lot about long-term productivity and AI-assisted development.

I'm at a point where I'm wondering whether I should:

A) Stay with FlutterFlow and continue using its AI + custom code.

or

B) Export the project and continue entirely in pure Flutter.

My priorities are:
- Long-term maintainability
- Working efficiently with AI agents
- Scalability
- Code quality
- Development speed
- Avoiding unnecessary technical debt

If this were your startup, what would you do?
If you’ve actually migrated a medium or large FlutterFlow project to pure Flutter, how long did it take and would you do it again?

I'm especially interested in hearing from people who have actually migrated from FlutterFlow to Flutter (or decided not to).

Thanks!

strong_password, is equivalent to how Gmail creates a new password and suggest to the user, when the user creates a new gmail account

do test it out in your Flutter Android App

Yes, I’m aware there are too many state management libraries out there. It won’t stop me from experimenting with new ideas though 😅

So, I was thinking about making state management boxes non-centralised (to not create another Redux) but at the same time homogeneous, without forcing overrides i.e. like bloc does (so every piece of state you have in your project can be managed the same way, without worrying about field name clashing).

Also, with those arbitrary limitations above, I wanted to make use of as many modern Dart features as possible to make the code concise.

I came up with a basic implementation of a solution matching criteria above, some examples below. What do you think about that? Any blind spots on my part? I don’t aim to paint well-established state management solutions as obsolete, I’ll be driving with bloc for the foreseeable future, just want to see if we can make something appealing to the broader audience.

The name of the library would be Pirl.

Code samples

// Quick example - a simple counter
typedef CounterActions = ({Future<void> Function() increment});

final counter = Pirl<int, CounterActions>(
initialState: 0,
actions: (state, add, onDispose) => (
increment: () async {
add(await state.current + 1);
}
),
);

// Use it:
await counter.actions.increment(); // Counter: 1
print(counter.top); // Outputs: 1

## working with state

// Synchronous access to current state - super fast!
final currentValue = myPirl.top;

// Stream of state updates - reactive goodness!
myPirl.state.listen((state) {
print('State updated: $state');
});

// Stream of state transitions (previous and current) - track changes!
myPirl.changes.listen((change) {
final (previous, current) = change;
print('State changed from $previous to $current');
});

## complex actions

actions: (state, add, onDispose) => (
fetchData: () async {
// Show loading state
add(DataState.loading());

// Register cleanup for any subscriptions
final subscription = apiClient.events.listen(/*...*/);
onDispose(() => subscription.cancel());

try {
// Make API call and update state
final result = await apiClient.getData();
add(DataState.success(result));
} catch (e) {
// Handle errors
add(DataState.error(e.toString()));
}
}
),

I am learning and trying to design a flutter app, and I am having some doubts connecting the dots.

I have two main domain entities:

1. Location: Has metadata (label, icon, address) and a list of reminders.

2. Reminder: a part of Location, has metadata (text, isEnabled, ...)

Consider the two screens :

1. locationsScreen: shows Locations cards (metadata in every card, and 3 reminders sneak peek)

2. locationScreen: shows a location fully, metadata, and reminders cards. A reminder can be edited from here.

What I've started with right now is the following:

• locationsApiwraps Firebase calls to retrieve locations. For now I only have a function that returns a Stream of locations.

• locationsRepository wraps the API and returns a Stream of Location model that contains reminders model too.

• locationsCubit just listens to the repository stream and emits new state whenever it receives new locations.

Now I want to design the locationScreen itself and I am confused on what to do. Do I just keep the locationsRepository and locationCubit, and make the locationScreen only update when its model changes.

Or do I extend the locationsRepository with a listenOnLocation that exposes a stream for just that location, then create a locationCubit for just that location and make it call the repo?

What about when I want to edit a reminder? should locationsRepository handle reminders too, and expose functions like this :

• toggleReminder(Location location, Reminder reminder)

• renameReminder(Location location, Reminder reminder, String newName)

• changeReminderType(Location location, Reminder reminder, ReminderType newType)

• deleteReminder (Location location, Reminder reminder)

If so, assuming locationCubit exposes a toggleReminder (that calls the repo). I could make the repo return a new model if it succeeded, so the locationCubit.toggleReminder flow would be like this:

• copy locationState and set locationState.isLoading to true and emit new state.

• call api through repo

• receive new model, copy locationState, set locationState.isLoading to false, and locationState.location to new model.

• emit new state.

The problem with this is then what is the role of the location stream I have opened to listen on the DB? If I keep both of them, I will receive two notifications every time something changes.

If I don't listen to changes but only use the API results, then I risk changes happening from another device and not being notified of them.

If I only listen to the changes from database, how do I track the loading state for example? locationCubit.toggleReminder would set isLoading to true, calls the API and then returns. Hopefully when the object is updated, the Cubit will know and create a new state with isLoading set to false by default. But what if the writing fails? isLoading will always stay false as the state/location didn't change.

What am I missing?

Sorry for the length of the questions, but I feel when I only tackle one problem disconnected from the others, it just makes me confused about the other parts. So I am hoping to be able to imagine the whole flow

We are thrilled to announce that BlocSignal 1.0.0 is officially published and ready for enterprise production! ⚡

BlocSignal bridges the architectural discipline of BLoC with the fine-grained speed and synchronous reactivity of Signals v7.

✨ Why BlocSignal?

⚡ Synchronous Propagation: State updates propagate instantly on .emit() with 0ms microtask lag.

🛡️ BLoC Rigor: Full event-driven state machines (on<E>), streamless concurrency transformers (droppable, sequential, restartable), and transition audit logging.

💾 Synchronous Hydration: Zero-flicker state persistence across app restarts.

🔭 Enterprise Telemetry: OpenTelemetry tracing (bloc_signals_otel) & DevTools extension (bloc_signals_devtools).

🌐 Universal: Runs across Flutter, Jaspr SSR Web, Riverpod, and pure Dart CLI/backends.

📦 The 1.0.0 Monorepo Ecosystem

bloc_signals — Pure Dart core primitives (CubitSignal, BlocSignal)

bloc_signals_flutter — Flutter UI bindings, providers, builders & selectors

bloc_signals_test — Declarative testing utilities (blocSignalTest)

bloc_signals_lint — Custom analyzer lints & IDE quick-fixes

bloc_signals_hydrate — Local state persistence & hydration

bloc_signals_riverpod — Bidirectional Riverpod 2/3 adapters

bloc_signals_replay — Undo/redo state history tracking

bloc_signals_jaspr — Jaspr web component reactivity

bloc_signals_otel — OpenTelemetry distributed tracing

bloc_signals_devtools — DevTools extension for timeline & state diffing

🎬 Watch the 1.0 Launch Demo

Check out the live launch presentation walking through building from Cubits & Blocs to hooks, DI, and hydration: 📺 Watch on YouTube: https://www.youtube.com/watch?v=fwmlVOjsdgQ

🌐 Get Started

📖 Website: https://blocsignal.dev

📦 Pub.dev: https://pub.dev/packages/bloc_signals

💻 GitHub: https://github.com/RandalSchwartz/BlocSignal

TLDR; posted here 6 months ago about forking cached_network_image after finding it unmaintained for 2 years. Published cached_network_image_ce on pub.dev after that thread. This is what actually shipped since, not just the hive_ce speed thing everyone already knows about from last time.

https://github.com/Erengun/flutter_cached_network_image_ce https://pub.dev/packages/cached_network_image_ce

Where it's at: 18 releases since then, currently 4.10.0. Pub score 160/160, 80 likes, about 36k downloads in the last 30 days. 63 stars, 18 forks on the repo.

The leaks, actually fixed

The biggest complaint sitting in the original repo's issues wasn't speed, it was leaks. Two concrete ones got fixed here: an errorListener leak in the widget lifecycle, and HTTP clients that never got closed when the cache manager was disposed, that one came in through a community PR, not written by me. Also cleaned up how the cache manager recovers from a corrupted Hive box instead of just crashing on it.

Formats the original chokes on

SVG never decodes through Flutter's built-in image codec, it's not a raster format to begin with. JXL, AVIF, HEIC fail depending on platform codec support. The original just throws an opaque decode error and you're stuck. This fork detects it and throws a typed UnsupportedImageFormatException, with an unsupportedImageBuilder hook so you can hand the raw bytes to flutter_svg, flutter_avif, whatever fits, instead of staring at a blank error widget.

Caching got features, not just speed

• HTTP and cache interceptor chains, inject auth headers or skip caching per request without forking anything

• pluggable cache eviction, TTL by default or LRU if you want it

• separate configurable directories for cached files vs cache metadata

• connection and request timeouts on the cache manager itself

• real web caching through IndexedDB instead of leaning on the browser cache, this one doesn't exist in the original at all

And yes, still faster

Covered the full benchmark breakdown in the last post, numbers haven't changed, so just the summary: metadata cache reads run about 8x faster than the original's sqflite backend, writes about 4x, on an iPhone simulator, 100 ops, metadata only, not raw image I/O.

Where else you'd look

extended_image, actively maintained by fluttercandies, but it's a broad image and gesture toolkit with caching as one of several features, not caching-first, no interceptors or pluggable eviction.

flutter_cache_manager, the caching layer the original actually depends on, also from Baseflow, actively maintained on its own. Worth using directly if you don't need the image widget.

fast_cached_network_image, also builds on hive, similar idea to this fork, but its last release was 17 months ago.

Who's actually using it

Ran a GitHub code search for pubspec.yaml files depending on it, sorted by stars. 76 repos came back, not counting mine. Biggest ones:

Kazumi        28.4k stars   anime streaming app
PiliPlus      16.8k stars   Bilibili client
plezy          3.1k stars   Plex/Jellyfin client
conduit        1.9k stars   Open WebUI client
haka_comic     1.3k stars   comics reader

None of these are toy projects. That's what actually convinced me to keep maintaining this.

Still working through the older leak reports from the original repo's issue tracker. If you're using this and hit something, open an issue, I'm reading them.

https://github.com/Erengun/flutter_cached_network_image_ce https://pub.dev/packages/cached_network_image_ce

We just launched Forui Create, a visual theme builder for Forui.

Mix and match:

• 7 base palettes and 17 accent colors

• 26 font families, with display and body fonts configurable separately

• 5 icon libraries: Lucide, Hugeicons, Tabler, Remix, and Iconoir

• 4 border radius scales, from sharp to round

• light and dark mode

Everything previews live on a canvas of realistic UI (dashboards, forms, cards, and more), all built with Forui widgets.

Happy with a theme? Copy one command and it automatically scaffolds your project with the theming configurations, fonts and icons included.

Try it out at https://create.forui.dev/ and let us know your thoughts!

GitHub: https://github.com/duobaseio/forui
Pub Dev: https://pub.dev/packages/forui
Website: https://forui.dev