flutter-quill: a temp-fork dependency, a full-width comma in the Dart sample, and an Android grant over the whole cache

The git install path ships a placeholder nobody fills in

Installation offers one command:

flutter pub add flutter_quill

The alternative is a YAML dependency block, and it is the second block in the file where a value is left for the reader to supply:

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

The `ref` line is the whole problem: `v<latest-version-here>` is a template value, not a tag, and the surrounding YAML is otherwise complete enough to paste. The URL points at the repository's default branch, which is `master`, so anyone who deletes the ref line gets whatever is on that branch rather than a released version. Compare that with the first path, where pub resolves the published version and the lockfile records what it picked.

One of the three required plugins is named as a temporary fork

The Platform Setup section names the plugins the package uses, and there are three. `url_launcher` opens links. `quill_native_bridge` reaches platform-specific APIs for the editor. The third is `flutter_keyboard_visibility_temp_fork`, used to listen for keyboard visibility changes, and its name states on its face that it is a temporary fork of another package rather than the published one. A fork dependency is normal in Flutter work, but this one is on the path of every build that uses the editor, since keyboard height is not an optional feature. The upgrade note in the same section shows the pattern the project already follows: a package gets replaced, and the old one is kept alive under a new name.

The Android provider is granted the whole cache directory

Clipboard image support needs a FileProvider added to `android/app/src/main/AndroidManifest.xml`, with authorities built from the application id, `exported` set to false, and `grantUriPermissions` set to true. The companion `file_paths.xml` is two lines:

<paths>
    <cache-path name="cache" path="." />
</paths>

The `path="."` is the detail to notice. A cache-path element with a dot covers the entire cache directory of the application, not one subfolder of it, and it is paired with URI permission grants, so any file another app writes into that cache can be handed out by URI. It is scoped to a directory the platform already treats as disposable, and the provider is not exported, which limits the exposure, but the grant is broad by default rather than narrowed to an image folder. The file states the configuration is only required on Android for that optional feature, and that copying images inside the editor needs no extra setup.

Clipboard handling has already moved once, and may move again

A note records the previous migration: starting with version 10.8.4, `super_clipboard` is no longer required in `flutter_quill` or `flutter_quill_extensions`, and the internal plugin `quill_native_bridge` became the default. Anyone who wants to keep the old package is pointed at `quill_super_clipboard`, with the parenthetical that support may be discontinued. So the clipboard path has changed once inside the 10.x line and the replacement for the replacement is already hedged. That is worth weighing before an app takes a dependency on either name, because the note names `flutter_quill_extensions` as also having changed, which means a project using the extensions package has to check its own dependency list rather than only the editor package.

The localization sample ends with a full-width comma

The first usage snippet adds localization delegates to the app widget, listing the three global delegates and `FlutterQuillLocalizations.delegate`. Its closing punctuation is the problem. After the closing bracket of the delegate list, the line carries a full-width comma, the character used in Chinese typography, where Dart expects an ASCII comma. Pasting that block into a Dart file produces a syntax error at the end of the delegate list, which is a confusing first impression for a snippet whose entire purpose is to be copied. The rest of the sample sequence is sound: a controller created with `QuillController.basic()`, the toolbar and editor widgets attached to it with their config objects, and disposal of the controller inside `dispose` before calling `super.dispose()`.

Saving and loading take different shapes

Documents are represented as Quill Delta, described as a compact method of describing changes through operations for insertions, deletions, and formatting. Extraction has two forms, `_controller.document.toDelta()` for the deltas and `_controller.document.toPlainText()` for plain text. Saving serializes the delta's own JSON:

final String json = jsonEncode(_controller.document.toDelta().toJson());

Loading hands the decoded structure straight to the document:

_controller.document = Document.fromJson(jsonDecode(json));

The asymmetry is in what each side asks of the other. The save path calls `toJson()` on the delta before encoding, while the load path passes the decoded map into a document constructor, and the file does not state whether that constructor expects a delta map or a wrapper around one. Read-only mode is a third, smaller case, set with `_controller.readOnly = true`.

Seven entries in the contents list have no body in the file

The table of contents names twelve sections. Four of them are present with content: Installation, Platform Setup, Usage, and Input / Output, plus the start of Configurations, which states that both the toolbar and the editor widgets are customizable and points at the sample page for advanced configuration. The remaining seven are named and then not written: Embed Blocks, Delta Conversion, Rich Text Paste, Translation, Testing, Contributing, and Acknowledgments. Two of those absences have visible counterparts elsewhere in the tree, since a `l10n.yaml` sits at the top level for localization and a `CONTRIBUTING.md` exists as a file, so the content for those sections is in the repository even where the readme walkthrough is not.

Two sibling packages and a blame-ignore file share the repository

The top level holds `flutter_quill_extensions/` and `flutter_quill_test/` alongside `lib/`, so the editor, its extensions, and its test helpers are three packages maintained in one place and released together. Other entries carry their own weight: `l10n.yaml` drives localization, `analysis_options.yaml` sets the lint rules, `doc/` holds the code introduction and the `migration/10_to_11.md` guide linked from the install section, and `.git-blame-ignore-revs` marks commits to be excluded from blame, which is the usual sign of a repository that has been reformatted wholesale at least once. The example app carries its own directories for android, ios, linux, macos, web and windows, matching the six platforms the package claims to cover.

Editorial conclusion

flutter-quill is a sound default for Flutter apps that need rich text and can accept Quill Delta as their stored format, since the install is one command and the controller model is small. Three things to check first. If you need images on the clipboard to be readable by other apps, read the Android FileProvider section before you copy the snippet, because the supplied paths element covers the whole cache directory. If you are upgrading across a major version, note that 10.0.0 to 11.0.0 has a migration guide and that clipboard handling changed at 10.8.4, with the old package marked for possible discontinuation. And if you copy the localization example, fix its closing punctuation, which is a full-width comma rather than an ASCII one.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. singerdmx/flutter-quill on GitHub