# Pikapika: A Cross-Platform Comic Client Built With Flutter and Go

> Pikapika is an MIT-licensed manga and comic browser for Android, iOS, Windows, macOS and Linux, written mainly in Dart with Go bridging the desktop and mobile platforms. Its README is candid about restricted content, distribution limits and a build toolchain that asks for specific Go and Flutter versions.

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

- Repository: https://github.com/ComicSparks/pikapika
- Stars: 8,341 · Forks: 487
- Language: Dart
- License: MIT
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/comicsparks-pikapika

## What Pikapika Solves, and for Whom

Pikapika is a comic and manga browser that runs on Windows, macOS, Linux, Android and iOS from one codebase. The README describes it as "a visually appealing, easy-to-use, ad-free manga client", and the feature list covers the usual reading loop: categories, search, random comic, rankings, comic details, chapters, image viewing and saving to the album, favourites and likes, comments and comment replies, and update notifications. There is also a games section with ad-free downloads.

The audience is narrow and the README says so plainly. The app "contains restricted content (such as explicit, gory, violent, drug-related scenes)", and users under 18 are told to use it under parental supervision. This is not a general-purpose reading app you would hand to a school. It is for adults who already know what they are looking for and want a client that handles search, downloads and cross-device transfer without advertising.

The download and export features are the part that distinguishes it from a plain reader. Completed downloads can be exported to a zip file and imported on another device, and after extracting the exported zip the HTML files inside can be used for reading directly. That is a real offline path, not just a cache.

## How the Flutter and Go Layers Fit Together

The README states that the application uses golang and dart (flutter) as its main languages, and that different frameworks bridge to desktop and mobile: go-flutter for Windows, macOS and Linux, and gomobile for Android and iOS. So the same Go code is packaged two different ways depending on the target, with Flutter providing the interface on top.

That choice has consequences. go-flutter and gomobile are separate integration paths, which means a bug in the platform bridge can appear on desktop but not on mobile, or the other way round. The README does not describe a single shared abstraction that hides this split, and it does not document how the two paths are kept in sync.

The data storage layout is documented per platform, and it differs enough to matter when you back up or migrate:

```text
ios/android: the program's own data directory (deleting it clears the data)
windows: the data folder in the same directory as the program
macos: ~/Library/Application Support/pikapika
linux: ~/.pikapika
```

On Windows the data sits next to the executable, which makes a portable install easy but also means moving the binary without the folder loses your library. On iOS and Android the data lives in the app's own directory, so uninstalling clears it. There is a cache with auto clean, according to the feature list.

The README also describes a three-part network arrangement: "VPN -> Proxy -> Traffic Diversion". If all three are configured at once, the phone reaches the proxy through the VPN, and the proxy requests the traffic diversion server. The README does not explain what the diversion server does beyond that sentence, so treat the description as an outline rather than a specification.

## Building Pikapika From Source

The README does not give a step-by-step install command. It points to the Releases page on GitHub for the installation package and says the source repository is at https://github.com/ComicSparks/pikapika. What it does give is the build environment, and the versions are pinned tightly enough that you should match them.

The build environment section lists golang at 1.17/1.18 and flutter at 2.10.3/3.7.3 for both desktop and mobile. The repository root contains pubspec.yaml and pubspec.lock, plus platform directories for android, ios, linux, macos and windows, and a .fvmrc file that suggests Flutter version management is part of the workflow. There is also a ci directory and a scripts directory.

Because no install command is documented, the honest starting point is to fetch the repository and check the pinned versions before running anything:

```bash
git clone https://github.com/ComicSparks/pikapika.git
cd pikapika
cat .fvmrc
cat pubspec.yaml
```

The first two commands fetch the source and enter it. The third shows which Flutter version the project expects through fvm, and the fourth shows the Dart dependencies. If your local Flutter is newer than 3.7.3, expect resolution differences, because the README names 2.10.3/3.7.3 and the lockfile was written against that range.

For a first real use, the README's own example is the download export path: download a comic to completion, export it to a zip, move that zip to another device, import it there, and optionally extract it and open the HTML files inside for reading. That flow is described in the README and is the feature most likely to matter if you read across a phone and a desktop. The README does not document what happens if an export is interrupted or if the archive password is lost, so verify that on a throwaway download before relying on it.

## Where Pikapika Breaks Down or Is the Wrong Tool

The licence situation is the clearest limitation, and it is a contradiction worth reading carefully. The repository is MIT licensed. The README's usage rules say the code "can be used for personal use without permission, but no releases are allowed, and it cannot be used for commercial purposes by individuals or companies, nor can it be put on any store". Those two statements pull in different directions, and the README does not reconcile them. If you are evaluating Pikapika as a base for a product, or you need to publish a build to a store, the README's rules are the ones the author states, and they rule that out. This is not legal advice; it is a reading of what the project itself says.

The distribution rules are equally restrictive. The README asks that links or information about the software not be posted in any two-dimensional chat or development community, that installation packages not be sent to any community or group chat, and that forks retain a link to the main repository. For a team used to sharing internal builds over chat, that is a direct conflict with normal practice.

The chat room feature is unchecked in the feature list, so it is not available. Comments cannot be deleted once posted, and the README warns about this explicitly: "comments in the community cannot be deleted, please use with caution". If your workflow depends on retracting a comment, this client will not let you.

The build toolchain is a second failure mode. Go 1.17/1.18 and Flutter 2.10.3/3.7.3 are old relative to current releases, and the README does not describe an upgrade path or a supported newer combination. Anyone building from source should expect to manage an older toolchain rather than use whatever is installed.

## How Pikapika Differs From a Plain Web Reader

The obvious alternative is reading the same content in a browser, or using a generic comic reader that consumes local files. The difference is in what Pikapika adds around the reading surface: account login, registration, personal information and auto check-in; search by category, tag, creator or translation group; favourites and likes; comments and replies; update notifications; and a download manager with import, export, wireless sharing and transfer between mobile and PC.

A local-file reader gives you none of that. It will open a CBZ or a folder of images, but it will not tell you when a series updates, will not search a catalogue by translation group, and will not move a library between a phone and a desktop through an encrypted archive. Pikapika's export produces a zip that can be imported elsewhere and whose HTML files can be read directly, which is a portable format rather than a proprietary cache.

The trade-off runs the other way too. A local reader has no account, no server dependency and no content restrictions, and it does not care which store it came from. Pikapika's features only work while the upstream service is reachable, and the README's distribution rules make it harder to share. If your priority is a self-contained library of files you already own, the generic reader is the simpler tool. If your priority is discovering and tracking comics across devices, Pikapika's feature list is the reason to use it.

## Maintenance, Releases and Upgrade Cost

The last push to the repository was on 2026-07-20, and the most recent release is v1.8.21 on the same date. Before that, v1.8.20 landed on 2026-06-16 and v1.8.19 on 2026-02-28. The spacing between those three releases is uneven: roughly two months, then roughly four months. That is a small sample, but it suggests release cadence is not fixed, so pinning to a specific tag is safer than tracking master.

The repository is not archived, and the recent tags put the last push within a few months of a current release. That is not the same as a regular schedule, and the README does not publish one, so anyone planning an upgrade should watch the Releases page rather than assume a cadence.

Upgrade cost is dominated by the toolchain. Because the README names Go 1.17/1.18 and Flutter 2.10.3/3.7.3, each new release may pull you back into an older SDK setup if you have moved forward. The pubspec.lock file pins Dart dependencies, which helps reproducibility but also means a dependency bump requires a deliberate change. On the licence side, the MIT file and the README's usage rules coexist without explanation, so if you intend to distribute anything at all, resolve that question before you invest in a build pipeline. That is a reading of the project's own text, not legal advice.

## Conclusion

Adopt Pikapika if you want a cross-platform comic reader with download import and export, and you are comfortable building Flutter and Go from source at the versions the README names. Do not adopt it if you need a permissively relicensable codebase for commercial or store distribution, since the README forbids releases, commercial use and store publication even though the repository carries an MIT licence. Before building, verify that your Go and Flutter versions match 1.17/1.18 and 2.10.3/3.7.3, and check where your platform stores data, because deleting that directory clears it.

## FAQ

### What is Pikapika?

Pikapika is a comic and manga browser for Windows, macOS, Linux, Android and iOS, written mainly in Dart with Flutter and bridged to platforms through go-flutter and gomobile. The README describes it as an ad-free manga client with search, downloads, favourites, comments and a games section.

### Is Pikapika legit?

The repository is public, MIT licensed, and hosted at github.com/ComicSparks/pikapika, with releases up to v1.8.21 on 2026-07-20. The README states that the author only shares programming technology and does not distribute software, and that whoever spreads the content is responsible for legal issues, so legality depends on your jurisdiction and how you obtained it.

### Where does Pikapika store its data?

The README lists the location per platform: the program's own data directory on iOS and Android, a data folder beside the program on Windows, ~/Library/Application Support/pikapika on macOS, and ~/.pikapika on Linux. On iOS and Android, deleting that directory clears the data.

### Which Go and Flutter versions does Pikapika require to build?

The README's build environment section lists golang 1.17/1.18 and flutter 2.10.3/3.7.3 for both desktop and mobile. The README does not document a supported newer combination, so match those versions if you build from source.

### Can Pikapika be published to an app store?

The README's usage rules say the code cannot be used for commercial purposes by individuals or companies and cannot be put on any store, and that no releases are allowed without permission. That sits alongside an MIT licence in the repository, and the README does not reconcile the two.

## Sources

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

---

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