Thunder: a cross platform Lemmy client written in Flutter
An open-source cross-platform Lemmy & PieFed client for iOS and Android
At a glance
- What is it?
- Thunder is an open source Flutter application for Lemmy and PieFed on iOS and Android, with a community browser, per instance information, search, post and comment handling, Material You theming and community translations, distributed through the app stores, an alternative store, TestFlight and GitHub releases. It suits a Lemmy user on a phone, and it is in active alpha development with breaking changes between versions.
- Who is it for?
- Adopt Thunder if you read Lemmy on a phone and want an app that is developed in the open, with a customer visible translation process and builds published outside the app stores as well as inside them. Do not adopt it as a stable daily driver without reading the release notes, because the project states that it is in active alpha development and that significant breaking changes may occur between versions.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository last received commits 36 days ago.
- What is it written in?
- Mainly Dart, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on October 21, 2026, and from our analysis. They are not legal advice.
Editorial analysis
What Thunder is
Thunder is an open source, cross-platform client for Lemmy and PieFed, built with Flutter and written in Dart, and it is presented in the readme as a Lemmy client with the PieFed support named in the project description and the topic list.
The framing in the repository is worth reading because it tells you what kind of project this is. The readme says the repository is currently the author's personal side project, built to make something cool while learning Dart and Flutter, and that contributions are always welcomed and indeed strongly encouraged, because the author can only work on it in spare time and community contributions are valuable.
That sentence explains a lot about the project you see. It is a single maintainer's learning project that became a real application with a store presence, and the request for help is genuine rather than a formality.
The scope is a full Lemmy client rather than a viewer. You browse the general feeds, all, local and subscribed, you view and subscribe to communities, you vote, save, share, post and comment, you read notifications, you manage multiple accounts, and you configure the way it looks down to the font scaling and the compact or card layout of a post.
The licence is AGPL-3.0, the site is thunderapp.dev, and the last push to the repository was on 2026-09-17.
Four ways to install it on each platform
The releases section is longer than a typical app readme, and the reason is that the app is distributed through more than one channel on both platforms.
On Android, the general releases come officially through the Google Play Store, or through IzzyOnDroid, or through GitHub releases. Pre-releases are in the GitHub releases section under the corresponding version, and Obtainium is offered as another way to get them.
On iOS, the general releases come through the App Store or through GitHub releases, the pre-releases are on TestFlight, and the alternative is to download the IPA file from the releases section and install it through AltStore.
That is an unusually wide spread, and each channel exists for a reason. The store is the path for people who want an update button. The GitHub releases are the path for people who want the newest build, and the TestFlight and AltStore routes exist because Apple does not allow a third party to distribute a signed build any other way, so a developer who wants people on a pre-release has to go through TestFlight or through the sideloading tooling.
IzzyOnDroid and Obtainium cover the other common Android sideloading patterns, and the in-app update notification for new GitHub releases, listed among the features, is what makes the GitHub channel usable once the app is installed.
So the practical summary is that the app is reachable however you like to get software, which suits a project whose releases are frequent and whose audience is used to installing from wherever.
The feature set, and what active alpha means in practice
The features section is grouped, and the readme is careful to call it a non-exhaustive list of what the app currently supports.
Communities and users covers the general feeds of all, local and subscribed, viewing, subscribing, favouriting and blocking communities, and reading a user's posts and comments with the ability to block them. Instances covers viewing instance information and version, and blocking unwanted instances where the instance supports it.
Search covers trending communities on the current instance, searching for communities, users, posts and comments, and advanced filters for sort, feed, community and creator.
Posts and comments covers creating and editing, voting, saving and sharing, customisable swipe actions, and filtering posts by keyword. Accounts covers the profile view with posts, comments and saved items, the notifications including replies, mentions and private messages, synced account settings for showing read posts, comment scores and bot accounts, and support for multiple accounts and for guest accounts on different instances.
Customization covers Material You theming on applicable devices, light, dark, OLED and system modes, preset accent colours, custom font scaling of the content, and a preview of how a post or comment will look in the compact or card layout.
And the readme states the caveat plainly. Thunder is currently undergoing active alpha development, it is possible that not all features have been fully implemented at this stage, and significant breaking changes may occur between versions. The project is not hiding that, and for a self-hosted community client that is a reasonable thing to accept.
The develop branch, and the submodules
The contributing section has four numbered steps, and two of them are about git mechanics rather than about code.
The first is to fork the repository and clone it with submodules, and the second is to base the feature or fix off the develop branch. The reason given is to allow for pre-release versions without affecting the main general releases. The third is to apply the changes based on an existing issue, or to create one, and the fourth is to open a pull request.
So the repository runs a two branch model where develop carries the work in progress and the default branch carries the general releases. That is why the default branch in the repository is develop, and it is worth knowing before you clone, because the difference between the two branches is not a small difference in a client that says breaking changes may occur between versions.
The submodules are the other piece of git mechanics, and the readme is explicit that the clone needs the recursive form.
git clone --recurse-submodules -j8 [email protected]:thunder-app/thunder.gitThe reason is in the build section, where the repository pins the Flutter SDK as a submodule and the commands are run from inside the flutter directory. A clone without the submodules gives you a repository whose build instructions do not work, and the fix is a single command, initialise the pinned SDK with the submodule update if the repository is already cloned.
That choice, pinning the SDK as a submodule rather than requiring an installed Flutter, is what makes the build reproducible. Everyone building the app uses the same Flutter version, which for a project with this many contributors and this many platform specific quirks is the difference between a build that works and a build that depends on which Flutter you happened to have.
Building from source and the localisation workflow
The build steps are listed and they are short, because the heavy lifting is in the pinned SDK.
After the clone and the submodule initialisation, the dependencies are fetched with the pub command run from the flutter directory, and the localisation files are generated with the l10n generation command from the same place. The readme also notes that the app is developed with Flutter and built to support both iOS and Android, and that there may be unofficial support on other platforms but it is not guaranteed at this time, naming Linux, Windows and macOS.
That is an honest limitation. Flutter can target desktop, and the readme says there is some support for it, but that it is not guaranteed. So if you are on a desktop, the readme is telling you that you are on your own.
Localisation is handled with Weblate, and the readme invites anyone to create an account and contribute. The project is also listed in the road map, where the current focus is to continue expanding the general functionality and stability, with the items named being continued improvements to localisation and language support through Weblate, improvements to moderation and admin capabilities, improvements to embedded content such as video and images, and improvements to push notification functionality.
The repository layout supports all of this. There is a l10n file for the localisation configuration, a build file, an analysis options file for the Dart analyser, a spec directory for the Dart style guide, a fastlane directory for the store release automation, a docker directory, and a scripts directory, alongside the platform directories for Android, iOS and the web target.
The limits, and the honest summary
Three things to weigh before you adopt it.
The first is the alpha status, which the project states plainly and which has a practical consequence. The releases are numbered with a patch suffix, 0.9.0-5 being the most recent, which is the pattern of a project that cuts many small builds. That is good for a client that updates from GitHub, and awkward for anyone who wants a version that does not change behaviour under them.
The second is the single maintainer. The readme says plainly that this is a personal side project, that the author can only work on it during spare time, and that community contributions are strongly encouraged. The project is AGPL licensed and it has a community translation process, a contributor guide and a code of conduct, so the invitation is real, but the bus factor of one is a fact and not a criticism.
The third is the scope. This is a client for Lemmy and PieFed, so if your reading is spread across several fediverse servers with different features, the coverage is not uniform, and the per instance features are conditional on what the instance supports, which the readme says for instance blocking.
What Thunder does have is breadth within its scope. The feature list covers the whole loop of using a Lemmy instance, from browsing and searching to posting, commenting, voting, notifications, multiple accounts and a detailed customisation section, and the customisation is the part that distinguishes a native client from a web interface, with per instance theming, accent colours, font scaling, a compact and a card layout, and configurable swipe actions.
So the honest summary is that this is a capable, actively developed, community translated client for two servers, distributed through every channel a mobile app can use, maintained by one person in their spare time, and at a stage where you should expect the interface to move.
Editorial conclusion
Adopt Thunder if you read Lemmy on a phone and want an app that is developed in the open, with a customer visible translation process and builds published outside the app stores as well as inside them. Do not adopt it as a stable daily driver without reading the release notes, because the project states that it is in active alpha development and that significant breaking changes may occur between versions. Before you build from source, note that the repository pins the Flutter SDK as a submodule, and use the develop branch if you want the pre-release behaviour rather than the last stable release.
Frequently asked questions
What is Thunder?
It is an open source, cross-platform client for Lemmy and PieFed on iOS and Android, written in Dart and built with Flutter. It provides community browsing, instance information, search, posting and commenting, notifications, multiple accounts, and detailed theming including Material You, and it is licensed AGPL-3.0.
Where can I get Thunder?
On Android through the Google Play Store, IzzyOnDroid or GitHub releases, with pre-releases on GitHub or through Obtainium. On iOS through the App Store or GitHub releases, with pre-releases through TestFlight or by installing the IPA from the releases section with AltStore.
How do I build Thunder from source?
Clone the repository with its submodules, because the Flutter SDK is pinned as a submodule, initialise it with the submodule update if the repository is already cloned, then fetch the dependencies with the pub command and generate the localisation files with the l10n command, both run from the flutter directory.
Is Thunder stable?
The README states that Thunder is currently undergoing active alpha development, that not all features may be fully implemented at this stage, and that significant breaking changes may occur between versions. The project also asks contributors to base their work on the develop branch so that pre-release versions do not affect the general releases.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/thunder-app-thunder)Was this useful?