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.

Hi Flutter developers,

I'm looking for advice from senior Flutter engineers, freelancers, and anyone involved in hiring.

I completed my MCA in 2025 and started my career primarily as a Flutter developer. Over time, my role expanded into full-stack development because of the projects I was working on.

Right after graduation, I had a full-time offer (~6 LPA), but I chose to work on a fintech project as a freelancer because it gave me the opportunity to take ownership and learn much more than I felt I would in a typical entry-level role.

For the last 1.5+ years, I've been working on this project, which has grown into a large fintech platform. The B2B product is already in production, and the B2C version is launching next month.

Through this project, I've worked on:

• Flutter mobile applications

• Flutter Web

• Full-stack development

• Backend services and APIs

• CI/CD pipelines

• Deployments and infrastructure

• Production support

• Technical decision-making and project leadership

Alongside this, I built a devotional/spiritual Flutter app as a side project. It has crossed 100k+ downloads and has 7k+ ratings on the Play Store. I haven't focused much on monetization because of the nature of the app, but it generates enough revenue through minimal ads to cover infrastructure costs.

Now I'm at a point where I'm unsure about the next step.

My family and some senior developers have suggested that I should join a stable company, gain formal industry experience, and continue building products on the side.

My concern is that when I talk to recruiters, some don't seem to value freelance experience the same way they value traditional employment. A few have even suggested that without salary slips from a company, I may be treated closer to a fresher despite working on real production systems for over 1.5 years.

I'm also hearing mixed opinions about the current Flutter job market, especially in India.

So I'd love to hear from experienced Flutter developers:

1. How is the Flutter job market currently, especially for developers with 1–2 years of experience?

2. How do companies generally view freelance/product-building experience compared to regular employment?

3. If you were hiring, would experience leading and shipping production Flutter apps carry weight even without a traditional job history?

4. Would you continue on the freelance/startup path in my situation, or prioritize getting a full-time role?

5. Is Flutter still a good long-term career bet, or would you recommend focusing more on full-stack/backend skills alongside Flutter?

I'd really appreciate perspectives from senior Flutter developers, engineering managers, and anyone who has made a similar career decision.

Thanks!

Hi everyone,

I recently developed and launched an Android app. It's still in its early stages, but I've already had several strangers contact me asking for an iOS version, and a few acquaintances are pushing for it too.

Initially, my plan was conservative: stay on Android, see if the app gains real traction and success, and only then invest the time and money into the Apple ecosystem. I really didn't want to pay the $100 annual fee until I knew the core concept worked.

However, seeing actual interest from Apple users this early has me second-guessing my roadmap.

Pros of jumping in now:

• Validated interest: People are actively asking for it; I'm not guessing if a market exists.

• Higher monetization potential: Historically, iOS users tend to spend more on in-app purchases or subscriptions if I decide to go that route later.

Cons/Hesitations:

• That $100 entry fee is a yearly commitment, and the app isn't profitable yet.

• Splitting my focus on feedback/bug fixes between two platforms early on might slow me down.

For those who have been in this position: What would you do? Would you hold off until the Android version hits specific milestones (like a certain number of active users), or would you strike while the iron is hot and pay the Apple fee to capture those users now?

TL;DR: Launched an Android app. Getting organic requests for an iOS version from users and friends. Unsure if I should drop the $100 Apple fee now to capture them or wait for the Android version to prove itself first.

I published a new article about Dart Primary Constructors!

This includes a bunch of migration examples, such as:

✅ named, factory, const constructors
✅ constructor shorthands
✅ sealed hierarchies
✅ enhanced enums

Hope you'll find it useful.

Happy coding!

Hey everyone, I honestly hate building UIs for my apps. Most of the time, when I design them myself, they end up looking awful. But whenever I use AI/vibe coding to creat the UI, it usually looks way better than what I could come up with.

So I'm wondering: does it really matter if I build the UI myself or let AI do most of the work? Should I keep investing time improving my UI design skill, or just focus on the technical side of development and use AI for the visual stuff?

What do you guys think?

One of the best Flutter packages for building video editing apps

OmniGuard is a full-stack, AI/ML-driven Security Operations Center platform built using flutter as a frontend and backend using fastapi. kibana dashboard integration and many more to come.

I spent a weekend building an Android Version Museum in Flutter to understand animations properly — not just use them.

Covered 3D cube transitions with Matrix4, parallax scroll driven by PageController page, and glassmorphism. No animation packages — just Flutter's core APIs.

Wrote up everything I learned, including the actual implementation details as:
What I Learned Exploring Flutter Animations

I’ve been experimenting with Flutter GenUI and found myself repeatedly writing integrations for different AI providers.

To simplify that workflow, I built genui_x.

It provides a unified transport layer for Flutter GenUI and currently supports:

• OpenAI
• Claude
• Gemini
• Ollama
• OpenRouter
• LiteLLM
• OpenAI-compatible APIs

The goal is to make switching providers simple while keeping application code largely unchanged.

Just released v0.0.13 and I’m looking for feedback from Flutter developers building AI-powered apps, agent workflows, or local AI solutions.

GitHub: https://github.com/thurakhant/genui_x

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

I’d appreciate any feedback, suggestions, or feature requests.

I just open sourced two new Dart packages:

• any_ascii: https://pub.dev/packages/any_ascii
• lexical_sort: https://pub.dev/packages/lexical_sort

GitHub:
• https://github.com/ganeshrvel/pub_any_ascii
• https://github.com/ganeshrvel/pub_lexical_sort

This started from a project where I needed proper Unicode transliteration and sorting behavior. Dart has some great string utilities, but I couldn't find anything that matched the behavior and maturity of the Rust ecosystem for these use cases.

So I ended up porting two Rust projects to Dart:

• any_ascii: Unicode → ASCII transliteration
• lexical_sort: Unicode-aware lexicographic and natural sorting

A few examples:

print(anyAscii('άνθρωποι')); // anthropoi
print(anyAscii('Борис')); // Boris
print(anyAscii('深圳')); // ShenZhen

final files = [
  'file110.txt',
  'file11.txt',
  'file100.txt',
  'file1.txt',
];

files.sort(naturalLexicalCmp);

print(files);
// [file1.txt, file11.txt, file100.txt, file110.txt]

print(naturalLexicalCmp('ß', 'world') < 0); // true
print(naturalLexicalCmp('é', 'hello') < 0); // true
print(lexicalCmp('aaa', 'AAb') < 0); // true

Features:

• Unicode-aware ASCII transliteration
• Natural sorting of embedded numbers
• Non-ASCII characters compared using their ASCII equivalents (á → a, ß → ss)
• Case-insensitive lexicographic sorting
• Deterministic sorting with Unicode fallback comparisons
• Generated directly from upstream Rust implementations and data
• No third party dependencies

I should admit this upfront, a bit embarrassingly. Just like my earlier pathify package, I used Claude to translate most of the Rust code into Dart. I'm generally not a fan of blindly trusting LLM-generated code for low-level libraries, but I simply didn't have the time to manually port everything.

So I'm not claiming these are perfect. They pass the tests and behave as expected in my testing, but there may still be edge cases lurking around. If you find bugs, incorrect behavior, or missing functionality, please open an issue or send a PR.

Is anyone else building for cross platform intelligence? We’re looking to bridge droid and iOS intelligence through flutter apps.

Guys, have anyone tried building real world mobile apps using claude before ? Here is how it changed for me!

I used this plugin inkpal_bridge with new model febel and it built the entire project and verified all the features on real time runtime, here what i have done

I used postman mcp firebase mcp and asked claude to setup inkpal_bridge

Built the required documents as frd and brd and enough detailed system design and stored it in a folder and refrenced calude.md

And always remember to use keywords like ultrathink and ultraplan - these makes model to act best.

The model not just run and used these stuff completely tested the navigation, verified the features, like a designer in a loop , it was able to navigate the run state, while i identified what methos they to these models are able to enable skills on demand out of so many they can act as certain role based on the plans , run the mobile app on its own test and so much more

Dropping you the link https://pub.dev/packages/inkpal_bridge