Skip to main content
Android Code Studio provides a powerful project wizard that helps you create fully configured Android projects directly on your device.

​
Using the Project Wizard

The Project Wizard (ATC Wizard) guides you through creating a new Android project with various templates and configurations.
1

Open the Project Wizard

From the main screen, tap the Create Project button or select File → New Project from the menu.
2

Choose a Template

Select from available project templates:
  • Empty Activity - Basic activity with a simple layout
  • Basic Activity - Activity with app bar and floating action button
  • Bottom Navigation Activity - App with bottom navigation
  • Navigation Drawer Activity - App with navigation drawer
  • Tabbed Activity - Activity with tabs
  • Compose Activity - Modern Jetpack Compose UI
  • Native C++ - Project with C++ native code support
  • Game Activity - Android game development template
  • No Activity - Empty project without activities
For Compose projects, the language is automatically set to Kotlin as Compose requires Kotlin.
3

Configure Project Settings

After selecting a template, configure your project:

​
Basic Information

  • Project Name - Must start with a letter and contain only letters, numbers, and underscores
  • Package Name - Your app’s unique identifier (e.g., com.example.myapp)
  • Save Location - Where to create the project

​
Build Configuration

  • Language - Choose Java or Kotlin
  • Minimum SDK - Minimum Android version your app supports (API 21+ recommended)
  • Use Kotlin DSL - Enable to use build.gradle.kts instead of build.gradle
The package name automatically updates based on your project name but can be customized.
4

Advanced Options (Optional)

For native development:
  • Use CMake - Enable for CMake build system (requires CMake installation)
  • Native Language - Choose C or C++
  • NDK Version - Select from installed NDK versions
Native C++ projects require an NDK installation. Install it from Settings → IDE Configuration → SDK Manager.
5

Create the Project

Tap Create to generate your project. The IDE will:
  1. Create the project structure
  2. Generate source files based on your template
  3. Set up Gradle build scripts
  4. Configure dependencies
  5. Initialize version control (git)

​
Project Structure

After creation, your project will have this structure: 
MyProject/
├── app/
│   ├── src/
│   │   ├── main/
│   │   │   ├── java/           # Java/Kotlin source files
│   │   │   ├── res/            # Resources (layouts, strings, etc.)
│   │   │   └── AndroidManifest.xml
│   │   ├── test/               # Unit tests
│   │   └── androidTest/        # Instrumented tests
│   └── build.gradle[.kts]      # Module build configuration
├── gradle/
│   └── wrapper/
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── build.gradle[.kts]          # Root build configuration
├── settings.gradle[.kts]       # Project settings
├── gradle.properties           # Gradle properties
└── gradlew                     # Gradle wrapper script

​
Template Details

​
Empty Activity

Creates a minimal activity with a simple layout:
MainActivity.kt
package com.example.myapp

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

​
Compose Activity

Creates a modern Jetpack Compose application:
MainActivity.kt
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            MyAppTheme {
                Surface(modifier = Modifier.fillMaxSize()) {
                    Greeting("Android")
                }
            }
        }
    }
}

​
Native C++ Project

Includes JNI configuration and native library setup:
MainActivity.kt
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        
        // Example native method call
        findViewById<TextView>(R.id.sample_text).text = stringFromJNI()
    }
    
    external fun stringFromJNI(): String
    
    companion object {
        init {
            System.loadLibrary("native-lib")
        }
    }
}

​
Configuration Files

The IDE generates properly configured files for your project.

​
Root build.gradle.kts

build.gradle.kts
plugins {
    id("com.android.application") version "8.2.0" apply false
    id("org.jetbrains.kotlin.android") version "1.9.20" apply false
}

​
Module build.gradle.kts

app/build.gradle.kts
plugins {
    id("com.android.application")
    id("org.jetbrains.kotlin.android")
}

android {
    namespace = "com.example.myapp"
    compileSdk = 34
    
    defaultConfig {
        applicationId = "com.example.myapp"
        minSdk = 21
        targetSdk = 34
        versionCode = 1
        versionName = "1.0"
    }
    
    buildTypes {
        release {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
    
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
}

dependencies {
    implementation("androidx.appcompat:appcompat:1.6.1")
    implementation("com.google.android.material:material:1.11.0")
    implementation("androidx.constraintlayout:constraintlayout:2.1.4")
}

​
gradle.properties

gradle.properties
org.gradle.jvmargs=-Xmx512m -Dfile.encoding=UTF-8
android.useAndroidX=true
kotlin.code.style=official
android.nonTransitiveRClass=true

​
Opening Existing Projects

  1. Tap Open Project on the main screen
  2. Navigate to your project folder
  3. Select the project root directory (containing build.gradle)
  4. Tap Open

​
Project Initialization

When you open a project, Android Code Studio:
1

Validates Project Structure

Checks for required files:
  • build.gradle or build.gradle.kts
  • settings.gradle or settings.gradle.kts
  • gradlew wrapper
2

Installs Gradle Wrapper (if needed)

If the Gradle wrapper is missing, the IDE automatically installs it:
-------------------- NOTE --------------------
Gradle wrapper not found. Installing...
----------------------------------------------
3

Initializes the Project

Runs Gradle sync to:
  • Download dependencies
  • Index source files
  • Parse build configurations
  • Set up language servers
4

Indexes Resources

Reads and caches:
  • Android resources (layouts, strings, drawables)
  • Java/Kotlin source files
  • Dependencies and classpaths
Initial project initialization may take a few minutes depending on project size and dependencies.

​
Troubleshooting

If you see “A project with this name already exists”, either:
  • Choose a different project name
  • Select a different save location
  • Delete the existing project if no longer needed
Native C++ projects require an NDK:
  1. Go to Settings → IDE Configuration
  2. Tap SDK Manager
  3. In Terminal, install NDK: 
    sdkmanager "ndk;25.2.9519653"
  4. Return to the project wizard and retry
If CMake is not found:
  1. Go to Settings → IDE Configuration
  2. Install CMake via Terminal: 
    sdkmanager "cmake;3.22.1"
  3. Restart the IDE and try again
Game Activity projects have special requirements:
  • Must be saved in the Android Code Studio home directory
  • Tap Automatically switch in the dialog to fix
  • Or manually set save location to the suggested path
If project initialization fails:
  1. Check your internet connection (for dependency downloads)
  2. Ensure you have enough storage space
  3. Try File → Sync Project with Gradle Files
  4. Check the Build Output for specific errors

​
Best Practices

Choose Appropriate SDK

Select the minimum SDK based on your target audience. API 21+ covers 99%+ of devices.

Use Kotlin DSL

Enable Kotlin DSL for better IDE support, type safety, and modern syntax in build scripts.

Follow Naming Conventions

Use PascalCase for project names and reverse domain notation for package names.

Enable Version Control

Projects are automatically git-initialized. Commit early and often.

​
Next Steps

After creating your project:

Build docs developers (and LLMs) love

Get started for freeTalk to us