Your stack. Your starting point.

Android Project Generator

Choose your architecture, pick your tools, and get a clean starter project.
Everything is generated in your browser. Nothing is uploaded.

Read generated source · Compare presets · First-run walkthrough

FREE · NO SIGNUP · INSTANT ZIP
Start with a preset

01The basics

Give your next project a name and a home.

Letters and numbers, starting with a letter.
For example, com.example.shoppingapp

02Architecture & state

Choose the boundaries that fit your application.

Recommended for most apps. Keep screen state in a ViewModel and persistence behind repositories.

03Networking & storage

Connect your services. Keep your data layer organized.

Networking options

04Make it your own

Useful foundations without unnecessary dependencies.

Additional features
Starter screens
Inspect the code before choosing your stack

What changes with another preset?

Compare the files your current form will download with another preset. Both sides use your project name, package and description. The preset uses its own remaining settings; this comparison does not change your form.

3 added · 0 removed · 4 changed · 21 unchanged files, relative to your current configuration.

Configuration differences (2)
architecture
Current: MVVM
Clean + Hilt + Room: Clean Architecture
database
Current: None
Clean + Hilt + Room: Room

changed · README.md

Current configuration

# MyAndroidApp

A thoughtfully structured Android application.

## Configuration
- Platform: android
- Architecture: MVVM
- Package / organization: com.example.myandroidapp
- State / async: StateFlow
- Networking: Retrofit
- Navigation: Compose Navigation
- Dependency injection: Hilt
- Storage: None
- Features: Material 3, Dark theme, UI State
- Screens: Home, Settings

## Getting started
1. Install JDK 17, Android Studio, Android SDK 35, and Gradle 8.11.1. Set ANDROID_HOME or create local.properties with sdk.dir.
2. This source ZIP does not embed the Gradle wrapper JAR. Run `gradle wrapper --gradle-version 8.11.1` once to generate the trusted wrapper from your local Gradle installation.
3. Open the folder in Android Studio and sync Gradle.
4. Run `./gradlew assembleDebug`, then run the app on an emulator.
5. Run `./gradlew test`. Configure the API_URL buildConfigField in app/build.gradle.kts.

## Architecture and extension points
The application composition root owns concrete repositories. Presentation accepts domain abstractions. The in-memory counter repository is a working demo; replace it with a network or storage implementation through the composition root. Keep UI state separate from persistence and request handling.

Add features alongside existing feature folders, then register routes. Services are initialized in the dependency container; no requests are sent on startup. API endpoints are placeholders. Logging should stay in debug builds and must not contain credentials. Authentication screens are mock entry points, not a real sign-in system. Connect the AuthRepository and add validation before collecting user credentials.

## Integration notes
- Review dependency versions before adopting this starter. The website centralizes them in src/config/versions.ts.
- Package plugins may require extra platform permissions. Consult each selected package before release.
- Add real API tests, accessibility tests, and release signing in your project. No release credentials are generated.
- Starter code is not a security audit or a guarantee of production readiness.

## Dependencies
- androidx.core:core-ktx: 1.16.0
- androidx.lifecycle:lifecycle-viewmodel-ktx: 2.9.0
- androidx.lifecycle:lifecycle-runtime-ktx: 2.9.0
- org.jetbrains.kotlinx:kotlinx-coroutines-android: 1.10.2
- androidx.compose:compose-bom: 2025.04.01
- androidx.activity:activity-compose: 1.10.1
- androidx.compose.ui:ui: 
- androidx.compose.material3:material3: 
- androidx.navigation:navigation-compose: 2.9.0
- androidx.lifecycle:lifecycle-viewmodel-compose: 2.9.0
- androidx.lifecycle:lifecycle-runtime-compose: 2.9.0
- com.squareup.retrofit2:retrofit: 2.11.0
- com.squareup.retrofit2:converter-gson: 2.11.0
- com.squareup.okhttp3:okhttp: 4.12.0
- com.google.dagger:hilt-android: 2.56.2

## Folder structure
```text
├── app
│   ├── src
│   │   ├── main
│   │   │   ├── java
│   │   │   │   └── com
│   │   │   │       └── example
│   │   │   │           └── myandroidapp
│   │   │   │               ├── data
│   │   │   │               │   ├── remote
│   │   │   │               │   │   └── ApiClient.kt
│   │   │   │               │   └── repository
│   │   │   │               │       └── MemoryCounterRepository.kt
│   │   │   │               ├── di
│   │   │   │               │   ├── AppContainer.kt
│   │   │   │               │   └── AppModule.kt
│   │   │   │               ├── domain
│   │   │   │               │   └── repository
│   │   │   │               │       └── CounterRepository.kt
│   │   │   │               ├── navigation
│   │   │   │               │   └── AppNavigation.kt
│   │   │   │               ├── presentation
│   │   │   │               │   ├── home
│   │   │   │               │   │   ├── HomeScreen.kt
│   │   │   │               │   │   ├── HomeUiState.kt
│   │   │   │               │   │   └── HomeViewModel.kt
│   │   │   │               │   └── settings
│   │   │   │               │       └── SettingsScreen.kt
│   │   │   │               ├── theme
│   │   │   │               │   └── AppTheme.kt
│   │   │   │               ├── App.kt
│   │   │   │               └── MainActivity.kt
│   │   │   ├── res
│   │   │   │   └── values
│   │   │   │       ├── strings.xml
│   │   │   │       └── themes.xml
│   │   │   └── AndroidManifest.xml
│   │   └── test
│   │       └── java
│   │           └── com
│   │               └── example
│   │                   └── myandroidapp
│   │                       └── CounterRepositoryTest.kt
│   ├── build.gradle.kts
│   └── proguard-rules.pro
├── gradle
│   └── wrapper
│       └── gradle-wrapper.properties
├── .gitignore
├── build.gradle.kts
├── gradle.properties
└── settings.gradle.kts
```

Generated entirely in your browser. No configuration or source was uploaded.

Clean + Hilt + Room

# MyAndroidApp

A thoughtfully structured Android application.

## Configuration
- Platform: android
- Architecture: Clean Architecture
- Package / organization: com.example.myandroidapp
- State / async: StateFlow
- Networking: Retrofit
- Navigation: Compose Navigation
- Dependency injection: Hilt
- Storage: Room
- Features: Material 3, Dark theme, UI State
- Screens: Home, Settings

## Getting started
1. Install JDK 17, Android Studio, Android SDK 35, and Gradle 8.11.1. Set ANDROID_HOME or create local.properties with sdk.dir.
2. This source ZIP does not embed the Gradle wrapper JAR. Run `gradle wrapper --gradle-version 8.11.1` once to generate the trusted wrapper from your local Gradle installation.
3. Open the folder in Android Studio and sync Gradle.
4. Run `./gradlew assembleDebug`, then run the app on an emulator.
5. Run `./gradlew test`. Configure the API_URL buildConfigField in app/build.gradle.kts.

## Architecture and extension points
The application composition root owns concrete repositories. Presentation accepts domain abstractions. The in-memory counter repository is a working demo; replace it with a network or storage implementation through the composition root. Put business rules in domain/usecases, implementation details in data, and UI in presentation. Domain must not import UI or data.

Add features alongside existing feature folders, then register routes. Services are initialized in the dependency container; no requests are sent on startup. API endpoints are placeholders. Logging should stay in debug builds and must not contain credentials. Authentication screens are mock entry points, not a real sign-in system. Connect the AuthRepository and add validation before collecting user credentials.

## Integration notes
- Review dependency versions before adopting this starter. The website centralizes them in src/config/versions.ts.
- Package plugins may require extra platform permissions. Consult each selected package before release.
- Add real API tests, accessibility tests, and release signing in your project. No release credentials are generated.
- Starter code is not a security audit or a guarantee of production readiness.

## Dependencies
- androidx.core:core-ktx: 1.16.0
- androidx.lifecycle:lifecycle-viewmodel-ktx: 2.9.0
- androidx.lifecycle:lifecycle-runtime-ktx: 2.9.0
- org.jetbrains.kotlinx:kotlinx-coroutines-android: 1.10.2
- androidx.compose:compose-bom: 2025.04.01
- androidx.activity:activity-compose: 1.10.1
- androidx.compose.ui:ui: 
- androidx.compose.material3:material3: 
- androidx.navigation:navigation-compose: 2.9.0
- androidx.lifecycle:lifecycle-viewmodel-compose: 2.9.0
- androidx.lifecycle:lifecycle-runtime-compose: 2.9.0
- com.squareup.retrofit2:retrofit: 2.11.0
- com.squareup.retrofit2:converter-gson: 2.11.0
- com.squareup.okhttp3:okhttp: 4.12.0
- com.google.dagger:hilt-android: 2.56.2
- androidx.room:room-runtime: 2.7.1
- androidx.room:room-ktx: 2.7.1

## Folder structure
```text
├── app
│   ├── src
│   │   ├── main
│   │   │   ├── java
│   │   │   │   └── com
│   │   │   │       └── example
│   │   │   │           └── myandroidapp
│   │   │   │               ├── data
│   │   │   │               │   ├── local
│   │   │   │               │   │   ├── AppDatabase.kt
│   │   │   │               │   │   └── LocalStore.kt
│   │   │   │               │   ├── remote
│   │   │   │               │   │   └── ApiClient.kt
│   │   │   │               │   └── repository
│   │   │   │               │       └── MemoryCounterRepository.kt
│   │   │   │               ├── di
│   │   │   │               │   ├── AppContainer.kt
│   │   │   │               │   └── AppModule.kt
│   │   │   │               ├── domain
│   │   │   │               │   ├── repository
│   │   │   │               │   │   └── CounterRepository.kt
│   │   │   │               │   └── usecase
│   │   │   │               │       └── IncrementCounter.kt
│   │   │   │               ├── navigation
│   │   │   │               │   └── AppNavigation.kt
│   │   │   │               ├── presentation
│   │   │   │               │   ├── home
│   │   │   │               │   │   ├── HomeScreen.kt
│   │   │   │               │   │   ├── HomeUiState.kt
│   │   │   │               │   │   └── HomeViewModel.kt
│   │   │   │               │   └── settings
│   │   │   │               │       └── SettingsScreen.kt
│   │   │   │               ├── theme
│   │   │   │               │   └── AppTheme.kt
│   │   │   │               ├── App.kt
│   │   │   │               └── MainActivity.kt
│   │   │   ├── res
│   │   │   │   └── values
│   │   │   │       ├── strings.xml
│   │   │   │       └── themes.xml
│   │   │   └── AndroidManifest.xml
│   │   └── test
│   │       └── java
│   │           └── com
│   │               └── example
│   │                   └── myandroidapp
│   │                       └── CounterRepositoryTest.kt
│   ├── build.gradle.kts
│   └── proguard-rules.pro
├── gradle
│   └── wrapper
│       └── gradle-wrapper.properties
├── .gitignore
├── build.gradle.kts
├── gradle.properties
└── settings.gradle.kts
```

Generated entirely in your browser. No configuration or source was uploaded.

These are complete file contents from the same templates as the ZIP, not a line-by-line patch or a migration tool. Compare dependency manifests, state owners and setup instructions together. A smaller file count is not a quality score, and this preview does not compile either project.

Review the output before your first commit

Compare MVVM + Compose with Clean + Hilt + Room above. Look at the added domain and database files, then inspect app/build.gradle.kts for the persistence dependencies. Adding Room scaffolding does not connect the demo counter to persistent storage: trace the repository binding before assuming values survive a restart. The preview shows what the template emits, not proof that a configuration was compiled.

Your Android starter includes an application entry point, navigation, working state examples, selected service integrations, and an architecture-aware README. The composition root connects concrete services to repository contracts, so you can add your own backend without coupling it to the screens.

Choose the right level of structure

MVVM suits most state-driven screens. MVI makes actions explicit; MVP separates view and presenter contracts. Clean Architecture adds domain use cases for rules that should stay independent of Android and network libraries.

After you download

Read the included README, install the listed SDK tooling, and run the starter tests. API URLs and authentication repositories are placeholders for your own services. Code-generation integrations have explicit local build commands.

Read the architecture guide →

From download to first run

This walkthrough uses the MVVM + Compose preset. Select that preset to reproduce it. Other configurations can require additional steps; the README in your download is specific to your choices.

1. Check the configuration and prerequisites

Use project name MyAndroidApp, package com.example.myandroidapp, MVVM, Jetpack Compose, Hilt, Retrofit, and no database. Install JDK 17, Android SDK 35, and Gradle 8.11.1.

These are the configured template requirements, not a claim of compatibility with every SDK release. The validation record lists the SDKs and combinations previously checked.

2. Inspect the archive before running commands

Generate the ZIP, extract it, and open a terminal inside the folder containing README.md. Preview the source tree in the generator before downloading. The default configuration currently produces 25 files, including the following entry points:

3. Set up and run the starter

java -version
gradle wrapper --gradle-version 8.11.1
./gradlew assembleDebug
./gradlew testDebugUnitTest

After building, open the extracted project in Android Studio, sync Gradle, and run the app on an emulator or connected device. The home screen should show a zero count and increment when tapped. The debug APK is under app/build/outputs/apk/debug/ for this unflavored preset.

4. Understand what the included test proves

app/src/test/java/com/example/myandroidapp/CounterRepositoryTest.kt is generated with this preset:

package com.example.myandroidapp
import org.junit.Test
import org.junit.Assert.assertEquals
import kotlinx.coroutines.runBlocking
import com.example.myandroidapp.data.repository.MemoryCounterRepository
class CounterRepositoryTest { @Test fun retainsValue() = runBlocking { val repository = MemoryCounterRepository(); repository.save(3); assertEquals(3, repository.load()) } }

The repository test checks the small in-memory contract. It does not prove that authentication, remote APIs, persistence, or release signing work. Add tests around your own behavior before replacing the demo repository.

5. Connect one real feature

Replace the memory repository through the application’s dependency container. Keep the screen dependent on its state owner, add an initial load and a recoverable failure state, then test a successful operation and an unavailable data source. API clients have placeholder endpoints; selecting an authentication screen does not create a real sign-in service.

Common setup problems

gradle or ./gradlew not found

Install local Gradle 8.11.1, then create the wrapper from the extracted root. On Windows use gradlew.bat for subsequent commands.

SDK location not found

Set ANDROID_HOME or create local.properties with sdk.dir pointing to your Android SDK. Install the compile SDK selected in your configuration.

Java or plugin compatibility failure

Use JDK 17 with the configured AGP 8.9.2, Kotlin 2.1.20, and Gradle 8.11.1 baseline. Check the Gradle JDK setting in Android Studio as well as your shell.

assembleDebug differs from the README

Build-variant options change task names. A flavor configuration can require assembleDevelopmentDebug. The downloaded README reflects your selected options; these commands describe the default preset.

Choosing supported options

The template baseline uses a coordinated Android build toolchain. Hilt and Room use kapt. The starter ViewModel receives a repository through a factory even when a DI integration is selected. Secure preferences is an interface to implement, and build variants change the available Gradle tasks.

If a combination fails, report the configuration and first error. For more context, read the source walkthrough or consult Android’s command-line build documentation.