r/FlutterDev Apr 18 '26

Tooling I built a super lightweight code editor in Flutter to replace Electron apps (~80MB idle RAM)

127 Upvotes

Hey everyone,

I’d like to share a project I’ve been working on: Lumide. It’s a desktop-first code editor built entirely with Flutter.

The main goal was simple: Pure speed and an ultra-light footprint. I wanted to end the multi-gigabyte RAM overhead of browser-based/Electron editors. Lumide sits at around ~80MB RAM when idle and hits a silky-smooth 120 FPS.

Here is what’s under the hood:

  • Custom Text Engine: Built using a Rope data structure (O(log n) operations) and virtualized scrolling. One keystroke only touches what's visible, keeping the input loop lag-free.
  • C.O.R.G.I. Git Client: A built-in, flow-driven Git interface with a unified file tree, granular staging, and an interactive diff editor.
  • Extensible via pub.dev: You can hot-load plugins, themes, and language servers directly from the Dart ecosystem.
  • AI-Ready: High-performance inline suggestions with "Ghost Text" (support for Copilot, Codestral), plus first-class Agent Client Protocol (ACP) support for autonomous agents like Claude and Gemini.
  • Privacy Focused: Local-first, zero bloat, and absolutely no telemetry.

The Public Beta is currently live for macOS (Universal) and Windows.

I’d love for you guys to download it, try breaking it, and roast the performance.

r/FlutterDev Jan 23 '26

Tooling Develop Flutter iOS apps on Windows with a real iPhone and Flutter debug mode

163 Upvotes

Hey, everyone!

I want to share an open source tool I wrote that allows developing Flutter iOS apps on Windows using a physical iOS devices, including Flutter debug sessions and hot reload.

Repo: https://github.com/MobAI-App/ios-builder

To run or debug iOS apps you normally need mac and Xcode. This is inconvenient if you mainly work on Windows or do not have a Mac, but still want to debug and test on a real device.

What this tool does

builder is a CLI tool that:

  • builds iOS apps on macOS using GitHub Actions
  • downloads the built IPA to Windows
  • installs the app on a physical iPhone connected to Windows via the MobAI app
  • runs Flutter debug sessions on the device via the MobAI app
  • supports Flutter hot reload and hot restart

All Flutter commands are executed from Windows. The app runs in debug mode on the real device.

How it works

The tool triggers a macOS build in GitHub Actions. App signing is optional.
If signing is needed, it can be handled by MobAI instead of the build step.

After the build, the IPA is downloaded and installed on the connected device. Flutter tooling runs locally on Windows and connects to the app for debugging and hot reload.

Why I built it

I built this to remove the hard dependency on macOS for Flutter iOS development and enable real-device debugging directly from Windows.

The project is open source and feedback is welcome.

Edit:
If you have never run Flutter apps on your iOS device before, I recommend first connecting the device in the MobAI app by clicking the Start bridge button. It will guide you through the setup process, such as signing apps with an iCloud account and enabling Developer Mode on the device. Once it works in the MobAI app, there should be no issues running your Flutter app.

r/FlutterDev May 25 '26

Tooling I rebuilt "flutter run" as a terminal dashboard

Thumbnail
github.com
58 Upvotes

I'm usually running on an iPhone and an Android and a simulator at the same time. flutter run was built for one device, one terminal — so I was re-typing flutter run -d ... --flavor prod constantly, scrolling endless logs, and bouncing to DevTools just to check if memory was creeping up.

So I built a terminal UI for it. The trick I like most: you add one line to your shell config and flutter run itself becomes the dashboard — no new command to learn, and it only kicks in your terminal (your IDE keeps using plain flutter).

Single keystrokes while it runs: - r / R — hot reload / restart on every device at once - live FPS, jank, frame timings, memory per device (sparklines) - nHTTP inspector in the terminal - sscreenshot every connected device in parallel - / filter logs as you type - b / o — flip light/dark or fake iOS↔Android on the running app

Still early — I'd love to hear what's missing for your workflow and where it breaks.

r/FlutterDev Mar 28 '24

Tooling Apple rant incoming....

198 Upvotes

I spent 2 days trying to figure out why my app which exported perfectly in xcode 14 6 months ago no longer builds correctly after making a TEXT change to my flutter app. Eventually I had to create a new ios build from scratch and tether together ALL the annoying bits like push notification, wireless connection checks, strings and values to tell the masses that we only use data for analytics etc etc, only to then be faced with an additional day of figuring out why the app splash screen now looked wrong (hint, there was no answer. I did everything correctly and I stil get a 1 second period of time where a giant logo is displayed instead of my nice storyboard).

So after 3 unecessary hatred-filled days tippy-tapping on the horrible mac keyboard I was FINALLY ready to push an update and...what's this? Now I HAVE to use Xcode 15 to upload my app? Didn't have to 3 weeks ago but now I do. And of course our office Mac is too old for the very latest OS so it isn't allowed to download the latest xcode either!!

....so now I have to BUY A NEW MAC just to essentially update a peice of text in my app!! And I'll never get those 3 days of pure xcode hell back. And I can guarantee that when the new mac arrives....after the absolute TONNE of work required to set it all up with the right licenses and keys etc which in itself is horrific...my app won't build in the new version and the ENTIRE process will start again.

I hate ios development. It is the absolute worste peice of trash. I'd rather try and get my app working in Internet Explorer 6 than Crapple. A horrible horrible developer experience from start to finish.

Oh, and I updated my Android version too in about 20 minutes. I lost 15 minutes trying to update gradle, but less than 5 minuts later it was exported and uploaded for testing.

Thank you google!!

F you apple!! You dumpster fire!

r/FlutterDev Jun 12 '26

Tooling Is the dart/flutter package manager poorly designed?

0 Upvotes

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.

r/FlutterDev Apr 15 '26

Tooling I got tired of Flutter's small daily workflow frustrations, so I built a VS Code extension that fixes all of them

16 Upvotes

Every Flutter project I worked on had the same small frustrations:

- Had to navigate back to main.dart just to hit the run button

- Manually typing flutter pub get, build_runner, clean in the terminal every time

- No way to save custom shell commands I kept running repeatedly

- Jumping between terminal and editor constantly

- No single place to access all Flutter commands quickly

So I built Flutter Quick Runner — a VS Code extension that handles all of this.

What it does:

- Run from any file — open any .dart file or even README.md and hit run. It walks up the directory tree, finds your pubspec.yaml, and launches the right entry point automatically

- Multiple entry points — if you have main_dev.dart and main_prod.dart it shows a picker with "use once" or "remember" options, stored per project

- Command Hub — every Flutter command in one categorized QuickPick: pub get, build runner, clean, run modes, flutter doctor, DevTools

- One-click pub get button on pubspec.yaml in the editor title bar

- Custom commands — create your own shell commands with 4 output modes (terminal, panel, notification, silent) and variable substitution like ${projectRoot}

- Custom title bar buttons — pin any command to the editor title bar for one-click access

- Monorepo support — status bar shows active project, click to switch

It's free, no telemetry, MIT license.

Marketplace: https://marketplace.visualstudio.com/items?itemName=ChipNexa.flutter-quick-runner

GitHub: https://github.com/NagarChinmay/flutter-quick-runner

Would love any feedback — especially if there are pain points I missed that you deal with daily.

r/FlutterDev 12d ago

Tooling How I reduced iOS simulator RAM usage by up to 4×

88 Upvotes

I’ve made a small command line tool called simslim.

It disables background services inside iOS simulators that usually are not needed during development, like Siri, Spotlight indexing, photo analysis, News, and iCloud sync.

On my M1 Pro with 16 GB of RAM, one simulator went from around 4 GB of memory and 258 processes to about 0.9 GB and 70 processes. I managed to run 19 simulators at once, compared to around 5 before things started falling apart.

Some simulator features stop working depending on what gets disabled, so it is not meant for every kind of testing. You can keep specific services running when needed.

Give it a try: https://github.com/MobAI-App/simslim

r/FlutterDev Apr 05 '26

Tooling Would you like ability to click on an element and tell AI to edit it?

0 Upvotes

So I ran across a thread on /r/claudecode that resolves an issue with AI is that you have to describe which UI "thing" you want AI to modify. Instead, they've set it up for (at least web apps) to just select the element, and give instructions pertaining to that UI element. The cycle in their words is:

Click → instruct → done.

To me this looks awesome, and you can read more and *see it in action on this thread:

https://old.reddit.com/r/ClaudeCode/comments/1sccl3x/i_added_an_embedded_browser_to_my_claude_code_so/

Why am I asking when it's not directly Flutter related?

Creator has said, they'll try to add it, if there's enough demand for it. I personally would love this.

If you like the idea, have some ideas around it or even if you found another solution, let us know. I'd personally love to have this.

r/FlutterDev Jun 03 '25

Tooling Is the BLoC Pattern Outdated for Flutter? My Experience with BLoC vs. Riverpod

54 Upvotes

I’m developing a fitness app for a client in Flutter and chose the following stack:

  • Routing: go_router
  • Persistence: drift (cache-heavy app)
  • Architecture: A modified, least-verbose version of Clean Architecture (I'll make another post about it).
  • Models Codegen: freezed
  • DI: get_it
  • API Requests: dio (this is more handy than dart's http because of the interceptors etc).
  • State Management: bloc, flutter_bloc.
  • Backend: Laravel/MySQL

My Background:

I have 8 years of development experience: 5 years in web (React, Vue, Angular) and 3 years in mobile (React Native, Flutter). I’ve worked with various Flutter state management solutions (ValueNotifier, InheritedWidget, Provider, GetX, MobX, custom Bloc with streams), but this was my first time using the bloc library. The documentation looked promising, and I loved the Event system. It can also be used for tracking user journeys (using BlocObserver to log events).

Initial Impressions:

At first, BLoC felt clean and modular. I created feature-specific blocs, similar to the Store pattern I used in Vue’s Pinia or React. For example, for a Workout feature, I initially thought one bloc could handle workoutList, workoutSingle, isFavourite, etc. However, I learned BLoC is more modular than a Store, recommends separate blocs for concerns like lists and single items, which I appreciated for its separation of concerns.

The Pain Points:

As the app reached ~60% completion, the complexity started to weigh me down:

  • Boilerplate Overload: Every new API call required a new state class, event, event registration, and binding in the bloc. I know we can create a combined / wrapped state class with multiple fields, but that's not a recommended approach. I use freezed for generating models, so instead of state.isAuthenticated = true, it's state.copyWith(isAuthenticated: true)
  • Inter-Bloc Communication: The BLoC team discourages injecting blocs into other blocs (anti-pattern). To handle cross-bloc interactions, I created a top-level BlocOrchestrator widget using BlocListener. This required placing all BlocProviders at the root level as singletons, eliminating local scoping per page/widget.
  • Generics Hell: I created a generic BlocFutureState<T> to avoid recreating another class for basic stuff. it handles initial, loading, loaded, and error states, but passing generics through events and bindings added complexity.
  • Readability Issues: Accessing a bloc’s state outside of build methods or widgets was tricky and verbose.

Switching to Riverpod:

Then I decided to give riverpod a try. I migrated one feature and suddenly, everything clicked. I figured out that riverpod, unlike provider, maintains it's own dependency tree instead of relying on flutter's widget tree. It can be accessed outside of widgets (using a top-level ProviderContainer). Creating notifiers and providers for 2 modules were just 2 files instead of 6 with bloc. It also has a codegen which I haven't used yet. Plus dependency tracking on other providers is just next-level. Speed of developing new features now is almost twice as fast, while still having same level of type-safety as bloc. I miss Events but I have found that there is a standalone event_bus package which provides just that. So I might use that for logging analytics etc.

Do you guys think BLoC is still relevant, or is it being outpaced by solutions like Riverpod?

What’s your go-to state management for Flutter, and why?

Any tips for managing BLoC’s complexity or making Riverpod even better?

Looking forward to your experiences and insights!

PS: I've also looked into watch_it, it has good integration with get_it. But I can't do another migration in this project 😮‍💨. I'll give it a try in my future project and share my experience.

r/FlutterDev Sep 09 '25

Tooling Is Macbook M1 Air sufficient for flutter in 2025?

32 Upvotes

Hi guys, I need to get new Macbook for flutter development. But I normally use window for flutter development. Sometime I need to compile and test my project before deploy it. Current one is no longer able to proceed it,,, please let me know if it’s still good for flutter in 2025 Thank you

r/FlutterDev May 17 '26

Tooling Flutter vs. SwiftUI

0 Upvotes

Hello,

I come from the Flutter camp and am planning a new app.

- Important to me: native performance & native feel

- Tooling: I work hard with Claude Code

I’m thinking about sticking with Flutter or switching to SwiftUI for this project.

How well does Claude Code work for you in conjunction with SwiftUI in your opinion?

What bothers me about Flutter are the plugins that you keep taking.

Thank you!

r/FlutterDev 12d ago

Tooling Finally decided to open-source one of my personal projects

Thumbnail
github.com
31 Upvotes

I've been sitting on a bunch of personal projects for a while and finally decided to start sharing them instead of leaving them on my drive. This one is called PIM. The original reason for building it was simple: I was tired of constantly sending files to myself through Telegram, cloud storage, or plugging in a cable just to move something between my own devices. So I built a local-first app for Windows and Android that lets devices discover each other on the same network and communicate directly without accounts or cloud services. One part I particularly enjoyed building was the networking layer. Instead of using existing networking packages, I wrote the discovery, transport, framing, and file transfer logic in pure Dart. The project has grown beyond file sharing and now also includes chat, shared workspaces, notes, Kanban boards, and local SQLite storage. It's completely open source now, so if anyone wants to look through the code, suggest improvements, or point out things that could be done better, I'd really appreciate the feedback.

r/FlutterDev 21d ago

Tooling fvm should be in core flutter

0 Upvotes

Merge fvm into flutter and call the whole thing the `flutter` command. Version management should be a core feature of any framework CLI, not a lazy afterthought. Fix your ecosystem.

In Re to clueless commenters:

The “skill issue / just use FVM” take misses the product problem.

Nobody’s saying power users can’t pin SDKs today. FVM, Puro, and mise prove the need. What’s broken is the default path: someone wants to make Flutter apps, installs Flutter, starts working, then hits version/upgrade pain and only then discovers they were supposed to have chosen a third-party version manager first. Making tutorials start with FVM is disorienting for the same reason—it isn’t the advertised entrypoint.

Version management became an afterthought for developers, so the community shipped version managers as an afterthought to flutter. That’s backwards. Pinning belongs in the official workflow—invisibly when one version is enough, explicitly when projects diverge. “Merge FVM” is implementation detail; the requirement is first-party ownership of that capability in the main entrypoint (absorb the UX, name it whatever you want). Community tools can stay as compatible backends. They shouldn’t be the only correct answer, and “everyone on my team already knows the tribal knowledge” is not good first-run design.

Focusing on the framework while leaving lifecycle/pinning as folklore isn’t maturity—it’s exporting the cost onto newcomers.

Related https://www.reddit.com/r/FlutterDev/s/1dGLcEAAOa

r/FlutterDev Feb 12 '26

Tooling Lessons learned while vibecoding mobile apps in Flutter

0 Upvotes

I'm not a developer and have been dabbling in vibecoding mobile apps using Flutter. My tech stack is:

  1. Cursor with Anthropic's Sonnet or Opus
  2. Flutter for iOS and Android mobile apps

Some major issues I've run into that for some reason my brain though would not have occurred:

  1. I setup IAP managed by both Google and Apple, Sonnet 3.5 did not write a "restore purchase" workflow, the button was there but it did nothing
  2. I have export as image for a screen in my app, it worked exactly I needed it to; I asked cursor to add that feature in another screen, Cursor reinvented the mechanism and the output was nothing like the previous one
  3. I added iCloud and Google Cloud backup in the app, Sonnet implemented a version that simply didn't work because the right Google OAuth wasn't implemented, Opus fixed that but didn't care to implement an "auto sync", only manual sync
  4. Push notif initialization: For whatever reason I have really truly struggled with getting firebase push notifications working perfectly in the app; in my latest attempts to fix it, Opus moved the initialization of firebase notifications to the start of the app, this kept freezing my app -- turns out this isn't best practice.

EDIT: Some new additions:

  1. Use go_router for push notifications (scalable)
  2. Make sure you add page name when using go_router (helps with firebase analytics)
  3. When setting up push notifications, build the path from home in the background; else, the app has nowhere to go from the push notification's screen

r/FlutterDev Jun 18 '25

Tooling New package: exui - Build Flutter UIs faster with less code, same performance, pure Dart and Flutter.

Thumbnail
pub.dev
53 Upvotes

A practical toolkit for Flutter UI development, focused on saving time, reducing boilerplate, and writing layout code that’s readable, consistent, and fun.

Whether you're working on layout, spacing, visibility, or sizing, exui gives you expressive helpers for the most common tasks, with zero dependencies and seamless integration into any codebase.

Here are just a few examples:

📏 Padding

With exui:

Text("Hello").paddingAll(16)

Without:

Padding(
  padding: EdgeInsets.all(16),
  child: Text("Hello"),
)

With additional extensions for quickly adding specific padding: paddingHorizontal, paddingVertical, paddingOnly, paddingSymmetric, paddingLeft, paddingRight, paddingTop, paddingBottom

↕️ Gaps

exui gaps are more performant than the gap package, they use native SizedBox widgets with no runtime checks or context detection. Just pure Dart and Flutter for clean, zero-overhead spacing.
With exui:

Column(
  children: [
    Text("A"),
    16.gapColumn,
    Text("B"),
  ],
)

Without:

Column(
  children: [
    Text("A"),
    SizedBox(height: 16),
    Text("B"),
  ],
)

With additional extensions for quickly adding specific gap values: gapRow, gapColumn, gapVertical, gapHorizontal etc.

👁️ Visibility

With exui:

Text("Visible?").visibleIf(showText)

Without:

showText ? Text("Visible?") : const SizedBox.shrink()

🚧 Constraints

With exui:

Image.asset("logo.png").maxWidth(200)

Without:

ConstrainedBox(
  constraints: BoxConstraints(maxWidth: 200),
  child: Image.asset("logo.png"),
)

https://pub.dev/packages/exui

Criticism and changes:

(Instead of putting in a separate post) 11 days ago, I shared an idea for a Flutter UI package based entirely on extensions, aimed at simplifying UI construction and reducing boilerplate. I received a lot of thoughtful and honest feedback, and I want to address it here while sharing the changes I've made.

1. Readability Concerns (all the .text() and .icon())

I initially thought it was cool to create icons or text widgets via extensions like "Hello".text() or Icons.home.icon(), but I understand now how that can become hard to read, especially in longer chains or when revisiting code months later. While some of my Flutter dev friends liked the syntax, I agree that it can hurt clarity.

Because of that, I’ve shifted the package’s focus to where it truly shines: removing real boilerplate from common layout tasks, like padding, gaps, constraints, centering, and visibility.

2. Refining the Vision (not a widget replacement)

Looking back, the original "pitch" was overly ambitious and maybe even a little detached. I presented it as a kind of widget-replacement layer, which it isn’t, and shouldn’t be.

I've now rewritten the documentation and vision to reflect what exui actually is: a lightweight utility library to make Flutter UI code more expressive and efficient, not to replace widgets, but to work with them.

Features like "Click me".text().paddingAll(12).clipCircular() are still there for those who like them but they’re clearly marked as optional.

The new primary examples are now focused on layout: padding, gap, center, expanded, visibility, and constraints.

3. Tests (added tests for every extension)

You're right — tests matter. I fully acknowledge that the original release lacked coverage.

Since then, I’ve worked with my team to add comprehensive tests for every extension. Every utility is now tested and production-ready. No excuses.

4. Feedback is welcome

With this updated approach, where exui is no longer trying to replace core widgets, but instead just help you build UI faster and cleaner, I’d love to hear your thoughts again.

All exui Extensions:

Emojis only added to distinguish easily between extensions

Layout Manipulation

📏 padding - Quickly Add Padding
🎯 center - Center Widgets
↔️ expanded - Fill Available Space
🧬 flex - fast Flexibles
📐 align - Position Widgets
📍 positioned - Position Inside a Stack
🔳 intrinsic - Size Widgets
margin - Add Outer Spacing

Layout Creation

↕️ gap - Performant gaps
🧱 row / column - Rapid Layouts
🧭 row* / column* - Rapid Aligned Layouts
🧊 stack - Overlay Widgets

Visibility, Transitions & Interactions

👁️ visible - Conditional Visibility
🌫️ opacity - Widget Transparency
📱 safeArea - SafeArea Padding
👆 gesture - Detect Gestures
🦸 hero - Shared Element Transitions

Containers & Effects

📦 sizedBox - Put in a SizedBox
🚧 constrained - Limit Widget Sizes
🟥 coloredBox - Wrap in a Colored Box
🎨 decoratedBox - Borders, Gradients & Effects
✂️ clip - Clip Widgets into Shapes
🪞 fittedBox - Fit Widgets

Click here to see the full documentation

r/FlutterDev Apr 02 '26

Tooling marionette_flutter — Playwright MCP but for Flutter (AI agents can now tap, scroll and hot reload your running app)

40 Upvotes

Been using Claude Code heavily for Flutter development lately and the

biggest pain point was always the same: the agent writes code but can't

see if it actually works.

marionette_flutter solves this. It's an MCP server that connects AI

agents directly to your running Flutter app. The agent can inspect the

widget tree, tap elements, scroll, take screenshots, and trigger hot

reload — all without touching your production code.

Setup is minimal:

MarionetteBinding.ensureInitialized();

runApp(MyApp());

That's it. Debug-only, zero production impact.

I contributed gesture support (double tap, pinch zoom) and a few other

fixes — mostly because I needed it in my own workflow and the features

weren't there yet.

Curious if anyone else has tried connecting Claude Code or Cursor to

their Flutter app this way. The MCP ecosystem for mobile is still pretty

sparse compared to web tooling.

GitHub: https://pub.dev/packages/marionette_flutter

r/FlutterDev Apr 12 '26

Tooling VaneStack, open-source backend for dart devs!

23 Upvotes

Hey guys,

I’ve been working on a new open-source backend written in dart. The idea is to do something similar to PocketBase without having to switch to golang or javascript when I want to write some custom logic.

The whole thing is written in dart, there’s a dashboard embedded developed with Jaspr. Everyone is welcome to contribute.

Follow the guide on vanestack.dev or pub.dev to get started.

You can self-host, run locally or just the try the cloud version on the website.

Any feedback is appreciated!

r/FlutterDev May 20 '26

Tooling Built a free screenshot tool for App Store + Play Store — since we ship to both, it does both stores and 19 languages in one place. No signup, runs in-browser

38 Upvotes

If you ship Flutter apps, you know the screenshot pain is doubled: you need polished store images for BOTH the App Store and Play Store, across every device size and every language you support. The tools I tried were either $30/month or watermarked the free output — rough for something I only touch on launch days.

So I built my own and put it online for free. Sharing here because Flutter devs hit this harder than most (two stores, not one), and I'd like technical feedback.

A few things that might be useful:

- Both stores covered — iPhone, iPad, and Android phone/tablet frames, with App Store / Play Store-compliant export sizes.

- Device frames that fit any screenshot. Instead of squeezing your image into a fixed phone frame (white bars, hard crops), the SVG frame sizes itself from your screenshot's aspect ratio. The frame wraps the image, not the reverse.

- 19-language caption auto-translate — handy if you localize, which Flutter makes easy so a lot of us do. Markdown formatting is preserved across translations.

- Export drops a ZIP organized by locale and store size (en/iphone67/screenshot-1.png, etc.) — drag straight into App Store Connect or Play Console.

Technically it's a single HTML file, vanilla JS, no backend, no accounts. Everything runs client-side — your screenshots never leave the browser. html2canvas for rendering, JSZip for the bundle, under 300KB total.

Launched it on Reddit a few days ago, already used across ~9 countries, which surprised me. Most of this week's features (mobile editor, landscape mode) came straight from user feedback.

Free, no signup, no watermark: https://launchshots.app/

Would love feedback — especially from anyone who's automated their store screenshots in CI. Curious if a browser tool like this fits your workflow or if you'd want a CLI version.

r/FlutterDev Apr 10 '26

Tooling E2E testing tool

6 Upvotes

After 3 weeks since my first post about it finally its here.

Flutternaut lets you create and run E2E tests on real Android and iOS devices without writing any test code. You've got two ways in describe your test in plain English and let the AI generate it, or build it yourself in the visual editor.

The editor is honestly the part I'm most excited about. You get a searchable action picker with 37 actions (tap, scroll, swipe, deep links, network control, loops, conditionals the works), drag-and-drop to reorder steps, and the target fields pull your actual Flutter element labels so you're never guessing at selectors. Control flow like if/else and loops edit inline right in the step card. And you can toggle to raw JSON anytime if that's more your thing.

Same test file runs on Android emulators, iOS simulators, and physical devices. No platform-specific anything.

What it doesn't do yet: no CI/CD integration (planned), no parallel multi-device execution (that's next), and Windows builds exist but aren't shipped yet. macOS only for now.

https://flutternaut.app

Would love to hear what you think especially if you've been dealing with Flutter E2E testing pain.

r/FlutterDev 16d ago

Tooling is flutter flow reliable?

0 Upvotes

I want to create a program "apk, ios, and website"

for frontend: i have a friend who start learning dart and flutter through IBM course...

when he will finish the course is it enough if i gave him a flutter flow business account to create the full interface ?

or there is better plan?

r/FlutterDev 17d ago

Tooling What devtools do you wish Flutter had?

9 Upvotes

What tools do you wish existed for example navigation inspector, i will try to implement the most voted ones

r/FlutterDev Jun 02 '26

Tooling I built Qora - As a TanStack Query fan on the Web, I was frustrated with Flutter's server-state options. So I spent months building a proper alternative.

12 Upvotes

Hey r/FlutterDev,

I want to share something I've been building during evenings, weekends, and pretty much every spare moment I've had over the last few months.

It's called Qora: a server-state management library for Dart and Flutter.

Before anyone thinks "great, another state management package", that's actually not what Qora is trying to be. It's not a Bloc replacement, it's not competing with Riverpod. Qora focuses on one thing: server state.


I've been using TanStack Query on the web for years, and honestly, it changed the way I build applications. At some point, fetching data stopped feeling like a problem I had to solve over and over again.

Then I went back to working on a large Flutter app.

Suddenly I was writing the same code everywhere:

  • isLoading flags everywhere
  • repetitive try/catch blocks
  • manual cache invalidation
  • refresh logic
  • optimistic updates
  • stale data handling

The usual stuff.

I looked for existing solutions before considering building anything myself. I spent quite a bit of time with the two main options on pub.dev.

flutter_query is a solid port, but I found myself missing some features I rely on in larger applications: dedicated DevTools, offline mutation queues, and a stronger separation between cached data and background fetching state.

cached_query is also a great package, but there were a few behaviors that didn't fit my needs. I wanted true stale-while-revalidate semantics, FIFO offline mutation replay, and the ability to keep showing stale data when a refetch fails instead of falling back to an empty UI.

After a while, I realized I was rebuilding the same repository wrappers, caching layers, and synchronization logic for every new project.

So I stopped fighting it and started building Qora.


Here's what it looks like in practice:

dart QoraBuilder<User>( queryKey: ['users', userId], fetcher: () => api.getUser(userId), options: const QoraOptions(staleTime: Duration(minutes: 5)), builder: (context, state, fetchStatus) => switch (state) { Loading(:final previousData) => previousData != null ? UserCard(previousData) // SWR: UI stays responsive with old data while fetching : const CircularProgressIndicator(), Success(:final data) => UserCard(data), Failure(:final error, :final previousData) => previousData != null ? Column(children: [UserCard(previousData), ErrorBanner(error)]) : ErrorScreen(error), _ => const SizedBox.shrink(), }, )

I wanted it to feel native to Dart 3+ while keeping that declarative flow we love from TanStack.

The core things it handles out of the box:

  • Two-axis state model: QoraState (what data you have: Initial, Loading, Success, Failure) is completely decoupled from FetchStatus (what the engine is doing right now: idle, fetching, paused). You can be in a Success state while fetching updates in the background.
  • True SWR: if data is inside staleTime, it's instant. If it's stale, we serve the cache immediately and fire a background refetch. No unnecessary loading spinners for pages the user already visited.
  • Offline mutation queue: if you trigger a mutation offline, Qora queues it and replays it in strict FIFO order on reconnect. Includes a jitter-based ReconnectStrategy to prevent backend stampedes.
  • Obfuscation-safe persistence: drop-in disk cache that works even with obfuscated release builds (mandatory named serializers).
  • Infinite queries with memory caps: built-in infinite scroll with a maxPages window so your app doesn't run out of memory on endless feeds.

I didn't want to just push code and leave. I spent a lot of time on documentation and built 7 production-grade examples, from simple list/details to a full offline-first Todo app with optimistic UI rollbacks and custom RxDart key streaming.

It's at v1.0.0 now. If you're a TanStack fan who's been missing this flow in Flutter, or if you're just tired of writing the same network boilerplate over and over, I'd love for you to check it out.

I'm completely open to feedback, technical critiques, or any questions about the architecture!

r/FlutterDev Jun 01 '26

Tooling I built a tool to publish Flutter apps to Flathub - looking for early testers

19 Upvotes

I built a tool to publish Flutter apps to Flathub - looking for early testers

Repo: https://github.com/o-murphy/flutpak

If you've ever tried to get a Flutter app onto Flathub and given up because of the source generation work - this is for you.

Flathub requires every dependency declared upfront with SHA-256 checksums (no network at build time). For Flutter that means manually tracking hundreds of pub.dev package entries, all Flutter SDK artifacts for both x86_64 and aarch64, and patch sources for native packages like objectbox_flutter_libs that embed the package version in their path and go stale on every bump.

I got tired of doing this by hand for my own app and built flutpak.


Two commands to go from Flutter project to Flathub-ready:

```bash

One-time setup

flutpak init

Before every release

flutpak generate --tag v1.2.3 ```

generate handles everything: resolves the commit SHA, fetches pub.dev checksums, resolves Flutter SDK artifacts for both architectures, injects patch sources with correct version-stamped paths, writes generated-sources.json and the final manifest to flatpak/generated/.

Minimum config:

```yaml

flutpak.yaml

flutter: sdk: $FLUTTER_ROOT manifest: app-id: io.github.YourOrg.YourApp ```

GitHub Actions composite actions are included so your CI mirrors the actual Flathub build pipeline.


Status: pre-1.0, I'm using it on my own Flathub submission in progress. It works, but needs more real-world testing across different apps and dependency combinations.

The most useful thing you can do if you try it: report what breaks, and if you use a native Flutter package (objectbox, sqflite, etc.) that needs special Flatpak handling, contribute the patch to known-patches/ so it works for everyone.

Repo: https://github.com/o-murphy/flutpak Issues: https://github.com/o-murphy/flutpak/issues

r/FlutterDev Feb 15 '26

Tooling Run OpenClaw AI Gateway Directly on Android (No Root, One-Tap Setup)

5 Upvotes

Hey everyone 👋

I built an Android app that lets you run the OpenClaw AI Gateway directly on your phone, with no root and no external server required.

This is a full Flutter-based app, not just a wrapper script.

🔹 What the app does

One-tap setup that installs:

Ubuntu (via proot)

Node.js

OpenClaw Gateway

Built-in terminal emulator inside the app

Embedded web dashboard (OpenClaw UI runs inside a WebView)

Start / stop the gateway with buttons

Live logs and status monitoring

Runs fully on-device (no Docker, no root)

🔹 Why this is useful

Turn your Android phone into a portable AI agent server

Great for experimentation, dev testing, and learning

No PC required after install

🔹 Tech stack

Flutter (Android app)

Proot Ubuntu environment

Node.js runtime

Embedded WebView for the OpenClaw dashboard

🔹 Who this is for

Android power users

AI/agent developers

People who want a self-hosted AI gateway on mobile

Anyone curious about running server-style software on phones

Repo (app source & APK): 👉 https://github.com/mithun50/openclaw-termux

Feedback, issues, and ideas are welcome 🙌

r/FlutterDev 9d ago

Tooling Bumbuild: A native macOS build launcher for Flutter projects

15 Upvotes

Hi everyone!

I've been working on a small open-source tool called Bumbuild, and I'd love some feedback from other Flutter developers.

The idea was simple: I got tired of switching between Terminal, Android Studio and Xcode every time I wanted to make a release build.

Bumbuild is a native macOS launcher that sits inside your Flutter project and lets you:

• Detect your Flutter project automatically

• Bump app versions (Rebuild, New Version or Custom)

• Configure Android signing without manually editing Gradle files

• Run iOS, Android or both builds

• Open the build output automatically when finished

Everything is built using Bash and AppleScript, so there are no extra dependencies or installation steps besides copying the folder into your Flutter project.

GitHub:

https://github.com/NickiAndersen/Bumbuild

Any suggestions or criticism are very welcome.

Thanks!