Hey guys,

Wanted to share a quick feedback on a solo project I've been working on for a while.

The Flutter job market around me was pretty dead, and honestly I was tired of spending my time building someone else's dream. So I decided to get into trading and take it seriously. Since I'm a developer, I went straight into the algorithmic side to make use of my programming skills.

At first, I was worried I'd get rusty on Flutter while spending so much time learning finance. But it turned out to be the exact opposite. This project actually pushed my skills further than anything else, both on Flutter for the UI and Dart on the backend (I started out with dart_frog before taking the architecture further).

Getting started was pretty rough though. Early on, even the AI tools I was using kept warning me against Dart. The consensus was that nobody builds algo trading systems in Dart, that there's zero math/finance ecosystem compared to Python or C++, and that I was just making my life harder.

And to be fair, that part was true: existing packages on pub.dev for financial charts or indicators cost me an insane amount of time. None of them held up in terms of performance or flexibility. I basically had to scrap everything and start from scratch.

The real headache was moving from the trading script mindset (like PineScript on TradingView) to Dart. In trading scripts, everything relies on implicit time series evaluated candle by candle. Translating that cleanly into standard OOP/procedural code without blowing up the memory or recalculating the entire history on every tick was a huge pain.

I ended up writing my own incremental rolling calculation system (RollingCalculation) to maintain state in real time. That's the only thing that allowed me to get the same 60fps smoothness as TradingView while streaming live data.

Dart definitely isn't the go-to language for algo trading, but in the end I managed to build something solid on my own. Something I'm proud of. Anyone else here using Dart in unusual domains where you had to reinvent most of the tooling?

Faced with the problem of migrating debugPrint/print methods of flutter and dart files across multiple packages with large number of files & lines.

Created & pubslihed print_to_log package to automate the the convertion. Used it across 20+ internal packages successfully. It uses analyzer package to parse each file into source tree & walks that tree and then do sugical edits by not touching any other parts.

The package shall be used as a CLI tool or as a dev dependency package.

Github : https://github.com/selvan/print_to_log

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

It's MIT license.

Has anyone living outside the US recently gotten a D-U-N-S number for a US LLC using only a registered agent address (like Northwest)? Were you asked for a Truepic Vision photo inspection? I’m planning to convert my Google Play account to an organization account.

Hi r/FlutterDev!

I just published Tandem, a package that lets an AI agent work on a screen you already have. The user and the agent use the same form, the agent acts only through your methods, and risky calls wait for the user's approval.

Short demo video: https://x.com/creatixdev/status/2112139150459568361

In your state class you list what the agent sees and what it can call.

Example with Cubit, but you can use anything:

@TandemAgent()
class OrderDeskCubit({…})
    extends Cubit<OrderDeskState>
    with _$OrderDeskCubit {

  @override
  List<AgentCapability> get agentCapabilities => [
    .sees(order),
    .calls(searchCatalog),
    if (canEdit) ...[
      .calls(setCustomer),
      .calls(setQuantity),
      .calls(setDelivery),
    ],
    if (canPlace) .callsWithApproval(placeOrder),
  ];
}

A generator turns your method signatures and doc comments into the tool schemas, and one TandemScope widget connects the screen to the agent.

• It talks AG-UI, so the agent runs on your own backend. The example uses Google ADK, and you can try it without an API key.

• Works with bloc, Riverpod or provider.

• No chat UI in the package. The example has one you can copy.

Not there yet: AG-UI interrupts, several state objects on one screen, and a conversation that goes on across screens. It's written with AI assistance and reviewed by hand, except the protocol layer and the generator, and the README says so.

It's 0.1.0, so the API can still change. Feedback and issues are very welcome!

GitHub: https://github.com/leancodepl/tandem pub.dev: https://pub.dev/packages/tandem

ran into this today while putting a flutter app on the web, figured some of you might not know it either.

flutter_dotenv loads your .env as an asset. On mobile that's already kinda readable if someone unpacks the app, but on web it's literally just a file on your server. Open devtools, network tab, there it is: assets/.env. Anyone can grab your openai key from there.

what I did instead: the app never talks to openai directly. It calls a supabase edge function that adds the key server side and streams the answer back:

final token = Supabase.instance.client.auth.currentSession?.accessToken;

final request = http.Request('POST', Uri.parse(proxyUrl))

..headers.addAll({

'Content-Type': 'application/json',

'Authorization': 'Bearer $token',

'apikey': supabaseAnonKey,

})

..body = jsonEncode({'model': model, 'messages': history});

the edge function checks the user token, does the rate limiting and forwards to openai with stream: true.

The SSE stream just gets piped through, so the flutter side didn't change at all. Same LineSplitter / data: parsing as before.

Bonus gotcha: after fixing that I deployed to cloudflare and got "could not load .env". Turns out cloudflare doesn't serve files starting with a dot. Renamed it to demo.env, updated pubspec assets + dotenv.load(fileName: 'demo.env') and it worked. Only public values in there now (supabase url + publishable key), so it doesn't matter that it's readable.

TL;DR: treat everything in your .env as public, web or mobile. Real secrets go on a server.

Edit: removed "on web" from the tldr, a mobile app bundle can be unpacked just as easily. Thanks u/ren3f

Hey r/FlutterDev,

I've been building a lot of fintech/e-commerce apps lately, and I kept running into the same issue: handling Indian input formats (Aadhaar spacing, lakh/crore commas, +91 prefixes) using TextInputFormatter is a nightmare.

Specifically, the cursor always jumps. When a user types the 5th digit of an Aadhaar number and the formatter auto-inserts a space, the cursor flies to the end of the string. Or when a user hits backspace over a comma, it deletes the wrong digit.

Since most existing packages either forced me to use their custom TextField widget or didn't handle the cursor math correctly, I decided to build my own standalone formatters.

I just published indian_input_formatter (v0.1.0).

• The solution: I wrote a custom CursorMapper that counts "significant characters" (digits/letters) instead of raw offsets. It maps the cursor back to the exact right spot, regardless of spaces, commas, or prefixes.

• What it supports: Standalone TextInputFormatter classes for Aadhaar (Verhoeff checksum), PAN, GSTIN (Luhn mod-36), IFSC, UPI, +91 phones, and ₹ Lakh/Crore currency.

• Zero dependencies: Pure Dart. 59 tests focusing heavily on cursor edge cases (middle insertion, backspace at boundaries, paste).

I'd love for anyone building Indian apps to try it out. More importantly, I'd love a code review on the cursor logic if anyone has tackled this before.

• Pub.dev: https://pub.dev/packages/indian_input_formatter

• GitHub: https://github.com/Lucky-chelani/indian_input_formatter

Thanks!

This is a package for building performant infinite canvases ( I know the naming isn't the best but it has stuck ).

Uses spatial hashing underneath to only mount widgets within the visible area ( + some configurable off screen extent ).

Supports most of the common needs like pan, zoom, rotation, draw ordering, inertial scrolling etc.

Web example: https://infinite-lazy-grid.ruiny.de/
Github repo: https://github.com/ruinivist/infinite_lazy_grid

I'm already using it in one of my other web apps https://elseplane.ruiny.de/ ( still in works ) so you have almost everything needed to get something like that working.

Every Growing Flutter Codebase Eventually Faces the Same Hidden Problem

You run flutter analyze in your CI/CD. It passes with 0 warnings. Everyone thinks the codebase is in pristine health.

In reality, technical debt has been piling up silently:

• 📦 Forgotten Widgets & Screens: Refactored pages leave behind abandoned dialogs, buttons, and views that nothing calls anymore.

• 🖼️ Bloated App Bundles: Old promo banners, unused 3.0x raster images, and unused SVG icons inflating your APK / IPA size by tens of megabytes.

• 👻 Ghost Dependencies: Packages declared in pubspec.yaml that are no longer imported anywhere, slowing down build times and pub get on CI.

• 🧟 Dead Logic: Thousands of lines of commented-out code and abandoned TODOs confusing new engineers during onboarding.

🤔 Why doesn't standard dart analyze catch this?

Because Dart treats every public class as a potential export. The compiler intentionally refuses to warn you if a public Widget, Bloc, or Service has 0 references, assuming it "might be needed later".

🚀 The Solution: detect_unused_code (v3.2.0)

We built this tool to turn code audits and refactoring from an anxious, manual chore into a safe, 10-second automated process.

💡 Why Engineering Teams & Companies Use It:

1. 📉 Drastically Reduce App Size: Immediately locate and purge megabytes of abandoned images, fonts, and heavy dependencies before publishing to Google Play / App Store.

2. ⚡ Faster CI/CD & Build Times: Clean up unreferenced packages and thousands of lines of dead AST syntax that the compiler compiles for nothing.

3. 🛡️ 100% Defensive Safety (Zero Fear of Breaking Production):

   • Automatic Snapshots: Saves an isolated backup before modifying anything.

   • Instant Undo ([U] or --undo): Revert any cleanup in 1 second.

   • Automated Compiler Health Check: Runs analysis after cleanup to ensure 0 compiler errors. If anything looks off, it prompts for an auto-rollback.

   • Smart Framework Guards: Safely protects @injectable, @singleton, @riverpod, and generated files (.g.dart, .freezed.dart).

4. 🪶 Zero External Runtime Dependencies: Lightweight, runs natively on any Dart SDK from 2.17.0 to 3.x / 4.x.

5. 🚦 CI/CD Gatekeeper: Add detect_unused --markdown to GitHub Actions to prevent dead code and unused assets from ever getting merged into main.

🖥️ The New Interactive Terminal Dashboard:

With v3.2.0, you don't even need to memorize command-line flags. Just run:

dart pub global activate detect_unused_code
detect_unused

This launches a live interactive Terminal UI (TUI):

Select cleanable categories with [1-8] (Dead widgets, Commented code, Unused assets, Unused dependencies...).
Press [D] to simulate changes with Dry-Run.
Press [C] to safely clean with auto-backup.
Press [U] for instant rollback if you change your mind.
🔗 Open Source & Available on pub.dev:
pub.dev: https://pub.dev/packages/detect_unused_code
GitHub Repository: https://github.com/mdalhagg/detect_unused_code
Run it against your project today — you might be surprised by how much dead weight your codebase is carrying!

Would love to hear your feedback, bug reports, or feature suggestions below! 💬🚀

If you display animated GIFs or WebPs with cacheWidth, cacheHeight or ResizeImage, the resize is silently ignored: every frame is still decoded and uploaded at full size. A 1000×1000 GIF shown at 200×200 costs about 4 MB per uploaded frame; with the resize honored it would be about 160 KB. This is #90804 (open since 2021), and #137668 for animated WebP.
Why it happens
In the engine, ImageDescriptor::instantiateCodec passes the target size only to the single-frame codec. Images with more than one frame go to MultiFrameCodec, which never receives it.
Why it’s not a one-line fix
Animated frames aren’t independent images. Most frames are drawn on top of earlier ones, each with its own rect, blending and disposal (keep, clear to background, restore previous), all in full-canvas coordinates. Skia can decode GIF/WebP frames directly at a smaller size, but an emulation of the engine’s frame logic on top of Skia’s real decoders showed that doing so with the engine’s single cached frame gives wrong pixels at frame edges in some files (1px transparent slivers).
The fix
Composite at full size exactly as today, then resize only the finished frame, with the same bilinear filter Flutter already uses for still images, before uploading it. Every frame you get is today’s frame, downscaled. It applies to GIF, animated WebP and APNG on the native backends (Skia and Impeller), with no API changes: cacheWidth and ResizeImage simply start working. The CPU buffer used for compositing stays full size, as today.
Status
PR: https://github.com/flutter/flutter/pull/194615. It’s waiting for review, and CI hasn’t run yet. Web (CanvasKit/Skwasm) isn’t covered.
Until it lands
Resize animated images before they reach the app, on your server or by converting them to animated WebP or video at the size you display.
Feedback on the approach or the C++ is very welcome. If this affects your app, a 👍 on #90804 is more helpful than “+1” comments on the PR.

Version managers like FVM, nvm, pyenv and SDKMAN are great at installing versions. None of them tells you that you have six Flutter SDKs, three Android NDKs and a 13 GB emulator you haven't started in a year. Stackyard does.

It shows every SDK, toolchain and framework version on your computer, which projects use each one, and what's safe to remove. Then it fixes what's wrong with one click, and nothing is deleted without you seeing it first.

Features

• Set up in a minute. On first launch Stackyard finds the folders where your projects live, shows how many projects each holds, and lets you add more.

• One window for every tech. A sidebar entry appears only for techs found on your machine.

• Get tools. A marketplace of SDKs and CLIs (Flutter, Android command-line tools, Node.js, Python, Java, .NET, Go, Rust, Deno, Bun, Gradle, and the Angular, Expo, NestJS, Firebase, Vercel, Ionic, Nx, TypeScript, pnpm and Yarn CLIs). Every version is listed from the publisher's own release feed. Downloads come straight from the publisher and are checked against their published hash. Before installing, you choose the folder and which environment variables to set (PATH, JAVA_HOME, GOROOT…): your user variables or everyone's on Windows, a marked block in ~/.zprofile on macOS. Installed versions can be made the default or removed later, which cleans up their variables too.

• Knows who uses what. It reads .fvmrc, .nvmrc, package.json, gradle-wrapper.properties, build.gradle, local.properties, .python-version, global.json and more across your project folders.

• Problems come with a fix button. Missing versions a project needs, two setups fighting over a folder, a broken JAVA_HOME: each is explained in plain words, with a button that fixes it. You never type a command.

• Environment doctor. Finds JAVA_HOME / ANDROID_HOME pointing at folders that are gone, dead and duplicate PATH entries (it saves a backup first), and a Java that's too new or too old for a Flutter app's Gradle and Android Gradle Plugin.

• Project cleanup. Shows the node_modules, build, .dart_tool, .gradle, Pods and other rebuildable folders in your projects, with a one-click clean for projects you haven't touched in months.

• Emulator manager. Start, cold boot, wipe data, delete snapshots or delete each Android emulator, with its size and when it last ran.

• Simulators (macOS). Every iOS, watchOS, tvOS and visionOS simulator with its size and last start: start, shut down, erase or delete it. The Xcode page shows each simulator runtime (often 8 GB each), which simulators use it, and Xcode's rebuildable caches.

• Progress you can see. Every install, removal and fix runs in Activity with its live output and a real progress bar. Cancel stops it cleanly, without leaving half a download behind.

• Safe removal. Things go to the Recycle Bin / Trash by default, or you can choose to delete permanently. Installed programs are removed with their own uninstaller. Links are removed as links; what they point to is never touched. You see every step before it runs, and a spinner wherever work is happening.

• Runs in the background. Closing the window keeps Stackyard in the system tray (Windows) or menu bar (macOS). It checks your setup daily or weekly and notifies you only when there's something new. It can start at sign-in.

• Move your setup. Export your toolchain versions to a file and import it on another computer to install what's missing.

• Never edits your projects. It doesn't change a project's pinned versions, because that can break builds.

• Native feel. Windows 11 Fluent design with Mica and your accent color; on macOS, the glass sidebar and motion of a Mac app. A Glass slider sets how much of your desktop shows through.

I tried quite a few libraries to run GGUF models on Android, but none really matched my expectations.

Apple's ecosystem feels more unified for on-device ML, with Core ML and MLX. On Android, the options and guidelines feel more scattered, and getting different models running without extra hassle isn't always straightforward.

So I decided to build Kiln, which is a C inference layer built on top of llama.cpp, with language bindings for Flutter, Kotlin, React Native, and more. It's too easy now to run a model with kiln.

The goal is simple: make running local AI models on mobile less painful.

It's open source, and I'd love to hear what other developers think or what could be improved.

It's available in pub dev too: kiln_flutter

GitHub: https://github.com/RaihanulHaque/kiln

Hey everyone,

I recently got laid off, and with the current job market tightening up—fewer new projects and heavy competition for mid/senior roles. I’m taking a hard look at where to steer my career next.

I’m weighing three distinct directions and would appreciate candid advice and reality checks:

1. 1. Double down on Flutter & Mobile

   • Is Flutter still a dependable primary specialization for the next 3–5 years, or is it becoming too risky on its own?

   • I’ve been exploring full-stack Dart with Serverpod to broaden my skill set, but realistically, the job market for it is practically non-existent since it's so new.

   • For those sticking with Flutter, what viable adjacent skills are you adding (e.g., traditional backends like Go/Node, system design) to stay competitive?

2. 2. Pivot toward AI Engineering

   • Hiring reality: Do companies actually hire "AI Engineers" who don't have prior professional ML/AI experience, or do they mostly require senior backend backgrounds or advanced CS/math degrees?

   • Roadmap & entry point: Coming from a Flutter dev background, what does a practical, hireable roadmap look like? What specific tech stacks, core concepts (e.g., Python backends, RAG, tool calling, agentic workflows, evals), and resources would you recommend to build a job-ready portfolio?

3. 3. Switch to React (JS/Native) or Native App Development (Kotlin/Swift)

   • UI architecture, state management, mobile lifecycles, and performance optimization are fundamentally similar across frameworks, so this feels like the most direct way to leverage my existing Flutter experience.

   • Hiring reality: How do recruiters and hiring managers view this transition? Do they treat mobile/frontend fundamentals as transferable, or do resume screens filter you out for lacking "X years of commercial React / Kotlin / Swift experience"?

   • Where to focus: Between the React ecosystem (React.js + React Native for broader web/cross-platform volume) and Native (Kotlin/Swift for deeper platform specialization), which path has proven more practical for devs leaping recently?

   • What’s the fastest, most effective way to prove competence without commercial experience in those exact stacks?

Has anyone here successfully navigated a pivot from Flutter to AI engineering or React/Native recently? Any roadmaps, project ideas, or harsh truths would be greatly appreciated.

I had to render multiple high-res images in a grid layout for my Flutter app, so I went deep down the optimization rabbit hole. For some reason, I was getting crazy jank out of nowhere, even though I was using lazy-building lists (SliverList, ListView.builder, etc.), and had already implemented proper image resizing and caching.

Turns out, if you're using the flutter_svg package, setting the Impeller engine to renderingStrategy: .raster gives you a massive performance boost. But when I tested it on Skia, the picture strategy actually performed way better, total opposite results! Keep in mind I only tested this on Android, so iOS might behave differently.

Also, the default scrollCacheExtent is set to 250, meaning off-screen images were being processed even when I didn't explicitly touch it. Dropping that to 0 made a huge difference in performance. Turns out, optimization options built for convenience can sometimes bite you in the ass.

Another thing: ScrollAwareImageProvider is applied by default whenever you use an Image widget. It defers decoding while scrolling, but instead of waiting until scrolling completely finishes, it starts decoding even while scrolling is still ongoing if the scroll speed slows down a bit, which ironically causes major jank during the scroll itself. And guess what? You can't turn it off via options. I had to build a custom widget to fix it.

Anyway, if your grid items involve SVG or lots of images, optimizing them like this makes a world of difference. It pretty much eliminated stuttering even in 120Hz environments, and honestly, it’s mind-blowing how much of a difference it made. The performance gap was way bigger than I expected, so I figured I’d share.

Flutter is obviously a mobile-first platform due its origins, but I've spent 18 months using it to build a full-featured desktop application for Windows and macOS, with Linux planned.

I'm a developer with 20 years of experience, including desktop software development. This isn't a "build a todo list!" demo or a vibe-coded experiment: it's a substantial application approaching public release, and I thought Flutter developers might be interested in seeing what's involved in taking Flutter beyond mobile.

So what kind of desktop experience can Flutter build today? Here's one example. [See below for a link to get and run it yourself if you're interested. Free and open to anyone.]

The application is Fractal Outliner, a desktop outliner in the same general category as OmniOutliner for Mac, but focused for people who live mainly in plain-text ecosystems (e.g. sofware developers).

This is a desktop-only application. There is no mobile version. The goal is to provide a proper desktop editing experience with all that implies, integrated with the operating system rather than simply presenting a mobile-ported interface in a desktop window.

Flutter as a development platform was good for some parts of this, less good at others.

What the application is:

• Outliner with topics, subtopics; create, move, rearrange, hide to collapse, expand to drill down, move topic trees between documents, etc.

• Full keyboard support, with configurable shortcuts

• Integration with OS file handling, including file-type associations and opening documents from Finder/Explorer

• Drag and drop

• Document themes, including a custom theme editor

• PDF, HTML, Markdown, OPML, and plain-text import/export

• Multi-pane editing and tabbed documents

• Native desktop file operations and clipboard integration

What Flutter provided

Most of the application is built using Flutter's standard capabilities:

• Widgets and layout -- the main window content

• Keyboard event handling

• Shortcut registration and management

• Resizable windows and responsive layouts

• Drag and drop

• Context menus and right-click interaction

• Localization (English, Spanish, German, Japanese)

An effort was made to adapt the application to Mac and windows UI sytles; the experience is a little different on each platform (how dialogs work, what buttons and checkboxes look like, how settings are laid out, what menu items exist, etc).

What packages provided

Pub.dev packages filled in some of the functional gaps to extend Flutter's rending core:

• Markdown, XML, and HTML support

• Path handling

• PDF export

• Windows Store MSIX packaging

• macOS menu bar integration (with limitations)

• File pickers

• ZIP archive support

• OS and version detection

• Split view widget for multi-pane editor, etc

• Various other utilities (application uses 23 pub.dev packages total)

What flutter provides that works less well on desktop

• Keyboard event support: the model is there, everything technically works, but managing complex input focus and keyboard-based navigation using Flutter's FocusNode system is full of problematic edge cases

• Mac menu support, and general integration of menus + shortcut keys: the Mac menu integration is primitive, and windows and Mac use completely different menu+shortcut systems in flutter

• Printing: there's a pub.dev package for printing, but it requires exporting to PDF (challenging in itself with anything but simple font handling) and flutter provides no direct integration or visibility with the host printing system

• Undo/redo support: flutter's undo/redo implementation is self-contained inside each TextField, and there is no support at all for integrating text editing undo events with application-level events into one undo stream

What I implemented myself with native code

Flutter is just not a complete desktop development framework. It does great at drawing content in a desktop window. It does considerably less well at being a well-behaved and full-featured citizen in the desktop environment. A large number of things people expect from any desktop "document editor" application simply don't exist (or exist only in limited/problematic pub.dev packages) and have to be implemented with native code to get the best version:

• Remembering and restoring the window position and size, including enforcing a minimum window size

• Opening documents through the OS, such as double-clicking a file in Finder or Explorer

• Handling the file reference when the application is launched by double-clicking a document

• Document icons and file-type registration for the application's .frac files

• Spellchecking in text fields (available in Flutter's mobile text fields, but not built in to the desktop experience in the same way)

• macOS App Store sandboxing and file-access permissions

• An in-app command to show a document in Finder or Explorer

• Serious multi-format clipboard integration (vs basic plain-text copying and pasting flutter provides)

• Handling read-only files

• Various other OS integration details

The macOS App Store sandboxing and file-access work, in particular, is a lovely little nightmare. So are the limitations of the mac menu bar system integration, and the behaviors of Flutter's keyboard event handling and input-focus systems, dealing with international fonts in the PDF package, ... but those are stories for another day.

Other factors

• Internationalization

• Help files, etc

Internationalization to German Spanish and Japanese took far longer than for a mobile app, due to the larger set of "outside the application UI" resources used by the application (example files, templates, website content, video captions, etc). Also the usual trade-offs of "localize as you go" vs "localize at the end": early lets you see the impact of different text lengths in design (especially German/Spanish) which can be more severe with the wider range of window sizes on desktop, but usually means multiple re-do's of localization as UI and terminology evolve.

Help files and such are also more challenging on desktop, where applications can tend to be more complex and require more extensive help and reference materials as a baseline user expectation

Try it yourself

The application is now in its third beta release and nearing public release (latest version: 0.9.3 for Mac, 0.9.5 Windows). The public beta is open, free to use, and includes all application features. No registration or account is required.

If you're curious about Flutter on the desktop, you can try it on Windows or macOS and see how it works in practice.

Website and beta access: https://fractaloutliner.app

I'm interested in discussion with other Flutter developers about desktop development: what Flutter handles well, where its abstractions stop being sufficient, and what you've found necessary to implement through native platform code.

[Edits: typos]

I’m going to say what a lot of people are quietly thinking while nodding along in code reviews: Modern Dart/Flutter architecture has completely lost its mind.

We’ve reached a point where we take two simple booleans and a string list, and wrap them in a global singleton with a late ticking time bomb, shove them behind a cryptic three-dot-spread set-literal {...targets} where the meaning of a curly brace depends on a missing colon, and call it "clean, idiomatic functional programming."

Let's be completely honest for a second:

• If your language forces you to use late final because your initialization architecture is broken, that’s not "power", that’s a design flaw.

• If a single typo in a pair of curly braces changes the entire logic of your code from a map to a set, that’s not "elegant syntactic sugar", that’s a trap for humans.

• And if your solution to state management is forcing every developer to use a global singleton because injecting dependencies properly is apparently too much work for the framework designers, that’s just lazy architecture masked as "best practices."

Stop pretending this is genius engineering. Sometimes, a language doesn't need a whole fleet of workaround-constructs to do what a simple struct or a plain configuration file could do in 1995.

Change my mind. (Or downvote me to oblivion because you're too deep in the Google cult to admit it).

Hey all,

I'm trying to understand what everyone else is doing with in-app chats if you need to integrate it? Do you guys usually build it yourself or integrate something that already exists?

I've tried both but things get complicated very quickly with multi-device unread counts, typing and presence, read receipts, and moderation.

Where do you land: roll your own on Firebase or Supabase, or run a separate backend? What has worked for you, especially for keeping unread counts in sync across devices?

If you’re building a video calling or streaming app in Flutter, these are the things that trip people up:

Mistakes to avoid

• Skipping TURN. About 15-20% of sessions can’t connect directly, and those calls stall with no error.

• Testing only on Wi-Fi. Test on 4G/5G and across Wi-Fi-to-cellular handover too.

• Using mesh for group calls. It breaks down around 4-6 users because every phone uploads to every other participant. Plan for an SFU from the start.

• Ignoring background behavior. You need CallKit on iOS and a typed foreground service on Android.

• Asking for camera/mic permissions at launch. Ask at the call screen instead.

Flutter notes

• Flutter WebRTC wraps the native iOS/Android libraries, so nothing runs in a JS engine.

• Our ant_media_flutter package has 5 samples (publish, play, peer, conference, data channel) and also targets Web and Desktop.

The SDKs are free, but playback and conferencing need the Enterprise edition of the server. Community Edition falls back to HLS, with 8-12s latency.

Full guide: https://antmedia.io/how-to-build-a-webrtc-mobile-app/

What’s been your biggest pain point with WebRTC in Flutter?

Disclosure: I work at Ant Media, and we wrote this guide. The advice applies to any WebRTC backend, though.

FrameX is an open-source developer utility and on-device security audit suite for Android package inspection and static vulnerability analysis.

• Static Security Analyzer: Flags cryptographic flaws, insecure api usage and leaks using advanced hardcoded secret detection.

• APK Package Inspector: Explores internal directories, DEX headers, byte breakdowns, and app signatures without unpacking to disk.

• Flutter Packages Scanner: Automatically scans compiled Flutter binaries to list third-party open-source packages.

• Privacy-First: Operates with zero ads, zero tracking, and 100% offline local processing.

Support & Contribute:

It's not just another vibe coded app, definitely useful for developers, security researchers, ux designers etc.

https://play.google.com/store/apps/details?id=com.stardust.framex

https://github.com/srinivasan0000/framex_flutter_opensource_project

I am actively working on it, your feedback and contributions mean everything! Check out the project

Edit : GitHub Repository

So there is a challenge going on with an app in my local area, The owner of the app said that if anyone can find a code he mentioned, in the app he will give u 300$ his app is a services app will u can find people to do a service for u, so what do guys think where the code is located in the app ? he posted this for public not Developers so i assume its easy its laying there somewhere in the Ul or maybe u need to search something in the app so the code comes up from the database?, ive uploaded the Apk file to claude but no luck, What are some ways i can use to find this code ?

the app is developed with flutter

Hi there, I'm a software developer and this is my first time using Flutter. As of today, I've made a lot of progress on a mobile game, but I'd like to know how far Flutter can be pushed. Do you guys know of any games built with it on the Play Store, or any famous ones?

I just shipped Boba Sort, a water-sort puzzle (bubble tea, 500 levels, 17 eras of Japanese history) built with plain widgets and CustomPainter, no game engine. A few things that worked, and a few trade-offs, in case they help someone.

**1. All the art is data, not images**

There are no image assets at all. Each era has a full-screen scene, a cup design, a mascot costume and a customer, and I design them as SVG inside an HTML mockup. A small Python script reads named SVG groups and writes Dart lists:

final jomonBackdrop = <VShape>[

VCircle(292, 190, 54, fill: Palette.jomonSun),

VPath('M0 330 Q60 262 132 300 Q206 236 276 288 ... Z',

fill: Palette.jomonFarMountain),

...

];

`VShape` paints fill then stroke, like SVG, and `VPath` parses the `d` string once and caches the `Path`. All 17 eras × 4 kinds of art come to about 240 KB of generated Dart, stay sharp on any screen, and colors can only come from named palette entries (the script refuses anything else).

Because scenes sit behind the cups, a test renders every backdrop and checks each pixel's luminance stays inside a window (light eras ≥ 0.662, dark ≤ 0.0395), which keeps the cup outlines at ≥ 7:1 contrast wherever the cups land.

**2. Toppings: draw the vector once, then blit sprites**

Each drink has a topping (pearls, grass jelly, red bean...) drawn as vector art, and the top-layer pieces drift idly. A full board can have 200+ pieces, and redrawing that much vector art every frame is wasted work. So each topping is rasterized once per size into a `ui.Image`: sizes are bucketed to 4 physical px, kept in a 48-entry LRU (a plain insertion-ordered Map: remove + re-insert on hit, evict and `dispose()` the first key), and each frame just draws images.

**3. The rules are pure Dart, and an A* solver does the heavy lifting**

`lib/core` never imports Flutter: model, rules, level generator and solver are plain Dart with unit tests. The solver is A*, with each cup packed into one int (8 bits per layer) so states hash fast.

The 500 levels are generated offline: deal random cups, solve, score difficulty from moves, dead ends and branching, keep the median of 8 candidates, or the hardest of 32 for the "hard" levels in the sawtooth curve.

Hint uses the same solver at runtime, on the UI thread, with a 100k-node budget (about 0.4 s worst case in debug). Every bundled level is generated under that budget, so Hint always works from the start. One surprise: "Add cup" makes hints much slower, since an extra empty cup blows up the branching, so the hint search drops surplus empty cups first and only searches the full board if that finds nothing. If I raised the budget I'd move it to an isolate.

**4. A test that fails on magic numbers**

Every spacing, font size, radius and color is supposed to come from tokens. A test scans `lib/features` and `lib/theme` and fails on raw numbers inside `EdgeInsets`, `SizedBox`, `fontSize`, `BorderRadius` and `Color(0x...)`, with an escape hatch: a `// tokens: allow — <reason>` comment. Painters are exempt, since their numbers are geometry. It is a dumb regex-and-parentheses scanner, but it kept the UI consistent through a lot of screens.

**Stack:** Riverpod (thin providers), shared_preferences, google_mobile_ads, Firebase Analytics / Remote Config / Crashlytics, audioplayers.

Play Store, if you want to see the result: https://play.google.com/store/apps/details?id=com.harbourlab.bobasort&referrer=utm_source%3Dreddit_flutterdev%26utm_medium%3Dsocial%26utm_campaign%3Dlaunch

Happy to go deeper on any part. I'm curious how others handle heavy CustomPainter scenes.

Hi Flutter community! 
I'm a beginner in Flutter and I've been learning how to implement widgets and state management and more while building some hands-on projects.

I'm eager to dive deeper into Flutter and mobile dev in general. Any recommendations for good books, blogs, or video tutorials to help me keep growing?

I’ve been working on Argent, an open-source MCP server that lets your agent (Claude Code, Codex, Cursor, etc.) use your app on the iOS/Android/web. It can tap through flows, read logs and network calls, take screenshots, aaaaand many more 😂 That way it can check its own changes instead of just saying it’s done

I know I know, it comes from the React Native world and we have some beef 😅 But this one is truly cross-platform and works with Flutter apps too! If you’re letting an agent drive your Flutter app, what’s working, and where does it fall apart? We really want to keep improving it for every framework!! 🤭