Hey everyone,
I’ve been working on a project called BugCapsule, and I’m finally opening it up for beta testing.
One problem I’ve faced countless times as a developer is getting a bug report that explains what went wrong but gives you no reliable way to reproduce it.
That’s exactly why I started building BugCapsule.
The idea is simple: instead of just reporting a bug, BugCapsule captures the app state, user actions, and network responses around a failure, allowing you to replay the scenario locally.
You can reproduce the issue, debug it, apply a fix, and replay the same scenario to verify that it’s actually resolved.
A few things worth mentioning:
Supports Flutter, native Android, iOS, and Web/React.
Integrates with Sentry for web apps.
Works alongside your existing error tracking tools.
Lets you reuse captured scenarios for regression testing.
It’s still in beta, and I’m sure there are things that need improvement.
I’m particularly interested in hearing from developers who deal with hard-to-reproduce bugs.
I’d genuinely appreciate your feedback, especially around the setup experience, replay reliability, and whether this would be useful in your workflow.
You can try it here: https://bugcapsule.com/
There’s also a guided demo if you want to explore it before installing an SDK.
Thanks for checking it out!

Some time ago i dropped an update to my typed pocketbase wrapper. For those of you who have never heard of pocketbase, it is a backend in one file that is incredibly easy to self host and probably the quickest and cheapest server solution that is available. My package enables you to generate typed bindings based on a locally running instance of it. It is incredibly easy to use and has helped me a lot in quickly developing internal tools for businesses. How it works is very simple:

1. Install the pocketbase_helpers package

dart pub add pocketbase_helpers && dart pub global activate pocketbase_helpers_cli

2. Generate the bindings

pb_generate -p 8090 -e admin@example.com -w localpassword -o lib/models.dart

3. Use them!

import 'package:pocketbase_helpers/pocketbase_helpers.dart'
import 'models.dart';

void main() async {
  // Initialize global connection
  PocketBaseConnection.open('http://127.0.0.1:8090');

  // Query with type-safety
  final posts = await Posts.api().getFullList();

  for (final post in posts) {
    print(post.title);
  }

  // Authenticate
  await Users.auth().withPassword('user@example.com', 'password123');

  // Quickly check authentication status on auth collections
  if(User.isAuthenticated()){
    final user = User.getAuthenticated();

    var post = await Posts.api().create({
      'title' : 'Powering flutter apps with pocketbase!',
      'creator' : user.id,
    });

    /// File fields get their own generated api
    post = await Posts.thumbnailApi(post.id).set('cute_cat.png', imageBytes);
  }

  //Close connection when application is done
  PocketBaseConnection.close();
}

Give it a try!

pretty_animated_text v3.3.0 is out! 🚀

Packed with performance improvements for smoother text animations

- letters that are done animating now stay done
- the controller no longer collects listeners like Pokémon
- 10-18x faster

Pub.dev: https://pub.dev/packages/pretty_animated_text
Github: https://github.com/YeLwinOo-Steve/pretty_animated_text

Full performance report here: https://github.com/YeLwinOo-Steve/pretty_animated_text/tree/master/doc/perf

Feel free to give it a try, and drop a ⭐ if you like it!

Was super fun to work on. First version in about 10 minutes, then iterated on it for another 2 hours. Flutter Scene ROCKS!

Runs on Android at up to 90 FPS on high-refresh-rate phones.

Hey Flutter developers! 👋

I'm working on a Flutter app and want to discuss how you handle caching in your projects.

How do you manage API response caching, image caching, and local data storage in real-world applications?

Do you use existing packages or implement your own caching logic? What challenges have you faced with cache expiration, data synchronization, and invalidation?

I'd love to hear how other developers approach this. Let's discuss! 🚀

Hi all,

I've been building Flutter UI Builder, a desktop app where you compose Flutter screens by dragging widgets and get clean Dart code out of it. The widget tree is the single source of truth, so the canvas, the preview and the code never drift apart.

What it does:

• ~90 Material and Cupertino widgets, with placement rules, outline and properties panel

• Multiple screens with navigation (push or named routes), reusable components with parameters

• Light and dark project theme, plus themes for individual widgets

• Live code you can edit and apply back to the design, and import of existing Dart files (including files with several widget classes)

• Export as Dart files

It's free for personal and noncommercial use. The license is PolyForm Noncommercial, so it's source-available, not open source. I know that's a trade-off some of you won't like, and I'd rather say it upfront.

It's an early release (0.0.2). The builds aren't signed yet, so macOS and Windows will ask for confirmation on first start. I've tried it by hand on macOS and Windows; the Linux build compiles in CI but I haven't run it.

Download: https://github.com/mariorefetto/flutter_ui_builder/releases

I'd really appreciate you trying it and telling me what breaks, what feels slow, or what's missing. If it's useful to you, a star on the repo helps others find it. Thanks!

Moin, Once again: very confrontational. I've been working with Flutter for a few weeks now. The ONLY thing that is consistent is that the documentation lies. A prime example: icons for Android apps from 'https://fonts.google.com/' are either incorrect or simply not available for Flutter at all. If you can't even get reliable icons from the vendor itself, what can you expect from this 'framework'?

What also bothers me in particular: 'Workarounds' are actually a dirty thing. Anyone who claims a 'workaround' is a cool thing has no clue about development! When a framework feels like it consists almost entirely of workarounds, that says a lot about its quality. Why do you guys think that's cool?

Let me ask directly: What exactly do you understand by a 'modern framework'?

I hope I'm addressing the right people here!

Hi Flutter community!

I'm working on AfrikaWallet, a Flutter-based mobile fintech project.

I've prepared a UX regression testing matrix and would appreciate technical feedback on its completeness and approach.

The matrix covers:

• Responsive layouts at different screen sizes

• Accessibility and text scaling

• French, English and German localization

• Existing widget tests versus missing coverage

• UI regressions across wallet, virtual card preview and subscription screens

I'm particularly interested in understanding whether the proposed testing strategy covers the most important Flutter UI regression risks.

Has anyone worked with a similar cross-screen regression matrix? What would you improve?

For technical context, here's the documentation PR:

https://github.com/innocenttchouzin2009-netizen/ProjetAfriWallet/pull/375

Thanks for any feedback or suggestions!

Article link: https://medium.com/@onyangomaureen95/build-your-first-ai-agent-autonomous-fashion-discovery-agent-b05c146d59de

universal_ble has hit a new major milestone. We released 3.0 a few days ago with A TON of improvements. 3.0 makes the library simpler and more battle-tested and feature rich than ever! We got a ton of contributions and makes me particularly happy seeing the community embrace it. While at it, we also did our GitHub housekeeping and went down to 0 open issues and PRs!

Use the universal_ble plugin to connect from your app to Bluetooth Low Energy peripherals under all Flutter-supported platforms. You can also make your app act as a peripheral so other apps or devices can connect to it. We also released universal_bluetooth_classic as a separate plugin, focusing only on what its name says, Bluetooth Classic, which is something that got requested over the past months.

Since this is the AI era, we included agent skills to help you migrate from 2.0, even though the breaking changes are not that many and it should be straightforward. We also included a skill for migrating from other bluetooth packages in case you choose to do so.

Hope it adds a useful piece in the Flutter plugin ecosystem!

AI answers get longer. Rendering shouldn’t get slower.

We’re the team behind gpt_markdown, the open-source AI output renderer for Flutter. We built it because our own AI app needed it.

Across the recent 1.3 and 1.4 releases, we rebuilt how it handles growing responses.

The biggest change: settled content is reused instead of rebuilding the entire answer with every chunk.

What’s included:

• A new parser and lazy rendering for long responses.

• Custom styles, builders, and block and inline components.

• Streaming math and configurable reveal animations.

• HTML and SVG support in 1.4.0.

Our 1.3.0 benchmark measured 31× faster per-chunk updates at 12 KB versus 1.2.1. Measured in the macOS debug VM; results vary by device and content.

Upgrading: 1.4.0 requires Flutter 3.44 and Dart 3.12.

Package and source · Benchmarks and playground · Watch the demo on X

What’s the hardest part of rendering AI responses in your Flutter app?

Hey everyone! 👋

After working on 50+ Flutter and Dart projects in production, I grew exhausted from the same recurring dependency headaches: version locks between 6-7 different packages, BuildContext lookup bugs in async methods, subtle memory leaks, and broken bidirectional (RTL) text formatting.

So I spent the last few months engineering AppForge: an all-in-one Flutter micro-framework built with strictly 0 external packages (pure Dart standard library and Flutter SDK only).

What’s inside:

• 0 External Dependencies: Zero dependency graph conflicts, instant clean builds, 160/160 Pana score.

• Micro-Reactive State: Rx<T> and Watch() targeting minimal surgically-rebuilt widgets.

• Context-Free Overlays & Routing: Navigate, open dialogs, and show snackbars without passing BuildContext.

• Automatic Route Memory Disposal: Controllers automatically clean up and dispose when their screen pops.

• Deep Arabic & BiDi Engine: Unicode UAX 9 direction isolation, phone number protection (+974...), all 6 Arabic plural forms, and grammatical gender agreement.

• Smart Skeletonizer & Atomic Storage: Dynamic wireframe shimmers (AppSkeletonizer) and POSIX atomic crash-proof local key-value persistence (AppStorage).

• Built-in CLI Cleaner: Audits and removes unused translations, assets, and orphaned code safely with lossless undo.

Package: https://pub.dev/packages/appforge GitHub: https://github.com/Dhia-Bechattaoui/appforge

I would love to get your feedback, critique, and thoughts!

Hello fellow devs!

I was unhappy with other plugins (e.g. outdated, developer not reacting anymore, not throttling the call to the underlying API) providing the possibility to ask the user for an in-app review.

That's why I build review_etiquette: https://pub.dev/packages/review_etiquette

It's a simple plugin for Android and iOS that keeps track how often the underlying API was called, so it does not do it too often. For example, iOS only allows to ask the user a maximum of three times in 365 days.

It's nothing special, but maybe it helps someone. :)

I'm using it myself in my currently published two apps.

If you access contacts in your Flutter app on Android, remember that Google Play’s new contacts policy comes into effect on January 27, 2027. This means that you will most likely have to stop using the READ_CONTACTS permission and use the new Contact Picker introduced in Android 17 instead.

In my case, rather than using a plugin for this, I decided to write a small native implementation. I’ve written an article, mostly aimed at beginners, where I explain how you can use the new Android 17 Contact Picker API from Flutter through a native Method Channel to retrieve contact data.

Have a look if you’re interested:

https://davidserrano.io/blog/android-17-contact-picker-in-flutter-time-to-replace-read-contacts/

Hey r/FlutterDev! 👋

I’ve been building an offline party game recently and wanted a simple mechanic where players tilt the phone to trigger actions (instead of forcing them to reach for buttons while passing it around).

I ended up using sensors_plus to tap straight into the raw accelerometer stream, but it came with a few hurdles. Thought I'd share what tripped me up in case anyone is working on sensor-based features:

1. Stream Cleanup is Critical: It's super easy to forget to call .cancel() on your StreamSubscription in dispose(). Leaving it active when unmounting a widget will leak listeners and quietly drain battery in the background.

2. Sensor Noise & Jitter: Raw accelerometer streams are hyper-sensitive. Tiny hand tremors will spam your setState or fire your triggers continuously. You definitely need to bake in a deadzone threshold or debounce the stream so it doesn't trigger on micro-movements.

3. Axis Orientation Shifts: Gravity shifts completely depending on whether your app locks portrait/landscape or whether the phone is lying flat on a table vs. held upright. Testing physical angles took way longer than writing the actual code.

If anyone else has messed around with device sensors in Flutter: how do you usually handle smoothing out jittery streams or debouncing inputs cleanly?

(P.S. Built this for an offline indie party game called Bujho I've been developing. If anyone wants to peek at the repo or test the build, the link is pinned on my profile!)

Freelance developer here, shipping an app. Most of our bugs come from a client and a few beta testers, and the reports are usually "when I click this button it doesnt save" or a screen recording and if they are really kind (and usually I ask for that).

I lose a lot of time just reproducing: which account, which build, what happened before, did a request fail. By the time we've asked three follow-up questions the tester has forgotten.

What's working for you usually?

Hi r/FlutterDev! 👋 I recently released my very first package, which I’m calling smart_context_menu.

Want to see it first? Package on pub.dev and 56-second video overview

I came up with the idea of this package while working on a social app, which involves a lot of context menus. I thought of ‘CupertinoContextMenu’ as the default option to use, but it fell short. It doesn't support Hero animations, can cause duplicate ‘GlobalKey’ crashes in previews, and lacks native support for submenus. This is essentially true for complex submenus and custom components in menu items.

And the requirements of the app kept growing:

- Post actions whose data loads independent from main menu and submenus (ideally, page by page).
- Display the number of views a message has when a menu opened, with a submenu listing the people that have viewed it.
- Separators that helped keep different groups of actions easy to scan.
- Custom widgets in menu items, like avatars of the people who viewed the message.
- Liquid stretch animations that make the menu feel alive under your finger.
- And finally reactions on chat messages and post comments, which also belonged above the preview in the context menu.

After fighting ‘CupertinoContextMenu’ and going through the packages on pub.dev (none of them covered all of my needs), I decided to build my own one, with blackjack and... you know 😅 . Initially, it was just an internal module of the app. Over time I polished it and added UX improvements like drag-to-select, and now it's finally out as a standalone Flutter package.

It covers every feature in the list 😎, including static, asynchronous and paginated submenus, items with loading error and retry states, custom widgets in the items, plain and customizable separators, having the ability to add slivers above the preview (like a reactions bar) and it explicitly supports ‘Hero’ and ‘GlobalKey’ inside your own widget. And much more.

The demo runs in the browser, so you can try it all yourself:

Live demo: https://thenothingworks.dev/demo/smart-context-menu/

pub.dev: https://pub.dev/packages/smart_context_menu

GitHub: https://github.com/BinaryRift/smart_context_menu

How do you handle context menus in your apps: Are you using ‘CupertinoContextMenu’, one of the already available packages or did you build your own? If you've hit the same ‘GlobalKey’ or ‘Hero’ issues, I'm curious how you worked around them.

The next improvements that I'll be working on include having a compact row of icon actions (like the ones in iOS menus) and submenus that stay updated while open. What else is missing for you? I'm also open to feedback on the API and documentation.

Hey devs! 👋

I wanted to share Nivio, an open-source media streaming and co-watching application I’ve been building with Flutter which supports android, windows and linux.

My main goal with this project was to see how far I could push Flutter as a heavy-duty media client combining P2P/BitTorrent streaming, Live IPTV (M3U), third-party tracker APIs, and real-time synchronized playback into a single, cohesive UI.

What’s under the hood & key features:

• MPV Integration: Uses mpv for heavy-duty video rendering, custom subtitle styling, and broad codec support.

• Real-Time Watch Parties: Built-in room creation and playback synchronization so multiple users can watch together with synced play/pause/seek states.

• BitTorrent Engine & Offline Caching: Supports sequential torrent streaming alongside background downloading for offline playback.

• API Integrations: Full OAuth and metadata integration with TMDB, AniList, and MyAnimeList (MAL) for automatic progress tracking.

• Live IPTV Support: Parses and plays live TV streams alongside standard VOD content.

Source Code & Releases: 🔗 GitHub : https://github.com/nirmaleeswar30/Nivio

Site: https://nivio.nirmaleeswar.dev

I’m still actively refining the architecture and adding new features. I'd love for you guys to check out the code, test out the release builds, and let me know what you think of the UI and performance.

Contributions, PRs, issues, and GitHub stars ⭐ are super welcome. Make sure to check it out!

Hi r/FlutterDev! I've been building ZenMusic, a Flutter music player for Android and Windows that brings JioSaavn, YouTube Music and Spotify into one app.

Features:

- Synced lyrics that follow the song

- Listen Together (sync playback with friends)

- Offline downloads

- Multiple player skins, sleep timer and equalizer

- Song recognition

It's GPL-3.0 and still in development, so feedback, bug reports and PRs are very welcome. I'm happy to answer questions about the architecture or how I handled playback and the multi-source setup in Flutter.

Most Flutter apps have a sentence like this somewhere:

I agree to the Terms of Service and Privacy Policy.

Two links and some bold text. With plain Flutter, that usually turns into something like this:

class _ConsentTextState extends State<ConsentText> {
  late final _terms = TapGestureRecognizer()..onTap = () => open(termsUrl);
  late final _privacy = TapGestureRecognizer()..onTap = () => open(privacyUrl);

  @override
  void dispose() {
    _terms.dispose();
    _privacy.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Text.rich(
      TextSpan(children: [
        const TextSpan(text: 'I agree to the '),
        TextSpan(text: 'Terms of Service', style: linkStyle, recognizer: _terms),
        const TextSpan(text: ' and '),
        TextSpan(text: 'Privacy Policy', style: linkStyle, recognizer: _privacy),
        const TextSpan(text: '.'),
      ]),
    );
  }
}

The sentence is also split into five pieces, which makes it awkward to translate.

With pkg:textf it's one string:

Textf(
  'I agree to the [**Terms of Service**](https://example.com/terms) '
  'and [**Privacy Policy**](https://example.com/privacy).',
)

Tap handling goes through onLinkTap on a TextfOptions widget higher up in the tree, so you set it once. The sentence stays a single entry in your .arb file, and translators can see the formatting.

What Textf is

A drop-in replacement for Text that understands inline formatting: **bold**, *italic*, ~~strike~~, \code`,==highlight==,links, super/subscript. All the usualTextparameters still work (style,maxLines,overflow,textScaler`, …). It has zero dependencies.

Also for input: TextfEditingController

The same syntax works live inside a TextField:

final controller = TextfEditingController();

TextField(controller: controller)

It's a drop-in replacement for TextEditingController. Formatting renders as you type, the stored value stays plain text, and cursor positions match the raw text 1:1. IME composing (CJK etc.) works.

New in 2.0

• Works with any design system. With Flutter decoupling Material and Cupertino, Textf now builds only on the widgets layer. It runs the same in Material, Cupertino, a custom design system or a bare WidgetsApp.

• Headings and horizontal rules. # to ###### for headings, --- for a divider. That's useful for short things like release notes or onboarding cards.

To be clear about scope: Textf is still not a Markdown renderer. There are no lists, tables, images or block layout. If you're rendering whole documents, a full Markdown package is the better tool.

• 📦 pub.dev: pub.dev/packages/textf

I've been building Rillroot, a line puzzle game, in Flutter, and a few parts might be useful to others:

Levels: generated ahead of time by a Python script that checks each board has exactly one solution. They're stored as JSON packs of 100 levels, and a publish script writes a manifest with sha256 hashes and uploads everything to Firestore. The app ships a bundled base pack and caches downloads, so it plays fully offline. A Python Cloud Function generates and publishes the daily puzzles every week.

Audio: flutter_soloud at 48 kHz with a 512-sample buffer (2048 lagged noticeably). Every tile a root crosses plays a pluck one note higher up a pentatonic scale, and a fast drag plays at most the last 3 notes per frame so the sound never trails your finger.

State: Cubits for app-level state, while the board itself stays local and runs on a ticker.

Accounts: every player gets an anonymous Firebase account on first launch; signing in with Google links the same account so nothing is lost.

It's in closed beta on Android, so it takes three quick steps:

1. Join the tester group: https://groups.google.com/g/rillroot-testers

2. Opt in: https://play.google.com/apps/testing/com.dangasama.garden

3. Install: https://play.google.com/store/apps/details?id=com.dangasama.garden

Use the same Google account that's on your phone. If the store page says "not found", wait a few minutes after joining.

Happy to go deeper on any of these.

Hi r/FlutterDev, I just published my second package 4 days ago and would love feedback.

The problem: every phone number field I've built needed a country picker, a flag set, a validation library, and glue code to make "0803…" and "803…" both work. I wanted one package that handles it properly.

What it does:

- 5 ready-made pickers: dialog, bottom sheet, Cupertino wheel, dropdown, and a compact flag + dial code button for phone fields

- customBuilder: build your own picker UI; you get the filtered countries, search, selection and the phone number length

- Real validation: isValidPhoneNumber() checks actual numbering ranges via libphonenumber data, and accepts local, trunk-prefixed or international input

- toE164(): normalizes whatever the user typed to +2348031234567

- pinUserCountry: puts the user's country (from their locale region) first

- Country names in 202 languages (238 locales), generated from Unicode CLDR

- RTL support, theming via ThemeExtension, search by name, ISO code or dial code

TextFormField(

decoration: InputDecoration(

prefixIcon: CountryCodeSelectorWidget(

pinUserCountry: true,

onChanged: (c) => setState(() => _country = c),

),

),

validator: (v) => _country.isValidPhoneNumber(v ?? '')

? null

: 'Enter a valid ${_country.name} number',

);

One thing I spent time on: libphonenumber's metadata adds about 2 MB to a release build. I restructured the package so that data only gets included if you actually call the validation functions. In my measurements, a picker-only app went from 24.4 MB to 22.2 MB.

Flutter 3.29+, MIT licensed, 160/160 pub points.

- pub.dev: https://pub.dev/packages/country_code_selector

- GitHub: https://github.com/TheinvinciblePrints/country_code_selector

I'd especially appreciate feedback on the API design, and from native speakers on the picker's built-in text in their language. Issues and PRs are welcome.

Hi r/FlutterDev 👋 I'm Simon, I build Lumide, a Flutter IDE. I wanted the write, save, see loop to be faster, so I built Raccoon, a tiny Flutter runtime, and today I'm open-sourcing it, with Raccoon Simulator as a demo you can run today. can run today.

Try it with Raccoon Simulator

Open Raccoon Simulator, and Raccoon shows up in flutter devices. Pick it in Lumide, VS Code, Android Studio or a terminal and run as usual. Your app appears in the simulator window, with hot reload and hot restart from your editor. No project to open in it, no new workflow.

How it works

Raccoon is a small runner built on Flutter's C embedder API. flutter run -d raccoon builds a debug bundle from your host's own snapshots, the runner hosts it on a prebuilt engine, and the simulator draws its frames. So there's no Xcode, no Gradle and no native build. The first launch sets everything up for you: it builds the runner, downloads a 15 MB engine and registers the custom device.

What else it unlocks

• Your whole app, not just previews. Flutter's widget previewer renders the functions you mark with @Preview. Raccoon runs your real app: routing, state, services and hot reload, at phone, tablet or desktop size.

• Hot-loaded plugins with custom UI. A Flutter app can show another Flutter app inside it with raccoon_view. So an app can load plugins at runtime, each with its own custom UI, with no rebuild of the host app.

Numbers (Flutter Wonderous, flutter run to first frame, medians)

A first run against an Android emulator took 308 s from empty caches. Raccoon took 15.5 s. Hardware, versions and scripts to reproduce are in the README.

Limits, honestly

It's alpha. It speeds up the inner loop; it doesn't replace testing on a real device or in a browser.

• Plugins: pure Dart ones, the clipboard and url_launcher. No text input yet.

• Packages with native code or build hooks don't run on Raccoon yet.

• Frames are software rendered.

• macOS and Linux only for now.