Essentials
Everything you need to start shipping.
$99USD, one-time
- Updates upto 1 Year
- All templates included
- Unlimited usage of code & unlimited projects
- Access to Discord community
Pay once, access forever.
Production-ready Jetpack Compose boilerplate
Accelerate your journey from concept to profitable app
Streamline your Android development with our comprehensive Jetpack Compose Boilerplate. From UI to architecture, we've got you covered. Reduce boilerplate code and bring your app to market sooner.
- Pay once, access forever
- Unlimited projects
- Commercial use
OnboardingScreen.kt
@Composablefun OnboardingScreen(onFinished: () -> Unit) { val pagerState = rememberPagerState { pages.size } Column( modifier = Modifier.fillMaxSize().padding(24.dp), horizontalAlignment = Alignment.CenterHorizontally, ) { HorizontalPager(pagerState, Modifier.weight(1f)) { OnboardingPage(pages[it]) } PagerIndicator(pagerState) AppButton( text = "Continue", onClick = onFinished, ) }} @Preview@Composableprivate fun OnboardingPreview() = AppTheme { OnboardingScreen(onFinished = {})}@Preview OnboardingPreview
9:41
Skip
Ship your idea faster
Everything you need to launch is already set up for you.
Continue
Inside the project
Open it in Android Studio. The groundwork is done.
Feature modules, a themable design system and shared build logic are wired together from the first commit, so your first change is a feature, not configuration.
compose101 — Android Studio
feature/onboarding/build.gradle.kts
plugins { // All Android, Compose and lint setup lives in build-logic alias(libs.plugins.compose101.android.feature) alias(libs.plugins.compose101.android.compose)} android { namespace = "com.compose101.feature.onboarding"} dependencies { implementation(projects.core.designsystem) implementation(projects.core.network)}feature/onboarding/OnboardingScreen.kt
@Composablefun OnboardingScreen( pages: List<OnboardingPage>, onFinished: () -> Unit, modifier: Modifier = Modifier,) { val pagerState = rememberPagerState { pages.size } val scope = rememberCoroutineScope() Column(modifier.fillMaxSize()) { HorizontalPager(state = pagerState, modifier = Modifier.weight(1f)) { OnboardingPageContent(pages[it]) } AppButton( text = stringResource(R.string.onboarding_continue), onClick = { if (pagerState.isLastPage) onFinished() else scope.launch { pagerState.animateScrollToNextPage() } }, ) }}core/designsystem/Theme.kt
// Swap these tokens for your brand and every screen followsprivate val LightColors = lightColorScheme( primary = Color(0xFF1E9E71), secondary = Color(0xFF137F64), surface = Color(0xFFF7FAF8),) @Composablefun AppTheme( darkTheme: Boolean = isSystemInDarkTheme(), content: @Composable () -> Unit,) { MaterialTheme( colorScheme = if (darkTheme) DarkColors else LightColors, typography = AppTypography, shapes = AppShapes, content = content, )}Features
Explore key features
Don't waste time reinventing the wheel. With our Jetpack Compose boilerplate, you'll have a solid foundation to build upon, allowing you to focus on creating the features that make your app unique.
- Onboarding
Engaging Onboarding Flow
Onboarding is the initial interaction users have with your app. It's the first impression they form, and it's an opportunity to showcase the app's strengths while also gathering valuable insights.
- Authentication
Effortless authentication and user management
Quickly integrate authentication into your app with our streamlined solution. We manage the user interface, security, and user management, allowing you to focus on perfecting your app's core features.
- Notifications
Keep users engaged
Sending notifications at the right time can maximize the impact on user retention and activity. Maximize your app's potential by delivering timely, personalized notifications directly to your users' devices.
- Localization
Break all language barriers
Expand your reach and cater to users worldwide with our powerful language and per app localization feature.
- Design system
Make your App's UI seamless and consistent
Easily integrate your design system into the boilerplate by updating just a few lines of code.
- Monetization
Maximize Revenue
Monetize your app with preconfigured integration using RevenueCat.
- Architecture
Building Beyond Limits
Apps often struggle to scale due to inconsistent coding practices and lint rule issues. This boilerplate provides lint rules for Kotlin and Jetpack Compose and a robust architecture, helping you scale your app smoothly and efficiently.
Architecture
Structured to scale past the first release
A feature-based, multi-module architecture with custom Gradle convention plugins. The structure you would set up for a long-lived app, already in place.
- Feature-based modules
- Each feature lives in its own module with its own screens and state, so teams can work in parallel and builds stay incremental.
- Custom Gradle convention plugins
- Android, Compose and lint configuration is defined once in build-logic. A new module needs a couple of plugin lines, not a copied build file.
- Lint rules from day one
- Kotlin and Jetpack Compose lint rules ship with the project, keeping code consistent as the codebase and the team grow.
app
Thin shell: navigation graph, DI entry point, app theme.
:app
Wires feature modules together
feature
One module per product feature. Features never depend on each other.
:feature:onboarding
First-run flow
:feature:auth
Sign-in & user management
:feature:paywall
RevenueCat offerings
:feature:settings
Per-app language & preferences
core
Shared building blocks every feature can reach for.
:core:designsystem
Tokens, theme, components
:core:network
Retrofit + Apollo clients
:core:notifications
Channels & delivery
build-logic
Custom Gradle convention plugins keep every module's setup to a few lines.
:build-logic:convention
Shared Gradle config
Stack
Built on the tools Android teams already trust
No proprietary framework to learn. Compose101 is idiomatic Kotlin and Jetpack Compose, pre-wired with the libraries you would have picked anyway.
Language
Kotlin
UI toolkit
Jetpack Compose
Build logic
Gradle convention plugins
Architecture
Multi-module
REST
Retrofit
GraphQL
Apollo Kotlin
Monetization
RevenueCat
Code quality
Kotlin & Compose lint rules
i18n
Per-app localization
Engagement
Push notifications
How it works
From request to first build
- 01
Request access
Pick a plan and send us a request. Our team will reach out with your access.
Essentials or Ultimate
- 02
Open in Android Studio
Set your app's name and swap in your design tokens. The architecture is already in place.
core/designsystem/Theme.kt
- 03
Build your features
Skip the repetitive setup and spend your first day on what makes your app unique.
./gradlew assembleDebug
Pricing
Save hours of repetitive code, ship fast, get profitable!
Don't waste time reinventing the wheel, invest in what matters the most. One-time payment, no subscription.
Ultimate
For teams that want to stay current, forever.
$129USD, one-time
- Lifetime updates
- Access to Discord community
- On-demand Live Support via Discord
- Prioritized Feature Requests
Pay once, access forever.
| Feature | Essentials | Ultimate |
|---|---|---|
| Updates | Up to 1 year | Lifetime |
| All templates included | ||
| Unlimited usage & unlimited projects | ||
| Discord community | ||
| On-demand live support via Discord | ||
| Prioritized feature requests |
FAQ
Frequently asked questions
Have more questions? Don't hesitate to reach out to our support team.
What level of experience is needed to use this boilerplate?
While our boilerplate incorporates advanced features, it's designed to be accessible for developers at all levels. Beginners can use it as a learning tool to understand best practices, while experienced developers can leverage its advanced features to accelerate their workflow.
How much time can I save by using this boilerplate?
On average, developers report saving over 90 hours on initial project setup and configuration. This allows you to focus on building your app's unique features rather than spending time on boilerplate code and setup.
Does this boilerplate support both REST and GraphQL?
Absolutely! Our boilerplate comes pre-configured with Retrofit for REST API integration and Apollo for GraphQL support, giving you the flexibility to choose the best approach for your project.
Can I use this boilerplate for commercial projects?
Yes, you can use this boilerplate for both personal and commercial projects. Please refer to our license agreement for specific terms and conditions.
Is there any documentation?
Yes, we provide comprehensive documentation to help you get started!
What kind of architecture is implemented in this boilerplate?
This boilerplate comes with feature-based, multi-module architecture with custom gradle conventions plugins.
Skip the setup. Start building.
Save time and focus on innovation rather than setup. One payment, unlimited projects.