# flutter_quill: a Quill Delta rich text editor for Flutter apps

> flutter_quill is a WYSIWYG editor widget for Android, iOS, web and desktop Flutter targets. It stores content as Quill Delta JSON, which makes it a good fit for apps that already think in Delta, and a poor fit for teams that want HTML in and HTML out.

**singerdmx/flutter-quill** — Rich text editor for Flutter

- Repository: https://github.com/singerdmx/flutter-quill
- Website: https://pub.dev/packages/flutter_quill
- Stars: 2,916 · Forks: 1,059
- Language: Dart
- License: MIT
- Published: 2026-09-24 · Updated: 2026-09-24 · Language: en
- Canonical page: https://hysenlabs.com/projects/singerdmx-flutter-quill

## What flutter_quill solves, and for whom

Building a rich text field in Flutter from scratch means writing your own document model, your own selection handling, your own toolbar state and your own serialization. flutter_quill packages that work as a widget pair: QuillEditor for the editing surface and QuillSimpleToolbar for the formatting controls, both driven by a single QuillController. The README describes the library as a WYSIWYG editor built for the modern Android, iOS, web and desktop platforms, and the repository layout matches that claim: the root package sits next to flutter_quill_extensions, flutter_quill_test and an example app with android, ios, linux, macos, web and windows folders. The audience is Flutter developers who need formatted text inside their own app rather than a separate web view. If you are shipping a note-taking screen, a comment composer with bold and lists, or an in-app document editor, this is the shape of component you would otherwise have to build. The choice it forces on you is the storage format, and that decision outlives the widget.

## How the Quill Delta model drives the editor

Content is not HTML. The library uses Quill Delta to represent document content, and the README describes Delta as a series of operations denoting insertions, deletions or formatting changes. The controller is the single source of truth: you create it with QuillController.basic(), hand the same instance to the toolbar and the editor, and read state back from it. Saving means calling _controller.document.toDelta() and encoding the result as JSON; loading means decoding that JSON back into the document. Plain text is available separately through toPlainText(). This is the part worth thinking about before you write any UI. Delta is a diff-oriented format, so the same document can be represented by more than one operation sequence, and anything outside the editor (a server search index, a PDF exporter, a web view) has to understand Delta or receive a converted form. The README's table of contents lists a Delta Conversion section and a Rich Text Paste section, which tells you the maintainers treat conversion as a first-class concern rather than an afterthought. It also means your persistence layer is not a text column of markup; it is a JSON blob whose schema you now own.

## Installing flutter_quill and rendering a first editor

The documented install path is the pub command, which adds the dependency and resolves it against your Flutter SDK.

```bash
flutter pub add flutter_quill
```

The README also shows a git dependency form pinned to a tag, for cases where you need a version that has not reached pub yet.

```yaml
dependencies:
  flutter_quill:
    git:
      url: https://github.com/singerdmx/flutter-quill.git
      ref: v<latest-version-here>
```

Before any editor renders, the app needs the localization delegate registered, because the toolbar and editor strings come from FlutterQuillLocalizations. The README's MaterialApp snippet lists it alongside the standard Flutter delegates.

```dart
MaterialApp(
  localizationsDelegates: const [
    GlobalMaterialLocalizations.delegate,
    GlobalCupertinoLocalizations.delegate,
    GlobalWidgetsLocalizations.delegate,
    FlutterQuillLocalizations.delegate,
  ],
);
```

With the delegate in place, the minimal working screen is a controller plus the two widgets. The README attaches both to the same QuillController and wraps the editor in an Expanded.

```dart
QuillController _controller = QuillController.basic();

QuillSimpleToolbar(
  controller: _controller,
  config: const QuillSimpleToolbarConfig(),
),
Expanded(
  child: QuillEditor.basic(
    controller: _controller,
    config: const QuillEditorConfig(),
  ),
)
```

The controller must be disposed in your State's dispose method, which the README shows explicitly. After that, a save is jsonEncode(_controller.document.toDelta().toJson()) and a load decodes the stored JSON back into the document. If you are on version 10.0.0, the README points to a migration guide for 11.0.0 rather than describing the changes inline, so read that document before upgrading a shipped app.

## Android clipboard setup and the platform bridge

flutter_quill depends on three plugins according to the README: url_launcher for opening links, quill_native_bridge for platform-specific editor APIs, and flutter_keyboard_visibility_temp_fork for keyboard visibility changes. The only platform configuration the README spells out is Android, and only for one optional feature: copying images to the clipboard so other apps can read them. It requires a FileProvider entry inside the application tag of android/app/src/main/AndroidManifest.xml and a file_paths.xml resource. The README states that without this setup a warning appears in the log during debug mode only, and that copying and pasting images inside the editor works without any additional configuration. Treat this as the general pattern for the package: most things work out of the box, and the platform-specific edges are documented in one place. Note also the clipboard history. The README says that starting with 10.8.4, super_clipboard is no longer required in flutter_quill or flutter_quill_extensions, and that the internal quill_native_bridge is the new default. A separate quill_super_clipboard package exists for teams that want the old behaviour, with the README warning that support may be discontinued. If you are upgrading from an older release, that swap is the change most likely to affect existing clipboard code.

## Where flutter_quill is the wrong choice

The Delta-first design is the limitation as much as the feature. If your product's canonical format is HTML or Markdown, flutter_quill is not a drop-in: you will write conversion code in both directions and accept that formatting outside the Delta vocabulary does not survive the trip. The README's table of contents names Delta Conversion and Rich Text Paste as separate topics, which is an admission that conversion is a real surface area rather than a solved detail. The second constraint is the embedding story. The README exposes Embed Blocks as a distinct topic, and the Android image-clipboard instructions show that some platform behaviour depends on host-app configuration you own. If your editor needs custom embedded content types, budget for that work. Third, this is a widget library, not a backend. Nothing in the README covers collaboration, conflict resolution, versioning or server-side rendering; the persistence format is a JSON blob you store wherever you like. Teams that need real-time multi-user editing should look at how their CRDT or OT layer maps onto Delta before assuming the editor solves it. Finally, the README gives the git dependency form with a literal v<latest-version-here> placeholder, so pinning to a specific tag is something you must resolve from the releases page yourself.

## flutter_quill compared with super_editor

The obvious alternative in the Flutter ecosystem is super_editor, and the difference is architectural rather than cosmetic. flutter_quill is built on Quill Delta, the format from Quill.js, and its widgets are designed around that document model: you get a controller, a document, and Delta in and out. super_editor takes a document model of its own and aims at a broader editing surface, including multi-column and custom component layouts rather than primarily formatted prose. The practical consequence is where your content has to travel. If you already store or exchange Quill Delta, because you have a web editor on Quill.js or a backend that understands the format, flutter_quill keeps one representation across platforms. If your requirements are closer to a general-purpose content canvas with custom blocks, the Delta model becomes something you work around. Neither choice is reversible cheaply once documents exist in production, because migrating stored documents between two document models is a conversion project, not a dependency swap. Pick based on the format you want to own.

## Licence, maintenance and upgrade cost

The repository is MIT licensed, which permits commercial and closed-source use with the usual requirement to preserve the licence notice; this is a description of the licence text, not legal advice, and your own counsel should confirm obligations for your distribution model. On maintenance, the picture is concrete rather than rhetorical: the last push to the default branch was on 2026-09-16, the same day as the v11.6.0 release. The release history shows v11.5.0 on 2025-10-18, v11.5.1 on 2026-05-20 and v11.6.0 on 2026-09-16, so the cadence has been a mix of patch and minor releases rather than a steady stream. Upgrade cost is dominated by two things. First, the 10.0.0 to 11.0.0 migration, which the README treats as significant enough to warrant its own guide. Second, the plugin dependencies, since a change in quill_native_bridge or the keyboard visibility package can force a Flutter SDK constraint change in your app. The repository ships a CHANGELOG.md and a doc/ directory, so read both before a major bump rather than after.

## Conclusion

Adopt flutter_quill if your Flutter app needs an in-app WYSIWYG editor and you are willing to treat Quill Delta JSON as the storage format, including the round-trip work that implies for any server or export target. Do not adopt it if you need HTML-faithful documents on day one, or if you cannot add the localization delegate and the Android file provider entry to your host app. Before committing, verify three things yourself: that your Flutter version resolves against the pubspec constraint, that FlutterQuillLocalizations.delegate is registered in your MaterialApp, and that your save and load path survives a Delta round trip through your own backend.

## FAQ

### What is flutter_quill?

It is a WYSIWYG rich text editor package for Flutter, described in the README as a rich text editor and a Quill component for Flutter, targeting Android, iOS, web and desktop.

### Is flutter_quill an alternative to super_editor?

They are different document models rather than two skins on one engine. flutter_quill is built around Quill Delta and the Quill.js format lineage, while super_editor uses its own document model aimed at a broader editing surface. The choice mostly comes down to which format you want your stored documents to be in.

### What is the best rich text editor for Flutter?

The README covers flutter_quill only, so no comparison across the ecosystem can be made from it. What it does establish is that flutter_quill is MIT licensed, keeps content as Quill Delta JSON, and needs the localization delegate plus, on Android, an optional FileProvider entry for copying images to the clipboard.

### Is the Quill editor free?

The flutter-quill repository is MIT licensed, which permits commercial and closed-source use provided the licence notice is preserved. That describes the licence text, not legal advice for your distribution model.

## Sources

- [License: MIT](https://github.com/singerdmx/flutter-quill/blob/master/LICENSE)
- [Project website](https://pub.dev/packages/flutter_quill)
- [README](https://github.com/singerdmx/flutter-quill/blob/master/README.md)
- [Releases](https://github.com/singerdmx/flutter-quill/releases)
- [singerdmx/flutter-quill on GitHub](https://github.com/singerdmx/flutter-quill)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/singerdmx-flutter-quill