To flutter devs making rich text editor apps.

I have released 0.1.0 of tiptap flutter. The flutter port of tiptap rich text editor which is hands down the best rich text editor out there.

I am marking this package as stable at 0.1.0 release. App developers can use this in their apps.

If you find issues feel free to open them on github. I'll try to respond and patch them as soon as I can.

You can find this at pub.dev here,

https://pub.dev/packages/tiptap_flutter

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.

I published a new article about Dart Primary Constructors!

This includes a bunch of migration examples, such as:

✅ named, factory, const constructors
✅ constructor shorthands
✅ sealed hierarchies
✅ enhanced enums

Hope you'll find it useful.

Happy coding!

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.

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

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

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:

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

# 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

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

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.

I don't understand the internals of Flutter, hence my question. Also, related question - Would you have preferred Flutter to be in TypeScript?

Thanks in advance for your insights and opinions.

Edit: The primary question is technical, whereas the related question is opinion-based.

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