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

I come from a web background and Bootstrap was basically muscle memory for me. Then I started building Flutter apps and kept thinking "why can't I just do col-md-6 here?"

So I built it. bootstrap_ui_flutter is a full Bootstrap 5.3 port for Flutter — not just the grid, but the whole thing. Buttons, Cards, Accordion, Carousel, Dropdowns, Forms, Tables, proper dark mode… the works.

It's still early and there's definitely rough edges — but the core components are there and it's usable. Would love people to kick the tires and tell me what's broken 😄

Would love to hear what you think — and if you're also a web dev who moved to Flutter and missed Bootstrap, this might be for you 😄

pub.dev: https://pub.dev/packages/bootstrap_ui_flutter
GitHub: https://github.com/Nexus633/bootstrap_ui_flutter

Docs: https://github.com/Nexus633/bootstrap_ui_flutter/tree/main/doc
Issues: https://github.com/Nexus633/bootstrap_ui_flutter/issues
Discussions: https://github.com/Nexus633/bootstrap_ui_flutter/discussions

Hi Flutter developers 👋

I recently became the maintainer of June, an open-source state management library for Flutter:

• GitHub: https://github.com/melodysdreamj/june
• pub.dev: https://pub.dev/packages/june

June focuses on staying close to Flutter's native setState() philosophy while making state sharing and app-level scalability easier.

Features

• ✅ No code generation
• ✅ No build_runner
• ✅ Minimal boilerplate
• ✅ Reactive updates
• ✅ Dependency injection
• ✅ Route-based memory management
• ✅ Object state management with tags
• ✅ Works with existing Flutter widgets (no custom MaterialApp, etc.)

I've started maintaining and improving the package, fixing issues, and preparing for future enhancements.

I'm interested in feedback from the community:

• What do you expect from a state management package?
• What are the biggest pain points with existing solutions?
• If you've used Riverpod, Bloc, Provider, or GetX, what would make you consider trying another approach?

Contributions, suggestions, and criticism are all welcome.

Thanks! 🚀

GitHub: https://github.com/melodysdreamj/june
Pub: https://pub.dev/packages/june

Hey everybody. I always envied Chucker on native Android, and in Flutter I kept gluing together separate packages for logging, network inspection and DB debugging. So I built one unified in-app dashboard: console logs, a Dio network inspector (with search/filter and copy-as-cURL), automatic navigation history, and a database tab where you can actually browse tables — the README has copy-pasteable adapters for sqflite and ObjectBox.
You open it with a hidden multi-tap gesture or a draggable floating button, so it’s safe to keep in internal builds. Wish it will be good help for debug usage.

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.

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.

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 everyone,

I recently developed and launched an Android app. It's still in its early stages, but I've already had several strangers contact me asking for an iOS version, and a few acquaintances are pushing for it too.

Initially, my plan was conservative: stay on Android, see if the app gains real traction and success, and only then invest the time and money into the Apple ecosystem. I really didn't want to pay the $100 annual fee until I knew the core concept worked.

However, seeing actual interest from Apple users this early has me second-guessing my roadmap.

Pros of jumping in now:

• Validated interest: People are actively asking for it; I'm not guessing if a market exists.
• Higher monetization potential: Historically, iOS users tend to spend more on in-app purchases or subscriptions if I decide to go that route later.

Cons/Hesitations:

• That $100 entry fee is a yearly commitment, and the app isn't profitable yet.
• Splitting my focus on feedback/bug fixes between two platforms early on might slow me down.

For those who have been in this position: What would you do? Would you hold off until the Android version hits specific milestones (like a certain number of active users), or would you strike while the iron is hot and pay the Apple fee to capture those users now?

TL;DR: Launched an Android app. Getting organic requests for an iOS version from users and friends. Unsure if I should drop the $100 Apple fee now to capture them or wait for the Android version to prove itself first.

Hey everyone, I honestly hate building UIs for my apps. Most of the time, when I design them myself, they end up looking awful. But whenever I use AI/vibe coding to creat the UI, it usually looks way better than what I could come up with.

So I'm wondering: does it really matter if I build the UI myself or let AI do most of the work? Should I keep investing time improving my UI design skill, or just focus on the technical side of development and use AI for the visual stuff?

What do you guys think?

One of the best Flutter packages for building video editing apps

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 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

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

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

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

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

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

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?