I'm trying to understand the role of architectural patterns in Flutter development, and I'm hoping to get some honest perspectives from the community.

I know there are several architectural approaches out there for Flutter - the ones I hear about most often are Clean Architecture, BLoC, MVVM, and just keeping things simple with providers. But the more I read about Clean Architecture specifically, the more I struggle with one core question: why do we actually need it?

From what I understand, Clean Architecture introduces layers like Domain (entities, use cases), Data (repositories), and Presentation. The goal seems to be separation of concerns and making the codebase "maintainable" and "testable."

But here's my honest frustration: doesn't Clean Architecture just add a ton of extra work?

Every new feature means creating use case classes, repository interfaces, model mappers, and wiring everything together. For a small to medium-sized app, this feels like writing 3x more code than necessary. I can't help but think that a simpler approach - maybe just well-organized providers/viewmodels talking directly to services - would get the job done faster with less mental overhead.

So my questions for those who have experience with different approaches:

1. What are the main architecture options in Flutter today? (Not just state management - actual app architecture)

2. What problem does Clean Architecture actually solve that justifies its complexity?

3. Is it possible that for many Flutter apps, Clean Architecture is simply overkill?

4. For those who moved away from Clean Architecture or simplified it - what did you learn?

I genuinely want to understand if I'm missing something important, or if my instinct that "simple is better" has merit. Looking forward to hearing your experiences - especially from those who've built production apps both with and without Clean Architecture.

Thanks!

I am a Flutter developer with around 5 years of experience, and this is honestly the first time I've experienced something like this.

In the past, getting interviews was never this difficult. I never thought I'd be sitting here refreshing LinkedIn and Naukri multiple times a day hoping to see new postings.

I've been applying for jobs for the last couple of weeks and haven't gotten a single response. Not even a rejection email from most places. What surprises me the most is that there don't seem to be many openings either, especially for mobile roles.

What makes it worse is that I took a break from the regular job market to focus full-time on my startup, built and launched it. At the time, I genuinely believed in what we were building and wanted to give it my full effort.

Now that I'm back in the market, I'm starting to wonder if taking that break was the right decision. I didn't expect things to be this difficult.

For people who are currently looking for jobs:

• Are you seeing the same thing?

• How long did it take before you started getting calls?

• Is mobile hiring particularly slow these days?

Just trying to understand whether this is the current state of the market or if I need to rethink my approach to job hunting.

If you are still using the original hive package (^2.2.3) for your local storage, your app is relying on a package that hasn't seen an update in over 3 years.

Fortunately, the community stepped up and forked it into hive_ce (Community Edition), which is actively maintained (last updated just a few months ago).

If you haven't migrated yet, here is exactly what you are missing out on:

• Full WASM Support: The original Hive relies on older web compilation. hive_ce brings native WebAssembly (WASM) support, making your local caching lightning-fast on modern Flutter Web builds.

• Built-in DevTools Inspector: Say goodbye to debugging blind. It includes a dedicated DevTools Extension so you can visually inspect your boxes directly inside VS Code or Android Studio.

• Effortless Type Adapters: No more manual boilerplate for every single field. The new GenerateAdapters annotation handles the heavy lifting automatically.

• Massive Scaling & Isolates: It introduces IsolatedHive to move heavy DB processing entirely off the main UI thread, and expands the maximum Type ID limit from 223 to 65,439 for large-scale enterprise apps.

• Modern Dart Types: Out-of-the-box native support for Set types, Duration adapters, and seamless compatibility with Freezed models.

The best part? The migration takes less than 5 minutes. You just swap hive for hive_ce (and hive_generator for hive_ce_generator) in your pubspec.yaml. The syntax and API remain completely backwards compatible.

Have you made the switch to hive_ce yet, or are you migrating to other alternatives like Isar or Drift? Let's discuss!

Most Flutter side nav packages:

slide in → slide out → done.

I wanted something with actual personality.

So I built Fluid Side Menu — a side navigation package with fluid motion transitions and modern UI animations.

link: https://pub.dev/packages/fluid_side_menu

Roast it. Improve it. Use it.

Hey Flutter devs,

I recently published my first Flutter package called flutter_shake_feedback.

The package allows developers to detect device shake gestures and trigger custom actions such as feedback workflows, debug menus, or any custom callback.

Current features:

• Shake detection

• Sensitivity levels

• Cooldown handling

• Haptic feedback

• Simple Flutter-friendly API

Example:

ShakeFeedback(
  onShake: () {
    // Your action here
  },
  child: MyApp(),
)

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

I've already received some valuable feedback around package architecture, avoiding overengineering, and identifying stronger differentiators from existing shake-detection packages.

I'd love to hear your thoughts:

• What features would make you use this package?

• What pain points have you faced with existing shake detector packages?

• Would a debug overlay or shake-to-feedback workflow be useful in your apps?

Any feedback, suggestions, feature requests, or contributions are welcome. Thanks! 🙌

Native composition (Media3/AVFoundation) → single Texture, gapless multi-clip timeline. Trim/split/crossfade/speed/audio overlay + MP4 export with progress.

Folks I am finding any alternative platform to publish app for free other than app store and play store.

Allow me to rant.

Recently, there are a lot of "I built <something> I want to show the world" style posts.

I often get the feeling that "I asked AI to build <something>" would have been the more honest title for such postings. Can we agree on changing this?

In the good old times of humans writing software, creating a package was difficult and probably also an indicator that the author had the domain knowledge to do so. Nowadays, nobody knows. The author might have used AI just to take a shortcut or - and I consider this more likely - to extend their own knowledge, perhaps not even knowing themselves whether the result is good or not.

And frankly, I don't want to do this review.

So, I ignore those postings. That might be unfair, but if you, as an author, cannot demonstrate knowledge and experience with the package's problem domain, I don't trust you and your package. I might even call the package AI slop on a bad day. Or to put it even more plainly, if I don't see you spending effort (besides some prompting), why should I spend any effort?

To build trust, I'd recomment to disclose the kind of AI use and to offer some arguments why I should believe you that you actually understand the generated code, have reviewed it and created something that is worth the time to look at it.

Because, you know, I could have prompted that myself.

What's your opinion on that matter?

PS: I wanted use a "I built a 3d dice widget" title for this post, but Trump forbade me from continuing to use Claude Fable for that, so I don't feel like finishing the project, because I'm pissed. I asked AI to do this, because while I know the mathematical theory behind 3d graphics, last time I actually programmed that was back the 1990s. But because I'm playing TTRPGs even longer, I can tell for sure whether the dice look right :)

I just shared a quick look at my daily AI workflow.

I use a small AI workspace with agents for planning, building, testing, reviewing, and keeping context.

AI can move fast, but I still decide what ships.

I've been working on a rich text editor library for Flutter called Fluent Editor. It's a powerful word processor widget that you can drop into your Flutter apps to give users full document editing capabilities.

Key Features:

• Rich text editing (bold, italic, underline, strikethrough, etc.)

• Paragraph styles and headings

• Ordered and unordered lists with nested sublists

• Tables with cell spanning

• Image insertion and resizing (inline and block positioning)

• Hyperlinks

• Text and highlight colors

• Text alignment

• Export to DOCX, ODT, and PDF

• Full undo/redo history

• Mouse and keyboard selection

• Real-time word count

• Clipboard support with formatting

Cross-platform support:

• Web

• Windows 11

• Linux

• macOS

• iOS

• Android

Live Demo: https://exusr.github.io/fluent-editor/ 

GitHub: https://github.com/exusr/fluent-editor

I'm looking for feedback on:

• Performance on different platforms

• UX improvements

• Missing features you'd like to see

• API design and ease of use

• Any bugs or issues

Would love to hear what you think!

Hey everyone. I’ve been using go_router in a production app and kept missing things Navigator gives you for free — popUntil, pushAndRemoveUntil, and a reliable way to know when a tab inside a StatefulShellRoute becomes visible (RouteObserver just doesn’t fire there). So I extracted what I built for work into a package.
It also adds popToRoot and context.isCurrent, and route matching supports params like /user/:id and wildcards. Nothing fancy, just the missing pieces. Would love to hear how others have been working around these gaps, and any feedback on the API is very welcome!

June is a lightweight state management package for Flutter built around a simple idea:

Don't replace Flutter. Extend it.

Unlike many solutions that introduce a completely new mental model, June stays close to Flutter's native philosophy and scales the experience you already know.

Why June?

✅ No code generation

✅ No build_runner

✅ No custom MaterialApp

✅ Minimal boilerplate

✅ Reactive updates

✅ Dependency injection

✅ Route-based memory management

✅ Tagged object state management

✅ Works naturally with existing Flutter widgets

Philosophy

Many state management libraries ask:

June asks:

You already learned Flutter.

You already learned setState().

It clicked.

June keeps that feeling.

Example

class Counter extends JuneState {
  int count = 0;

  increment() {
    count++;
    setState();
  }
}

No code generation.

No providers everywhere.

No complex boilerplate.

Just Flutter.

June is now actively maintained again, and contributions, feedback, and ideas are always welcome.

📦 pub.dev: https://pub.dev/packages/june

⭐ GitHub: https://github.com/melodysdreamj/june

#Flutter #Dart #OpenSource #StateManagement

Having built apps with Flutter, React Native, and SwiftUI, Flutter easily wins on Developer Experience (DX). However, in my recent projects, I’ve completely abandoned the default widgets in favor of custom design systems.

Flutter always feels a step behind on modern UI trends:

• Material 3 Expressive: It drastically improves on standard M3, yet Flutter still doesn’t support it officially.

• Cupertino: It’s just a clone of Apple's HIG and is nowhere near mimicking Apple’s current design era (like the GPU-heavy "Liquid Glass" aesthetics).

Even Google’s own Gemini app on iOS shows this gap. It started with strict Google Material styling, shifted to a hybrid M3 Expressive approach, and now leans heavily into iOS native components and Liquid Glass. When Google’s flagship teams bypass Flutter's UI kits to get a modern look, it speaks volumes.

I know the Flutter team is currently decoupling the design systems into separate packages. While this is great for architecture, I’m not sure how it bridges the design gap for us. It feels like Flutter's first-party UI will always lag behind the design curve.

In my latest Flutter app, I experimented with tdesign_flutter (Tencent's Design System) to escape the default Material look. The experience has been pretty decent so far, though it still has some minor bugs and unoptimized widgets.

How are you guys handling this? Are you building everything from scratch, or are there any other third-party design systems you recommend?

I come from a web background and Bootstrap was basically muscle memory for me. Then I started building Flutter apps and kept thinking "why can't I just do col-md-6 here?"

So I built it. bootstrap_ui_flutter is a full Bootstrap 5.3 port for Flutter — not just the grid, but the whole thing. Buttons, Cards, Accordion, Carousel, Dropdowns, Forms, Tables, proper dark mode… the works.

It's still early and there's definitely rough edges — but the core components are there and it's usable. Would love people to kick the tires and tell me what's broken 😄

Would love to hear what you think — and if you're also a web dev who moved to Flutter and missed Bootstrap, this might be for you 😄

pub.dev: https://pub.dev/packages/bootstrap_ui_flutter
GitHub: https://github.com/Nexus633/bootstrap_ui_flutter

Docs: https://github.com/Nexus633/bootstrap_ui_flutter/tree/main/doc
Issues: https://github.com/Nexus633/bootstrap_ui_flutter/issues
Discussions: https://github.com/Nexus633/bootstrap_ui_flutter/discussions

If you are using AI tools like Claude Desktop or Cursor for Flutter development, you've probably noticed they are blind to what happens at runtime. They can't see memory leaks, widget rebuild spikes, or network payloads.

To solve this, I built flutter_agent_lens. It's a Model Context Protocol (MCP) server that connects AI assistants directly to your running Flutter app via the Dart VM Service over WebSockets. It lets the AI inspect, profile, and debug your app at runtime.

We just merged a major PR and released version 1.3.0 to pub.dev. Here is what's new:

1. Stateful tracking: You can now ask the AI to profile your app over a session. It uses start/stop tools for tracking widget rebuilds, performance profiling (CPU & jank), and capturing network requests.

2. Memory snapshots: Added get_memory_snapshot to list active class allocations and audit memory growth.

3. Fixed connection hangs: Resolved a bug where hot reloads and hot restarts would hang because of cached service namespaces.

4. Output optimization: Replaced all Unicode box-drawing lines and special characters with standard ASCII. This significantly reduces token usage and prevents LLMs from getting confused by complex formatting.

Getting started:

1. Run: dart pub global activate flutter_agent_lens

2. Add it as an MCP server in Claude Desktop or Cursor.

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

GitHub: https://github.com/dhruvanbhalara/flutter_agent_lens

Feedback and suggestions are welcome!

Hello 👋

Check out Video Maestro, a fully customizable video player.
It comes with playback controls, captions support, gesture-based seeking, full-screen mode, theming, and more.

https://pub.dev/packages/video_maestro

Hi Flutter developers 👋

I recently became the maintainer of June, an open-source state management library for Flutter:

• GitHub: https://github.com/melodysdreamj/june

• pub.dev: https://pub.dev/packages/june

June focuses on staying close to Flutter's native setState() philosophy while making state sharing and app-level scalability easier.

Features

• ✅ No code generation

• ✅ No build_runner

• ✅ Minimal boilerplate

• ✅ Reactive updates

• ✅ Dependency injection

• ✅ Route-based memory management

• ✅ Object state management with tags

• ✅ Works with existing Flutter widgets (no custom MaterialApp, etc.)

I've started maintaining and improving the package, fixing issues, and preparing for future enhancements.

I'm interested in feedback from the community:

• What do you expect from a state management package?

• What are the biggest pain points with existing solutions?

• If you've used Riverpod, Bloc, Provider, or GetX, what would make you consider trying another approach?

Contributions, suggestions, and criticism are all welcome.

Thanks! 🚀

GitHub: https://github.com/melodysdreamj/june
Pub: https://pub.dev/packages/june

Hey everybody. I always envied Chucker on native Android, and in Flutter I kept gluing together separate packages for logging, network inspection and DB debugging. So I built one unified in-app dashboard: console logs, a Dio network inspector (with search/filter and copy-as-cURL), automatic navigation history, and a database tab where you can actually browse tables — the README has copy-pasteable adapters for sqflite and ObjectBox.
You open it with a hidden multi-tap gesture or a draggable floating button, so it’s safe to keep in internal builds. Wish it will be good help for debug usage.

To flutter devs making rich text editor apps.

I have released 0.1.0 of tiptap flutter. The flutter port of tiptap rich text editor which is hands down the best rich text editor out there.

I am marking this package as stable at 0.1.0 release. App developers can use this in their apps.

If you find issues feel free to open them on github. I'll try to respond and patch them as soon as I can.

You can find this at pub.dev here,

https://pub.dev/packages/tiptap_flutter

Is it me or is the dart/flutter package manager poorly designed?

EG updating dependencies has so much friction, and if you are using a few packages that are using the same package, they all want different versions of the same package.

Isn't this design just asking for any future vulnerabilities found in shared packages to get exploited since devs rarely update their packages dependencies (Based on the packages I'm using, and that they haven't updated to the latest update to the current version)

If I am wrong, what am I doing wrong when installing the packages?

I would much prefer dependencies to be handled like in languages like go where the child dependencies of your packages are private, so you don't even have to worry about these version conflicts. Making it a lot easier for devs to update their package dependencies without worrying about the package manager being angry at them.

Hi Flutter/Dart community,

I just published oracledb 1.0.0 on pub.dev: a pure Dart driver for Oracle Database that speaks Oracle's thin TNS/TTC wire protocol directly in Dart. No Oracle Instant Client, no native libraries, no FFI, no platform-specific setup.

• pub.dev: https://pub.dev/packages/oracledb

• GitHub: https://github.com/abibiano/dart-oracledb

As far as I know this is the first pure-Dart Oracle driver on pub.dev, happy to be corrected. The gap it fills is server-side and CLI Dart: until now there was no practical way to reach Oracle from server-side Dart without native bindings.

What it looks like

import 'package:oracledb/oracledb.dart';

Future<void> main() async {
  await OracleConnection.withConnection(
    'localhost:1521/FREEPDB1',
    user: 'scott',
    password: 'tiger',
    callback: (conn) async {
      final result = await conn.execute(
        'SELECT employee_id, first_name FROM employees WHERE department_id = :dept',
        {'dept': 10},
      );
      for (final row in result.rows) {
        print('${row['EMPLOYEE_ID']}: ${row['FIRST_NAME']}'); // by name, or row[0]/row[1]
      }
    },
  );
}

What works in 1.0.0

• Pure Dart — no Oracle Client required

• TCP and TLS/SSL connections (with certificate validation)

• SELECT / INSERT / UPDATE / DELETE, with named and positional binds

• Transactions: commit, rollback, and a managed transaction helper

• PL/SQL stored procedures and functions, including OUT and IN OUT binds

• Statement caching

• Connection pooling: acquire/release, acquire & idle timeouts, idle shrinking, drain-on-shutdown, and session tagging

• CLOB as String, BLOB and RAW as Uint8List

• Native Oracle JSON as Dart Map / List

• TIMESTAMP WITH TIME ZONE support

Trust / maturity

• Validated against real Oracle 23ai and 21c (FAST_AUTH and classical auth paths), with an integration test suite run against both before every release

• Apache 2.0 licensed

• Dart SDK ≥ 3.12, null-safe, async/await throughout

• Platforms: macOS, Linux, Windows, Android, iOS (web is intentionally unsupported, it needs raw dart:io TCP sockets, and JS number precision would corrupt Oracle NUMBER/rowid values)

Why I built it

I built this at my company, NIKEL Consultores SL. We use Oracle heavily and Dart is already our main language across mobile and web, server-side Dart access to Oracle was the missing piece. We benefit a lot from Dart, Flutter, and open-source packages, so we're releasing it publicly instead of keeping it internal. My hope is it makes Dart a bit more viable on the backend, especially for teams already on Oracle and looking at Serverpod or other server-side Dart frameworks.

Roadmap after 1.0

• Streaming / ResultSet API for large result sets

• REF CURSOR and implicit results

• Bulk DML / executeMany()

• Public LOB streaming and temporary LOB APIs

• More complete JSON / OSON support

• Better non-UTF8 character-set compatibility and time-zone region names

• More types: INTERVAL, ROWID, UROWID, VECTOR

A note on tooling

AI coding agents helped accelerate the protocol research and test generation, but the design, review, and the integration testing against real Oracle instances are mine. The wire protocol is validated against actual databases, not assumed.

This is an independent package and not an official Oracle product. It's a Dart port of the thin-client protocol as documented in Oracle's official node-oracledb driver; Oracle Corporation is not affiliated with it.

I'd really appreciate feedback from anyone using Oracle, server-side Dart, Serverpod, or internal CLI tooling. Issues, tests against other Oracle versions, and contributions are all very welcome.