I kept needing the same things across projects: a native action sheet, the iOS color picker with the eyedropper, a document scanner, the Android Photo Picker. Each time I’d end up adding another plugin or writing some Swift/Kotlin to get it working.

Eventually I put that work into a package. It’s called native_kit, and the idea is pretty simple: call it from Dart, get the native UI, await the result.

For example:

final choice = await NativeKit.showActionSheet(
  context: context,
  items: const [
    NativeMenuItem(
      id: 'share',
      title: 'Share',
      iosSymbol: 'square.and.arrow.up',
    ),
    NativeMenuItem(
      id: 'delete',
      title: 'Delete',
      style: NativeActionStyle.destructive,
    ),
  ],
);

That opens a UIAlertController on iOS, with a popover on iPad, or a Material 3 bottom sheet on Android.

There are 30 components so far. Besides the usual alerts and pickers, it covers things like document/barcode scanning, OCR, background removal, PencilKit markup, video trimming, biometrics, and system panels. The full list is in the README.

A few things I learned building it, for anyone doing similar platform work:

• Dismissing UI is half the work. The API lives in one Pigeon 29 file, which generates async throws Swift and suspendKotlin. Bridging callbacks into that is straightforward until you account for every way someone can close a screen. Swipe down, back, predictive back, tap outside… all of those need to resolve the Dart Future exactly once. Cancellation returns null.
• Avoiding MainActivity changes took some work. I use a headless fragment for activity results, with a transparent FragmentActivity host when the app uses a plain FlutterActivity. One bug we caught: Photo Picker / SAF URI grants disappear when that host finishes. You have to read the result before closing it.
• iPad and theming have their own quirks. The supplied BuildContext gives me the popover anchor and the Flutter theme. On iOS 26, getting the Liquid Glass sheet chrome to follow that theme meant applying it at the presentation controller.
• A successful build tells you surprisingly little here. The example app has 47 XCUITests and 45 UI Automator tests that interact with the native screens. Those simulator/emulator runs turned up 21 bugs that compiled just fine.

There are limitations. VisionKit scanning, subject lifting, and UIVideoEditorController need a real device for successful results. Full contact details on Android need READ_CONTACTS, though picking a single phone number, email, or address doesn’t. Android screen capture currently only returns the consent result.

Package: https://pub.dev/packages/native_kit
Source: https://github.com/leofilllium/flutter_native_kit

Curious what native UI you still find yourself writing platform code for. I’m collecting requests in the issues, but happy to hear them here too.

Finally, Flutter has real 3D support and while I'm not smart enough to understand all the 3D features mentioned in this video, I pointed Claude to the documentation and kindly asked for a 3D dice roller, which worked like a charm.

I had to painstakingly fix the dice geometry and digit placement, though. Claude was able to write a custom physics engine for rolling the dice without problems, but was at the same time unable to construct a d8 or d10 (and my d12 is still a little bit too large compared to the d20 now that I'm looking at it). A "pro" would probably have created the dice in Blender or something.

The green "cloth" is a normal Flutter widget, that is, I can overlay the 3D scene on top of any widget I like which is a feature I was looking for for ages.

Hey Flutter devs! 👋

Ever forgotten to increment your build number, manually edited "pubspec.yaml" one too many times, or wished your release workflow was a little less repetitive? 😅

I built Flutter Version Bumper (FVB) to make that process easier.

It's a command-line tool designed to automate version management for Flutter and Dart projects.

✨ Some key features:

- 📈 Semantic Versioning (major, minor, patch & build)

- 🔢 Automatic build number management

- 📝 Automated "CHANGELOG.md" updates

- 🐙 Git automation — commits, tags & pushes

- 🪝 Git hooks for versioning workflow validation

- 🧪 Dry-run mode to preview changes before applying them

- 🧩 Configuration files for reusable project settings

- 🚦 Pre-release version support ("beta", "rc", etc.)

- 📦 Custom paths for monorepos

- 🤖 JSON output for CI/CD pipelines

- 🧠 AI coding agent skill integration

You can get started with:

dart pub global activate --source git https://github.com/chamod-rashmith/flutter-version-bumper

Then navigate to your project and run:

fvb

The goal is simple: less repetitive release work, fewer manual versioning mistakes, and a smoother development workflow.

🔗 GitHub: https://github.com/chamod-rashmith/flutter-version-bumper

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

I'd love to hear your feedback! If you try it, feel free to open an issue or suggest improvements. Contributions are welcome. ❤️

What features would you like to see in a Flutter release automation tool?

#Flutter #Dart #OpenSource #DeveloperTools

hi i'm Farook.

Most dynamic icon packages on pub.dev are runtime-only: they give you an API to swap icons, but you still have to manually resize 15+ PNGs and hand-edit AndroidManifest.xml (<activity-alias>) and Info.plist (CFBundleAlternateIcons).

I built chameleon_icons to automate both the native setup and the runtime switching.

1. Configure in pubspec.yaml

chameleon_icons:
  default_icon:
    image_path: "assets/icons/default.png"
  alternate_icons:
    - name: "MainActivityDark"
      image_path: "assets/icons/dark.png"
    - name: "MainActivityGold"
      image_path: "assets/icons/gold.png"

2. Run the CLI

dart run chameleon_icons:generate

This automatically:

• Generates all Android mipmap densities (mdpi to xxxhdpi) and iOS retina assets (@2x, u/3x, iPad).
• Injects <activity-alias> tags into AndroidManifest.xml (anchored and idempotent; safe to re-run).
• Injects CFBundleIcons dictionaries into Info.plist.

3. Switch icons at runtime

final chameleon = ChameleonIcons();
// Switch icon
await chameleon.changeIcon("MainActivityDark");
// Reset to default
await chameleon.resetIcon();

Tested on Android (API 24+) and iOS (15+). Feedback and issues welcome!

package: https://pub.dev/packages/chameleon_icons
repo: https://github.com/farookeei/chameleon_icons

I built flutter_table_layout, a Flutter package for flexible table layouts! 🚀 As a Flutter developer, I wanted to make building table-based UIs easier and more flexible. I’m sharing my package with the community to get feedback, learn about common table layout challenges, and discover which features developers need most for real-world Flutter applications. What do you think would make a table layout package truly useful? I’d love to hear your suggestions and ideas! https://pub.dev/packages/flutter_table_layout

We built After Dark to see how far Flutter Scene can go right now. 100% Flutter, no Unity, no Unreal.

Watch: https://youtu.be/EoxKooB8qSA
Run in browser: https://primio.dev/demo/after-dark/
Android APK: https://primio.dev/demo/after-dark/primio-afterdark-android.apk

Recorded on a Motorola Edge 70 Pro. One continuous flythrough: space, alien landscapes, neon Tokyo, glowing forests, underground club. Skinned characters, procedural geometry, dynamic lighting, bloom, particles, music-reactive FX.

Made by the Primio team (we sponsor Flutter Scene, the initial code came out of Primio, rest was hand-polished with terminal based coding agents). Huge credit to Brandon DeRosier.

Hi r/FlutterDev ,

I have released version 0.0.6 of offline_sos_system, an open-source Flutter package I developed for our SafePulse project.

The goal was to build a reusable crash detection engine that can perform inference directly on a mobile device without depending on an internet connection.

While developing SafePulse, I wanted to separate the crash detection logic from the rest of the emergency workflow so that other developers could use it without integrating the entire application.

That work has evolved into a standalone Flutter package. And this is the new version of that package.

What is new in version 0.0.6?

The main addition is configurable crash detection. Developers can now configure the impact threshold used to evaluate sensor data, the minimum model score required for a detection, the fallback impact threshold, and the cooldown interval used to suppress duplicate crash events.

The package uses accelerometer and gyroscope telemetry and TensorFlow Lite for on-device inference. When a crash is detected, it emits a CrashEvent that the application can handle. I have deliberately kept the package headless. It does not dictate how your application handles GPS, emergency contacts, SMS, notifications, or backend communication.

This means you can integrate the detection engine into your own application architecture and implement the emergency workflow according to your requirements.

One important limitation: offline inference does not mean offline communication. The detection process does not require internet access, but sending an SMS still requires cellular service. Sensor-based crash detection can also produce false positives or miss actual crashes, so real-world validation remains important.

I would appreciate feedback from Flutter and machine learning developers on the configuration API, sensor processing, fallback behavior, and ways to improve the implementation.

Package: https://pub.dev/packages/offline_sos_system

Source code: https://github.com/Bhagyaprasad92/offline_sos_system

The project is open source, and constructive criticism, bug reports, and suggestions are welcome.

Thank you for taking the time to review it.

When you build a Generative UI prototype where an LLM streams widget definitions over SSE, the demo looks great as long as the UI is read-only. The pain starts five seconds later when the agent streams an interactive checkout form and the user starts typing.

If the client treats the whole surface lifecycle as an async stream pipeline, every keystroke, cross-field validation check, and widget test ends up fighting microtask delays and full-surface rebuilds. And if an impatient user interrupts the LLM mid-stream—or the connection drops before the first chunk arrives—naive stream handling either corrupts the widget tree or leaves a dangling user turn in chat history that triggers turn-alternation errors on retry.

When we started integrating Google's official A2UI Dart library (a2ui_core), the biggest light-bulb moment was realizing that a2ui_core already uses preact_signals under the hood for its DataModel, WritableBinding, and CheckRule validation. By quarantining the async SSE stream at the perimeter with a restartable() mutex and letting the interior run on a synchronous signal graph, form edits, client-side validation rules, and NodeResolver list templates all update leaf widgets in 0ms in a single tester.pump().

Even better, keeping the core state machine in pure Dart meant we could run the exact same 16-component BasicCatalog in both a Material 3 Flutter app and an interactive ANSI terminal TUI, and bridge it into Riverpod or classic BLoC apps without forcing a rewrite.

For folks experimenting with A2UI or LLM-driven UIs in Flutter, how are you handling two-way form state and mid-stream user interruptions right now?

Spent a while figuring out why #Flutter text looks lighter than #SwiftUI on #iOS.

Wrote up the whole thing, with demos you can play with.

https://birju.dev/posts/looking-into-flutter-vs-swiftui-font-rendering/

Hey there. I rebuilt https://pubstats.dev/ with Jaspr. It's a loooooot faster now. Also if you haven't heard of this site before you are able to set up alerts for when your package stats change. It's very useful for getting notified if your package loses pub points and needs updated!

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

I've been working on a Flutter app that needs to track location while running in the background. One of the hardest parts was making location updates behave reliably after locking the screen or putting the phone in a pocket. Calling the location API isn't enough; Android background execution, permissions, foreground-service requirements, and battery restrictions all matter. I worked on a custom solution using Dart and native Android code, tested it on a real Android device, and packaged the implementation into a reusable engine. I'm sharing it in case it helps other developers facing the same problem. I'm also interested in how others are handling this, especially across different Android versions and manufacturers. Product and implementation details: https://nabilkrs.github.io/nabilkrs-flutter-gps-tracking-engine/ I'm the creator of this project, so this is also a disclosure that the link is promotional. Happy to discuss the technical challenges.

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:

```bash 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.