Kickstarter's Android App Is Open Source: What the Repository Actually Gives You

What kickstarter/android-oss actually publishes

Kickstarter's native Android app is developed on GitHub, and this repository is that codebase. The README frames the intent plainly: the project is "an educational resource" where the team shares "our wins, mistakes, and methodology of Android development as we work in the open." The primary language is Kotlin, the licence is Apache-2.0, and the topics list includes functional-reactive-programming and RxJava, which matches the README's pointer to the view models directory.

The audience is narrower than the topic list suggests. This is not a library other apps import, and it is not a client for the Kickstarter API that outsiders can authenticate against. It is a full application: an app/ module, a lib/ module, Gradle build files, Fastlane configuration, CircleCI configuration, and a Makefile that wires the whole thing together. You read it, you build it with mock data, and you learn from it. The README says the best way to report a bug is a GitHub issue, and asks for operating system, device, version number and reproduction steps.

The build is driven by a Makefile and a private secrets repository

The mechanism to understand before cloning is the secrets step. The Makefile's bootstrap target depends on dependencies and secrets, and the secrets target tries to clone [email protected]:kickstarter/native-secrets.git into vendor/native-secrets. If that clone fails, the Makefile prints that you do not have access and falls back to placeholder values.

That fallback is the whole story of what you can run. Each copy command has a `||` branch pointing at a checked-in example: Secrets.java falls back to Secrets.java.example, fabric.properties to config/fabric.properties.example, firebase.properties to config/firebase.properties.example, and the WebView Java interfaces to files under config/. The Makefile also copies a font, slack.properties and a Ruby secrets file, with `|| true` on some of those lines so a missing file does not stop the build.

So the repository is designed to compile and run for someone with no credentials at all. What it is not designed to do is reach Kickstarter's production services, because the values that would make that possible live in a private repository. The README states this directly in the Getting Started heading: follow the instructions "to build and run the project with mock data."

Building it locally: bootstrap, import, run

The README gives six steps. Clone the repository, install JDK 8 (the README says the project is currently on JDK 8 and links to Oracle's JDK 8 downloads), install Android Studio, run the bootstrap target from the repository root, import the project into Android Studio, then run it.

The bootstrap step is a single make invocation. The README says to keep an eye on the output because manual steps may be required, which is consistent with the Makefile's fallback messages.

cd android-oss
make bootstrap

After that, open Android Studio, choose Open an existing Android Studio project, and select the project directory. Gradle builds it. The README notes that the app is then run through Run > Run 'app', and that you will be prompted to build or launch an emulator once the build finishes.

The Makefile also defines a bootstrap-circle target that runs ./script/bootstrap_configs instead of ./script/bootstrap, which is what CI uses. If you are trying to reproduce a CI failure rather than set up a workstation, that is the target to look at, though the README does not document it.

The RxJava view models are the part worth reading

The README's opening paragraph points at one directory in particular: app/src/main/java/com/kickstarter/viewmodels. It describes these as "logic-filled view models" and pairs them with the project's use of RxJava. That is the architectural bet this codebase makes, and it is the reason someone would read it rather than any other Android app source.

The pattern puts presentation logic in a view model that exposes observable streams, leaving the Activity or Fragment to subscribe and render. In a repository this size, that means the interesting decisions are not in the UI layer but in how those streams are composed, transformed and combined. The topics list confirms the framing with functional-programming and functional-reactive-programming alongside kotlin-android.

This is also where the trade-off sits. A reader who does not already work in RxJava will find the view models hard to follow, and the README offers no tutorial for the pattern, only a pointer. The team's own documentation lives in a separate repository, kickstarter/native-docs, which the README links under a Documentation heading. If you want the reasoning behind the code rather than the code itself, that is where to look, and this repository does not reproduce it.

Where this repository stops being useful

The clearest limitation is the one the Makefile encodes: without access to kickstarter/native-secrets, the app runs on placeholders. That rules out using this repository as a starting point for a third-party Kickstarter client, because the configuration that would point it at real services is not public. Anyone hoping to fork it and ship an alternative client is blocked at the first make bootstrap.

The second limitation is version drift. The README specifies JDK 8, which is old for Android work, and the Getting Started section has not been rewritten around a newer toolchain. A modern Android Studio installation may or may not handle this project without adjustment; the README does not discuss toolchain compatibility beyond naming JDK 8.

The third is scope. The README describes the team's primary focus as "continuing to improve the app for our users in line with our roadmap," and asks contributors to open issues rather than submit features. There is no documented path for outside pull requests that change product behaviour, and the code of conduct section says the project reserves the right to delete or ban behaviour that violates its stated foundation of respect. Treat it as a published codebase with an issue tracker, not a community project with a contribution pipeline.

How it compares with the iOS repository

Kickstarter open sourced the iOS app as well, at kickstarter/ios-oss, written in Swift. The README links to it directly and points at a Kickstarter engineering blog post about the journey to open source both apps.

The difference in approach is language and platform, and that difference matters more than it first appears. A team evaluating reactive architecture on Android will find the RxJava view models here; the Swift counterpart uses whatever reactive or non-reactive patterns the iOS team chose, and the two codebases are not translations of each other. If your interest is in how one product expresses the same domain across two platforms, reading both is the point. If your interest is Android architecture specifically, the iOS repository tells you nothing you can apply.

A second alternative is not a competitor at all: the native-docs repository. It is documentation rather than code, and for someone deciding whether to adopt a pattern, prose about the reasoning may be more useful than the implementation. The README treats them as complementary, and so should you.

Licence, maintenance and what a fork costs you

The licence is Apache-2.0, with the copyright line reading "Copyright 2020 Kickstarter, PBC" and a NOTICE file at the repository root. Apache-2.0 permits commercial use and modification and requires that you preserve the licence and notice, and it includes a patent grant. This is not legal advice; if you plan to redistribute a modified app or ship code derived from these view models, have your own counsel read the NOTICE and LICENSE-APACHE files, since the NOTICE file can carry attribution obligations that the bare licence text does not show.

Maintenance is real but should be judged from the repository's own signals. The last push was on 2026-09-03, and the most recent release is v3.42.0 from 2026-08-12, with v3.41.1 and v3.41.0 before it in July and August. The repository is not archived. That pattern suggests ongoing work on the app itself, though the README's framing is that this is an educational publication of a product codebase, not a maintained library with a support commitment.

Upgrade cost is the practical question for a fork. If you copy the view model pattern into your own app, you inherit RxJava as a dependency and the version of it pinned in this project's Gradle files, and you take on keeping that current yourself. The repository will not do it for you, because it is not a dependency you can bump.

Editorial conclusion

Adopt this repository if you want to read how a production Kotlin and RxJava Android app is structured, or if you are building a similar client and want a worked example of the view model pattern. Do not adopt it if you need a Kickstarter API client, a drop-in library, or a build that talks to live Kickstarter data: the Makefile's secrets step falls back to placeholder values when the private native-secrets repository is unavailable. Before cloning, check that your machine has JDK 8, since the README states the project is on that version, and read the app/src/main/java/com/kickstarter/viewmodels directory to confirm the RxJava style matches what your team writes.

Frequently asked questions

Official sources

1. kickstarter/android-oss on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases