# ComicSparks/jasmine: a Flutter comic browser with a Rust service layer

> Jasmine is an MIT-licensed comic browser for Android, iOS, macOS, Windows and Linux, built with Flutter for the UI and Rust for the service layer. The README is explicit about restricted content and non-commercial use, and that shapes who can adopt it.

**ComicSparks/jasmine** — A comic browser，support Android / iOS / MacOS / Windows / Linux. 

- Repository: https://github.com/ComicSparks/jasmine
- Stars: 5,443 · Forks: 357
- Language: Dart
- License: MIT
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/comicsparks-jasmine

## What Jasmine is, and the restriction that comes before the code

Jasmine is a comic browser published under the MIT license by the GitHub organisation ComicSparks. The README describes it in one line: a comic browser supporting Android, iOS, MacOS, Windows and Linux. The repository is written primarily in Dart, with Rust listed under the technical architecture as the high performance service behind the Flutter UI. The topics attached to the repository include flutter, rust, ios, jmcomic, pica and picacg, which tells you roughly which source sites the app is aimed at.

The README opens with three numbered notices before any feature list appears. The first says the app has restricted content. The second asks readers to know local laws before using the code. The third states that the repository owner will not release the code and its assets to the community outside GitHub. A later section adds two rules: the code may only be learned from and used, commercial use is prohibited, and assets must not be sent to anyone.

That is the practical frame for everything else on this page. The LICENSE file is MIT, but the README's own rules are narrower than MIT's grant. If your intended use is a product, the README is telling you not to. If your intended use is reading comics and studying how a Flutter-plus-Rust client is put together, the project is aimed at you. The README does not reconcile the two positions, and it does not define what counts as commercial. Treat that gap as a real one, not a formality.

## The Flutter and Rust split, and what the repository layout shows

The README's technical architecture section is two lines long: Flutter for high-performance UI, Rust for high performance service. A diagram image is referenced but not described in text, so the exact boundary between the two is not spelled out in the README. The layout fills in some of it. There is a lib/ directory, which is where Dart source normally lives in a Flutter project, and a pubspec.yaml at the top level, which is the Flutter dependency manifest. Platform directories sit alongside it: android/, ios/, macos/, linux/, windows/, and also ohos/, which points at OpenHarmony rather than the five platforms named in the README's one-line description.

There is a test/ directory, a scripts/ directory, a ci/ directory and a .github/ directory, plus .fvmrc, which is the config file for Flutter Version Management. The presence of .fvmrc suggests the project pins a Flutter version rather than tracking whatever is installed, which matters when you try to build it. analysis_options.yaml is present, so the Dart analyzer is configured rather than left at defaults.

What the README does not give you is the Rust crate layout. There is no top-level Cargo.toml in the listed entries, and no rust/ directory at the top level. The README says Rust is part of the architecture, and the repository topics include rust, but the README does not say how the Rust code is invoked from Dart, whether through FFI, a subprocess, or a local service. If the Rust layer is what interests you, that is the first thing to check in the tree before you invest time.

## Feature set as the README lists it

The README's feature checklist is the only feature documentation in the repository. Under Comics it marks comic categories, comic reader, comic search, comic favours, histories and cache comic as done. Under Community it marks list comments and send comments as done. Under User it marks login and register as done. Under Devices adaptation it marks Android's high frequency screen as done. Games is the single unchecked item.

Read that list for what it implies. There is no item for offline sync across devices, no item for reading progress export, and no item for a plugin or source-extension mechanism, even though the repository topics name several comic sources. The README does not explain how sources are configured or whether users can add their own. Cache comic is listed as a feature, but the README does not say where the cache is stored, how large it grows, or how it is cleared.

The screenshots referenced in the README show a browser view and a reader view, which confirms the two main surfaces but adds no detail about navigation, gesture controls or reading modes. If you are evaluating Jasmine against your reading habits, the checklist tells you the categories of things that exist and nothing about how well any of them works.

## Installing Jasmine and opening it for the first time

The README does not contain installation instructions. It links to the GitHub releases page through a badge, and the releases listed are v1.7.21 from 2026-07-20, v1.7.20 from 2026-04-27 and v1.7.19 from 2026-04-14. For most readers the practical path is to download a build from the releases page rather than compile from source, because the README gives no build steps at all.

If you do build from source, the repository layout tells you what the toolchain expects. There is a pubspec.yaml for Flutter dependencies and a .fvmrc for version pinning. A standard Flutter fetch and run sequence would look like this, using the commands the Flutter toolchain itself provides rather than any project-specific script:

```bash
flutter pub get
flutter run
```

The first command resolves the dependencies declared in pubspec.yaml. The second builds and launches the app on a connected device or the currently selected desktop target. Because the project pins Flutter through .fvmrc, you may need to select the matching SDK version first if you use FVM; the README does not state which version that is, so read .fvmrc to find out. The README also does not document how the Rust component is built or linked, so treat a successful Dart build as the first checkpoint and not the finish line.

There is a scripts/ directory in the repository. The README does not describe what the scripts do, so if the plain Flutter commands fail, that directory is the next place to look rather than guessing at flags.

## Where Jasmine is the wrong choice

The clearest limitation is the licence position. The README prohibits commercial use in plain language, and the MIT LICENSE file does not repeat that restriction. If your legal review relies on the LICENSE file alone, you will reach a different conclusion than the README's rules section. The README does not resolve this, and it does not offer a separate commercial licence. That alone disqualifies Jasmine for any product work.

The second limitation is documentation. There is no install guide, no build guide, no architecture document beyond the two-line Flutter-and-Rust summary, and no statement of which Flutter or Rust versions are required. The README does not document rollback, migration between releases, or what changed between v1.7.19 and v1.7.21. Release notes are not included in the repository's published documentation, so you cannot tell whether a version bump is a fix or a breaking change without reading the commit history yourself.

The third is scope. The README's own description names five platforms, but the repository also contains an ohos/ directory for OpenHarmony. That is not a problem in itself; it does mean the one-line description and the tree disagree slightly, and you should not assume a platform is supported just because a directory exists. If your target is a platform not covered by a directory in the tree, Jasmine is not the tool for you.

## How Jasmine differs from a server-based manga reader

The obvious comparison is a self-hosted manga server that runs on a machine you control and serves a web reader to any browser. That model puts the library, the metadata database and the source connectors on the server, and the client is thin. Jasmine inverts this: it is a client application, distributed as a release binary per platform, with Flutter rendering the interface and Rust handling the service work on the device. Your reading history, favourites and cache live with the app, not on a server you can back up centrally.

That difference has consequences. A server-based reader gives you one place to fix a broken source connector, and every client picks it up immediately. Jasmine gives you a release cycle: the fix ships in a new version, and users on older releases stay broken until they update. A server-based reader also lets you share a library across devices trivially, because the server is the shared state. Jasmine's README lists histories and favours but says nothing about syncing them between your phone and your desktop, so do not assume that works.

In exchange, Jasmine has no server to run, no ports to expose, and no hosting cost. For a single user on a single machine, that is a simpler arrangement. The trade is that you are dependent on the maintainers shipping a new release whenever a source changes, and the release cadence visible in the release list is roughly monthly to quarterly.

## Maintenance, upgrades and what the licence actually covers

The last push to the master branch was on 2026-07-28, and the most recent release, v1.7.21, was published on 2026-07-20. The repository is not archived. The gap between v1.7.20 on 2026-04-27 and v1.7.19 on 2026-04-14 is thirteen days, while the gap from v1.7.20 to v1.7.21 is nearly three months, so the cadence is not steady. Plan for upgrades to arrive irregularly.

The upgrade cost is not documented. The README does not describe a data migration path between versions, does not say whether cached comics survive an upgrade, and does not say whether login sessions persist. If you keep a large cache, assume you may lose it on upgrade until you confirm otherwise. The README also does not document rollback, so downgrading after a bad release is an open question.

On licensing: the repository ships an MIT LICENSE file, and the README separately states that the code may only be learned from and used, that commercial use is prohibited, and that assets must not be redistributed. Those two positions are not identical. MIT permits commercial use and redistribution; the README forbids both. This is a factual conflict in the repository, not a legal opinion, and resolving it is a question for a lawyer rather than for this article. What you can say without qualification is that the README's own rules are stricter than the LICENSE file, and that anyone planning to redistribute builds or assets should read both before doing so.

## Conclusion

Adopt Jasmine if you want a cross-platform Flutter comic reader whose Rust service layer you can study, and you accept the README's non-commercial, learning-only restriction. Do not adopt it if you need a commercially licensable app, a documented plugin API, or a project with a published roadmap. Verify first that the five platform directories (android, ios, macos, windows, linux) build with your installed Flutter and Rust toolchains, and read the README's restricted-content notice before you ship anything.

## FAQ

### How do I install Jasmine?

The README does not include installation instructions. It links to the GitHub releases page, where v1.7.21 is the most recent release, so downloading a build from there is the documented path. Building from source means working from the repository layout, which includes pubspec.yaml and .fvmrc, since no build guide is provided.

### Which platforms does Jasmine support?

The README describes Jasmine as a comic browser supporting Android, iOS, MacOS, Windows and Linux. The repository tree also contains an ohos/ directory, which the one-line description does not mention.

### Can I use Jasmine commercially?

The README states that the code may only be learned from and used, and that commercial use is prohibited. The repository also ships an MIT LICENSE file, which does not carry that restriction, so the two documents disagree. The README does not explain how to reconcile them.

### What technology does Jasmine use?

The README's technical architecture section lists Flutter for the UI and Rust for the service layer. Dart is the primary language in the repository, and the topics include flutter and rust.

### Does Jasmine sync my reading history between devices?

The README lists histories and comic favours as features but says nothing about syncing them across devices. There is no item in the feature checklist covering cross-device sync, so this cannot be confirmed from the documentation.

## Sources

- [ComicSparks/jasmine on GitHub](https://github.com/ComicSparks/jasmine)
- [Issues](https://github.com/ComicSparks/jasmine/issues)
- [License: MIT](https://github.com/ComicSparks/jasmine/blob/master/LICENSE)
- [README](https://github.com/ComicSparks/jasmine/blob/master/README.md)
- [Releases](https://github.com/ComicSparks/jasmine/releases)

---

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