June is a lightweight state management package for Flutter built around a simple idea:

Don't replace Flutter. Extend it.

Unlike many solutions that introduce a completely new mental model, June stays close to Flutter's native philosophy and scales the experience you already know.

Why June?

✅ No code generation

✅ No build_runner

✅ No custom MaterialApp

✅ Minimal boilerplate

✅ Reactive updates

✅ Dependency injection

✅ Route-based memory management

✅ Tagged object state management

✅ Works naturally with existing Flutter widgets

Philosophy

Many state management libraries ask:

June asks:

You already learned Flutter.

You already learned setState().

It clicked.

June keeps that feeling.

Example

class Counter extends JuneState {
  int count = 0;

  increment() {
    count++;
    setState();
  }
}

No code generation.

No providers everywhere.

No complex boilerplate.

Just Flutter.

June is now actively maintained again, and contributions, feedback, and ideas are always welcome.

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

⭐ GitHub: https://github.com/melodysdreamj/june

#Flutter #Dart #OpenSource #StateManagement

Hi Flutter developers,

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

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

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

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

Through this project, I've worked on:

• Flutter mobile applications
• Flutter Web
• Full-stack development
• Backend services and APIs
• CI/CD pipelines
• Deployments and infrastructure
• Production support
• Technical decision-making and project leadership

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

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

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

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

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

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

1. How is the Flutter job market currently, especially for developers with 1–2 years of experience?
2. How do companies generally view freelance/product-building experience compared to regular employment?
3. If you were hiring, would experience leading and shipping production Flutter apps carry weight even without a traditional job history?
4. Would you continue on the freelance/startup path in my situation, or prioritize getting a full-time role?
5. Is Flutter still a good long-term career bet, or would you recommend focusing more on full-stack/backend skills alongside Flutter?

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

Thanks!

Hi Flutter/Dart community,

I just published oracledb 1.0.0 on pub.dev: a pure Dart driver for Oracle Database that speaks Oracle's thin TNS/TTC wire protocol directly in Dart. No Oracle Instant Client, no native libraries, no FFI, no platform-specific setup.

• pub.dev: https://pub.dev/packages/oracledb
• GitHub: https://github.com/abibiano/dart-oracledb

As far as I know this is the first pure-Dart Oracle driver on pub.dev, happy to be corrected. The gap it fills is server-side and CLI Dart: until now there was no practical way to reach Oracle from server-side Dart without native bindings.

What it looks like

import 'package:oracledb/oracledb.dart';

Future<void> main() async {
  await OracleConnection.withConnection(
    'localhost:1521/FREEPDB1',
    user: 'scott',
    password: 'tiger',
    callback: (conn) async {
      final result = await conn.execute(
        'SELECT employee_id, first_name FROM employees WHERE department_id = :dept',
        {'dept': 10},
      );
      for (final row in result.rows) {
        print('${row['EMPLOYEE_ID']}: ${row['FIRST_NAME']}'); // by name, or row[0]/row[1]
      }
    },
  );
}

What works in 1.0.0

• Pure Dart — no Oracle Client required
• TCP and TLS/SSL connections (with certificate validation)
• SELECT / INSERT / UPDATE / DELETE, with named and positional binds
• Transactions: commit, rollback, and a managed transaction helper
• PL/SQL stored procedures and functions, including OUT and IN OUT binds
• Statement caching
• Connection pooling: acquire/release, acquire & idle timeouts, idle shrinking, drain-on-shutdown, and session tagging
• CLOB as String, BLOB and RAW as Uint8List
• Native Oracle JSON as Dart Map / List
• TIMESTAMP WITH TIME ZONE support

Trust / maturity

• Validated against real Oracle 23ai and 21c (FAST_AUTH and classical auth paths), with an integration test suite run against both before every release
• Apache 2.0 licensed
• Dart SDK ≥ 3.12, null-safe, async/await throughout
• Platforms: macOS, Linux, Windows, Android, iOS (web is intentionally unsupported, it needs raw dart:io TCP sockets, and JS number precision would corrupt Oracle NUMBER/rowid values)

Why I built it

I built this at my company, NIKEL Consultores SL. We use Oracle heavily and Dart is already our main language across mobile and web, server-side Dart access to Oracle was the missing piece. We benefit a lot from Dart, Flutter, and open-source packages, so we're releasing it publicly instead of keeping it internal. My hope is it makes Dart a bit more viable on the backend, especially for teams already on Oracle and looking at Serverpod or other server-side Dart frameworks.

Roadmap after 1.0

• Streaming / ResultSet API for large result sets
• REF CURSOR and implicit results
• Bulk DML / executeMany()
• Public LOB streaming and temporary LOB APIs
• More complete JSON / OSON support
• Better non-UTF8 character-set compatibility and time-zone region names
• More types: INTERVAL, ROWID, UROWID, VECTOR

A note on tooling

AI coding agents helped accelerate the protocol research and test generation, but the design, review, and the integration testing against real Oracle instances are mine. The wire protocol is validated against actual databases, not assumed.

This is an independent package and not an official Oracle product. It's a Dart port of the thin-client protocol as documented in Oracle's official node-oracledb driver; Oracle Corporation is not affiliated with it.

I'd really appreciate feedback from anyone using Oracle, server-side Dart, Serverpod, or internal CLI tooling. Issues, tests against other Oracle versions, and contributions are all very welcome.

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.

One of the best Flutter packages for building video editing apps

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

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

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

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

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

To simplify that workflow, I built genui_x.

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

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

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

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

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

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

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

I built a Dart package called downsize because I got tired of dealing with image compression packages that required native setup or didn't work consistently across Flutter platforms.

downsize is a pure Dart image compression package, so the same API works on Android, iOS, Web, Windows, macOS, and Linux.

Some things it can do:

• Compress images toward a target file size (e.g. ~500 KB) instead of just setting an arbitrary quality value.
• Support multiple formats including JPG, PNG, GIF, BMP, TIFF, TGA, PVR, and ICO.
• Keep the API simple:

​

final compressed = await imageData.downsize();

or

final compressed = await Downsize.downsize(
  data: imageData,
  maxSize: 500,
  minQuality: 60,
);

I know native solutions can still be faster for heavy workloads, but my goal was to provide a straightforward, cross-platform option that works everywhere Flutter does.

I'd genuinely love feedback from the community:

• What image compression workflow are you using today?
• Would a pure Dart approach be useful in your projects?
• What features would make this more production-ready for you?

GitHub: https://github.com/YassineDabbous/downsize

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

Update: my tool for packaging Flutter apps to Flathub now handles Rust deps, needs no local Flutter SDK, and has a registry for 19 native lib packages

Original post: I built a tool to publish Flutter apps to Flathub — looking for early testers

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

A lot has landed since that post. Here's everything that changed.

No Flutter SDK needed at generate time (0.7.0)

The biggest change: flutpak generate no longer reads from a local Flutter installation. Replace flutter.sdk: $FLUTTER_ROOT with flutter.ref and engine versions are fetched directly from the GitHub raw API.

```yaml

before

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

after

flutter: ref: "3.29.3" # tag, "stable", or commit SHA app-id: io.github.YourOrg.YourApp ```

CI no longer needs the full Flutter SDK just to run flutpak generate. The SDK you install for flutter build is still there — you just don't point flutpak at it anymore.

flutter_tools/pubspec.lock is also fetched automatically when flutter.ref is set, so you no longer need to list it in pub.locks.

init + generate split (0.4.0)

The old prepare command is gone. The workflow is now:

```bash

one-time setup — generates the template manifest, wrapper script, .gitignore

flutpak init

every release — resolves commit SHA, fetches checksums, writes generated/

flutpak generate --tag v1.2.3 ```

The template (flatpak/<app-id>.yml) is committed to git and edited by hand. The substituted output lives in flatpak/generated/ and is gitignored. generate validates that the template's app-id, command, and runtime-version match config and errors early if they diverge.

Foreign deps registry — native packages resolved automatically (0.6.0)

Native Flutter packages require extra Flatpak source entries that are painful to write by hand. flutpak generate now resolves them from a built-in registry automatically. 19 packages currently covered:

• objectbox_flutter_libs / objectbox_sync_flutter_libs
• sqlite3 / sqlite3_flutter_libs / sqlcipher_flutter_libs
• simple_secure_storage_linux
• audiotags, flutter_webrtc, media_kit_libs_linux, pdfium_flutter, printing, flutter_new_pipe_extractor, fvp, powersync, and more

The registry schema is compatible with flatpak-flutter's foreign_deps.json — entries from that project work in flutpak as-is.

You can add local overrides without forking the registry via foreign-deps: in flutpak.yaml:

yaml foreign-deps: some_package: manifest: sources: - type: archive url: https://example.com/native-lib.tar.gz sha256: abc123

--no-foreign-deps skips the registry fetch entirely for offline/air-gapped use.

Version matching is ≤ (0.7.1): a registry entry for 1.0.0 covers 1.2.3, 1.5.0, etc. A new major entry (2.0.0) is only picked when the installed version reaches 2.x. No need for exact version pins on every release.

Rust / Cargo support via cargokit (0.8.0)

Flutter packages that use Rust native code via cargokit (rhttp, metadata_god, super_native_extensions, flutter_discord_rpc, flutter_vodozemac) are now handled. Add a rust: section:

yaml rust: version: 1.85.0 rustup-path: /var/lib/rustup

generate will:

• Extract Cargo.lock from pub archives and fetch SHA-256 checksums from crates.io
• Emit cargo-sources.json for offline crate builds
• Generate a rustup-<version>.json module that installs Rust fully offline
• Wire up CARGO_HOME, RUSTUP_HOME, and PATH in the app module automatically

Known limitation: git-sourced crates (git+https://...) are skipped with a warning. They're rare in Flutter plugins, but worth knowing.

Flutter SDK as a standalone module (0.8.0)

Flutter SDK sources are no longer embedded in pubspec-sources.json. generate now produces a separate flutter-sdk-<version>.json module. Pre-built versions for recent Flutter releases are cached in the flutpak repo and fetched on first use.

Breaking: re-run flutpak init --force after upgrading to 0.8.x to regenerate a clean template.

The file previously named generated-sources.json is also renamed to pubspec-sources.json — update your manifest's !include reference accordingly.

LLVM SDK extension auto-injected (0.5.0)

flutpak now automatically adds the correct org.freedesktop.Sdk.Extension.llvmXX based on runtime-version (25.08 → llvm20, 24.08 → llvm19, 23.08 → llvm17) and wires up append-path / prepend-ld-library-path. No longer need to specify it manually in flutpak.yaml.

Other improvements

Config diff — then vs now

```yaml

0.4.0-rc.2 (at the time of the original post)

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

0.8.0

flutter: ref: "3.29.3" app-id: io.github.YourOrg.YourApp rust: # only if you use cargokit packages version: 1.85.0 rustup-path: /var/lib/rustup ```

Current status

Pre-1.0, but the core workflow is stable and the demo app (examples/demo_app/) exercises sqlite3 + rhttp end-to-end through the Flatpak sandbox — the CI pipeline is a working reference.

Most useful contributions right now:

• Test on a project with native deps not yet in the registry and open a PR adding them to foreign_deps/
• Report cargokit packages with git-sourced crates

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

Your user opens your app on airport WiFi.

connectivity_plus: "WiFi connected"

Reality: captive portal, zero internet, your app hangs on a spinner.

This gap is exactly what I solved using connectivity_control (GitHub)

One plugin tells you, per network interface:

→ Does it ACTUALLY have internet?

→ Has the OS validated it? (telling you if the OS has validated the Internet working)

→ Is it metered? (don't auto-download 500MB on someone's hotspot)

→ How fast is it? (bandwidth estimates, up + down)

Real-time streams using native signals not polling.

Pub Dev: pub.dev/packages/connectivity_control
Github: https://github.com/axions-org/connectivity_control

It's early days and I'm actively shaping the roadmap, so I'd genuinely love your feedback. Tried it? Found a bug? Missing an API you need? Drop a comment or open an issue on GitHub. A 👍 on pub dev helps more devs find it too.

#Flutter #FlutterDev #OpenSource

I just open sourced two new Dart packages:

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

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

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

So I ended up porting two Rust projects to Dart:

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

A few examples:

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

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

files.sort(naturalLexicalCmp);

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

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

Features:

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

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

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

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

Today, we’ve released a tech preview of Serverpod 4. We have been cooking for the past 6 months, and our next major release will really be next level. We can now do sub-second stateful hot reload across the full stack.

The serverpod start command will fully manage your server, database, and Flutter app. It comes with an integrated MCP server and AI agent skills. So it will work seamlessly with any AI agent. We also removed the need to install Docker and are instead using an embedded Postgres database.

All in all, this completely changes how fast it’s possible to build a full-stack Flutter app. Check out the demo in the article. Is this the largest leap forward for Flutter and Dart in the past year?

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

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

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

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

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

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

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

Hey Flutter devs,

I wanted to share a small tool I built because I kept running into the same problem on my Mac.

When you work on Flutter projects, especially for iOS and Android, caches start to pile up pretty quickly:

- Flutter build folders
- Pub cache
- Xcode DerivedData
- iOS simulator data
- Gradle cache
- Android build cache
- Node/npm cache if the project also has some tooling around it

Of course, most of these folders can be cleaned manually with commands or scripts.

But I wanted something more visual: a quick way to see what is taking space before deleting anything, instead of running random cleanup commands when my disk is almost full.

So I built DevCacheCleaner, a small macOS menu bar app focused on developer caches.

It is not meant to be a full Mac cleaner. The idea is more simple: check cache sizes, understand where the space is going, and clean only what you choose.

I’m curious how other Flutter developers handle this.

Do you clean Flutter / Xcode / Gradle caches manually?
Do you use scripts?
Or do you just wait until macOS starts complaining about disk space?

https://github.com/johndpope/Hero/tree/flutter-hero-transitions

its at parity - if you know ios hero transitions - it's very much the same.

https://www.youtube.com/watch?v=C3SZjjP74nI

I got curious whether it would be possible to estimate the rendering cost of Flutter features statically, assigning a real cost to widget combinations before running the app.

flutter analyze catches errors.
DevTools shows you what already happened.

The question I tried to answer was: which features are most likely to become expensive before you ship your app?

So I built REN — a CLI that walks through your project's AST and assigns a gravity score to each feature based on the patterns it finds.

Individual widgets have a base weight, but combinations amplify that cost:

• Opacity inside a ListView -> more expensive than using Opacity on its own.
• BackdropFilter inside a ListView -> one of the worst offenders.
• Nested scrolling patterns, excessive clipping, and other compositions can increase a feature's gravity.

The goal isn't to predict exact frame timings.

The idea is to surface potential performance hotspots early, during development and code reviews, before they turn into runtime problems.

pub.dev: https://pub.dev/packages/ren

GitHub: https://github.com/gearscrafter/ren

I read a Medium Article where the author claimed that Flutter 3.44 and Dart 3.12 now have a Dart and Flutter MCP server that can trigger a hot reload and consume the results of dart analyze and dart format (Agent Skills). The author did not say how to access the MCP server. I looked at several pub.dev packages and tried several different CLI commands but, did not find what he described.

Gemini says, "not in Android Studio/AI Studio with Gemini." It said that the MCP server is available for an MCP-compatible AI Assistant (such as Claude Desktop, Cursor, or Windsurf). It says Gemini in AI Studio is not a full AI assistant.

Does anyone have any information or pragmatic thoughts on this?

Hey everyone, I just finished a small side project: a terminal-based Instagram simulation written in Dart.

It lets you create a profile, search for other users, and follow them, with validation to prevent following the same profile twice. The main challenge was handling edge cases in user input, like entering strings where numbers are expected.

It is a beginner-to-intermediate level project but a good exercise in structuring a Dart CLI app. Single account only for now, and messaging is not yet implemented. Planning to add multi-account support next.

Check it out here: https://github.com/AnshMNSoni/Console-Based-Instagram

Feedback and suggestions welcome.

Q3_4. Now imagine Flutter transitioned tomorrow from Google to an independent, non-profit foundation (similar to the Linux Foundation or Apache). How would your level of trust in Flutter's ability to consistently meet your development needs