Learn Jetpack-compose - 8 Code Examples & CST Typing Practice Test

Jetpack Compose is Android’s modern toolkit for building native UI using Kotlin, offering a declarative approach to designing app interfaces and simplifying UI development for Android.

View all 8 Jetpack-compose code examples →

Jetpack Compose Simple Todo App Jetpack Compose Counter App Jetpack Compose Dark Mode Counter Jetpack Compose Multi Counter Jetpack Compose Auto Increment Counter Jetpack Compose Todo With Priority Jetpack Compose Countdown Timer Jetpack Compose Counter With Alert

Learn JETPACK-COMPOSE with Real Code Examples

Updated Nov 23, 2025

Introduction & Fundamentals Setup & Configuration Architecture & Deep Internals Performance & Security Development Workflow Learning & Career Growth Business & Strategy Examples

Code Sample Descriptions

Jetpack Compose Simple Todo App

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.text.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        TodoApp()
        }
    }
}

@Composable
fun TodoApp() {
    var todos by remember { mutableStateOf(listOf<String>()) }
    var newTodo by remember { mutableStateOf("") }

    Column(modifier = Modifier.padding(16.dp)) {
        Row {
        TextField(value = newTodo, onValueChange = { newTodo = it }, modifier = Modifier.weight(1f))
        Spacer(modifier = Modifier.width(8.dp))
        Button(onClick = {
        if(newTodo.isNotBlank()) {
        todos = todos + newTodo
        newTodo = ""
        }
        }) {
        Text("Add")
        }
        }
        Spacer(modifier = Modifier.height(16.dp))
        Column {
        todos.forEach { todo -> Text(todo) }
        }
    }
}

Demonstrates a simple Jetpack Compose app with a Todo list, adding tasks, and displaying them using Composables and state management.

Let’s Try →

Jetpack Compose Counter App

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        CounterApp()
        }
    }
}

@Composable
fun CounterApp() {
    var count by remember { mutableStateOf(0) }
    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Text("Counter: $count", style = MaterialTheme.typography.h4)
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = { count++ }) { Text("+") }
        Button(onClick = { count-- }) { Text("-") }
        Button(onClick = { count = 0 }) { Text("Reset") }
        }
    }
}

A simple counter app with increment, decrement, and reset buttons.

Let’s Try →

Jetpack Compose Dark Mode Counter

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        DarkModeCounterApp()
        }
    }
}

@Composable
fun DarkModeCounterApp() {
    var count by remember { mutableStateOf(0) }
    var isDark by remember { mutableStateOf(false) }
    MaterialTheme(colors = if (isDark) darkColors() else lightColors()) {
        Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Text("Counter: $count", style = MaterialTheme.typography.h4)
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = { count++ }) { Text("+") }
        Button(onClick = { count-- }) { Text("-") }
        Button(onClick = { count = 0 }) { Text("Reset") }
        }
        Button(onClick = { isDark = !isDark }) { Text("Toggle Theme") }
        }
    }
}

Counter app with light/dark theme toggle.

Let’s Try →

Jetpack Compose Multi Counter

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        MultiCounterApp()
        }
    }
}

@Composable
fun MultiCounterApp() {
    var counters by remember { mutableStateOf(listOf(0, 0, 0)) }
    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        counters.indices.forEach { i ->
        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
        Text("Counter ${i+1}: ${counters[i]}", style = MaterialTheme.typography.h5)
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = { counters = counters.toMutableList().also { it[i]++ } }) { Text("+") }
        Button(onClick = { counters = counters.toMutableList().also { it[i]-- } }) { Text("-") }
        }
        }
        }
    }
}

Multiple independent counters in a single view.

Let’s Try →

Jetpack Compose Auto Increment Counter

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.delay
import androidx.compose.runtime.LaunchedEffect

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        AutoIncrementCounter()
        }
    }
}

@Composable
fun AutoIncrementCounter() {
    var count by remember { mutableStateOf(0) }
    var isRunning by remember { mutableStateOf(true) }
    LaunchedEffect(Unit) {
        while(true) {
        delay(1000)
        if(isRunning) count++
        }
    }
    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Text("Counter: $count", style = MaterialTheme.typography.h4)
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = { isRunning = !isRunning }) { Text(if(isRunning) "Pause" else "Resume") }
        Button(onClick = { count = 0 }) { Text("Reset") }
        }
    }
}

Counter that automatically increments every second.

Let’s Try →

Jetpack Compose Todo With Priority

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.text.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        PriorityTodoApp()
        }
    }
}

@Composable
fun PriorityTodoApp() {
    var todos by remember { mutableStateOf(listOf<Pair<String,String>>()) }
    var task by remember { mutableStateOf("") }
    var priority by remember { mutableStateOf("") }
    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Row {
        TextField(value = task, onValueChange = { task = it }, modifier = Modifier.weight(1f), placeholder = { Text("Task") })
        TextField(value = priority, onValueChange = { priority = it }, modifier = Modifier.weight(1f), placeholder = { Text("Priority") })
        Button(onClick = {
        if(task.isNotBlank()) {
        todos = todos + (task to priority)
        task = ""; priority = ""
        }
        }) { Text("Add") }
        }
        Column {
        todos.forEach { Text("${it.first} (Priority: ${it.second})") }
        }
    }
}

Todo app where each task has a priority and displays it.

Let’s Try →

Jetpack Compose Countdown Timer

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.delay
import androidx.compose.runtime.LaunchedEffect

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        CountdownTimerApp()
        }
    }
}

@Composable
fun CountdownTimerApp() {
    var count by remember { mutableStateOf(10) }
    LaunchedEffect(Unit) {
        while(count > 0) { delay(1000); count-- }
    }
    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Text("Time: $count", style = MaterialTheme.typography.h4)
        Button(onClick = { count = 10 }) { Text("Reset") }
    }
}

Countdown timer starting from 10 seconds.

Let’s Try →

Jetpack Compose Counter With Alert

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.launch

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        AlertCounterApp()
        }
    }
}

@Composable
fun AlertCounterApp() {
    var count by remember { mutableStateOf(0) }
    val scaffoldState = rememberScaffoldState()
    val scope = rememberCoroutineScope()
    Scaffold(scaffoldState = scaffoldState) {
        Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Text("Counter: $count", style = MaterialTheme.typography.h4)
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = {
        count++
        if(count == 10) scope.launch { scaffoldState.snackbarHostState.showSnackbar("Count reached 10!") }
        }) { Text("+") }
        Button(onClick = { count = 0 }) { Text("Reset") }
        }
        }
    }
}

Counter shows a Snackbar alert when it reaches 10.

Let’s Try →

Frequently Asked Questions about Jetpack-compose

What is Jetpack-compose?

Jetpack Compose is Android’s modern toolkit for building native UI using Kotlin, offering a declarative approach to designing app interfaces and simplifying UI development for Android.

What are the primary use cases for Jetpack-compose?

Native Android app development. Apps requiring reactive UI updates. Modernizing legacy Android apps. Enterprise Android apps with dynamic content. Rapid prototyping of Android interfaces

What are the strengths of Jetpack-compose?

Full native performance on Android. Modern declarative programming style. Tight integration with Kotlin and Android ecosystem. Reusable and modular composable components. Simplifies UI state handling and lifecycle management

What are the limitations of Jetpack-compose?

Android-only (no cross-platform support). Requires Kotlin knowledge. Still maturing compared to traditional XML-based UI. Limited community resources compared to older frameworks. May require refactoring legacy apps to adopt fully

How can I practice Jetpack-compose typing speed?

CodeSpeedTest offers 8+ real Jetpack-compose code examples for typing practice. You can measure your WPM, track accuracy, and improve your coding speed with guided exercises.

Learn Other Programming Languages

C React Python C++Rust TypeScript Kotlin PHP Java C#Ruby Mql Cql N1ql Cypher Gremlin Partiql Haskell Elixir Fsharp View all languages →

Code Sample Descriptions

Jetpack Compose Simple Todo App

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.text.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        TodoApp()
        }
    }
}

@Composable
fun TodoApp() {
    var todos by remember { mutableStateOf(listOf<String>()) }
    var newTodo by remember { mutableStateOf("") }

    Column(modifier = Modifier.padding(16.dp)) {
        Row {
        TextField(value = newTodo, onValueChange = { newTodo = it }, modifier = Modifier.weight(1f))
        Spacer(modifier = Modifier.width(8.dp))
        Button(onClick = {
        if(newTodo.isNotBlank()) {
        todos = todos + newTodo
        newTodo = ""
        }
        }) {
        Text("Add")
        }
        }
        Spacer(modifier = Modifier.height(16.dp))
        Column {
        todos.forEach { todo -> Text(todo) }
        }
    }
}

Demonstrates a simple Jetpack Compose app with a Todo list, adding tasks, and displaying them using Composables and state management.

Let’s Try →

Jetpack Compose Counter App

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        CounterApp()
        }
    }
}

@Composable
fun CounterApp() {
    var count by remember { mutableStateOf(0) }
    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Text("Counter: $count", style = MaterialTheme.typography.h4)
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = { count++ }) { Text("+") }
        Button(onClick = { count-- }) { Text("-") }
        Button(onClick = { count = 0 }) { Text("Reset") }
        }
    }
}

A simple counter app with increment, decrement, and reset buttons.

Let’s Try →

Jetpack Compose Dark Mode Counter

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        DarkModeCounterApp()
        }
    }
}

@Composable
fun DarkModeCounterApp() {
    var count by remember { mutableStateOf(0) }
    var isDark by remember { mutableStateOf(false) }
    MaterialTheme(colors = if (isDark) darkColors() else lightColors()) {
        Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Text("Counter: $count", style = MaterialTheme.typography.h4)
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = { count++ }) { Text("+") }
        Button(onClick = { count-- }) { Text("-") }
        Button(onClick = { count = 0 }) { Text("Reset") }
        }
        Button(onClick = { isDark = !isDark }) { Text("Toggle Theme") }
        }
    }
}

Counter app with light/dark theme toggle.

Let’s Try →

Jetpack Compose Multi Counter

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        MultiCounterApp()
        }
    }
}

@Composable
fun MultiCounterApp() {
    var counters by remember { mutableStateOf(listOf(0, 0, 0)) }
    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        counters.indices.forEach { i ->
        Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
        Text("Counter ${i+1}: ${counters[i]}", style = MaterialTheme.typography.h5)
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = { counters = counters.toMutableList().also { it[i]++ } }) { Text("+") }
        Button(onClick = { counters = counters.toMutableList().also { it[i]-- } }) { Text("-") }
        }
        }
        }
    }
}

Multiple independent counters in a single view.

Let’s Try →

Jetpack Compose Auto Increment Counter

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.delay
import androidx.compose.runtime.LaunchedEffect

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        AutoIncrementCounter()
        }
    }
}

@Composable
fun AutoIncrementCounter() {
    var count by remember { mutableStateOf(0) }
    var isRunning by remember { mutableStateOf(true) }
    LaunchedEffect(Unit) {
        while(true) {
        delay(1000)
        if(isRunning) count++
        }
    }
    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Text("Counter: $count", style = MaterialTheme.typography.h4)
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = { isRunning = !isRunning }) { Text(if(isRunning) "Pause" else "Resume") }
        Button(onClick = { count = 0 }) { Text("Reset") }
        }
    }
}

Counter that automatically increments every second.

Let’s Try →

Jetpack Compose Todo With Priority

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.foundation.text.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        PriorityTodoApp()
        }
    }
}

@Composable
fun PriorityTodoApp() {
    var todos by remember { mutableStateOf(listOf<Pair<String,String>>()) }
    var task by remember { mutableStateOf("") }
    var priority by remember { mutableStateOf("") }
    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Row {
        TextField(value = task, onValueChange = { task = it }, modifier = Modifier.weight(1f), placeholder = { Text("Task") })
        TextField(value = priority, onValueChange = { priority = it }, modifier = Modifier.weight(1f), placeholder = { Text("Priority") })
        Button(onClick = {
        if(task.isNotBlank()) {
        todos = todos + (task to priority)
        task = ""; priority = ""
        }
        }) { Text("Add") }
        }
        Column {
        todos.forEach { Text("${it.first} (Priority: ${it.second})") }
        }
    }
}

Todo app where each task has a priority and displays it.

Let’s Try →

Jetpack Compose Countdown Timer

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.delay
import androidx.compose.runtime.LaunchedEffect

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        CountdownTimerApp()
        }
    }
}

@Composable
fun CountdownTimerApp() {
    var count by remember { mutableStateOf(10) }
    LaunchedEffect(Unit) {
        while(count > 0) { delay(1000); count-- }
    }
    Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Text("Time: $count", style = MaterialTheme.typography.h4)
        Button(onClick = { count = 10 }) { Text("Reset") }
    }
}

Countdown timer starting from 10 seconds.

Let’s Try →

Jetpack Compose Counter With Alert

import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.launch

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
        AlertCounterApp()
        }
    }
}

@Composable
fun AlertCounterApp() {
    var count by remember { mutableStateOf(0) }
    val scaffoldState = rememberScaffoldState()
    val scope = rememberCoroutineScope()
    Scaffold(scaffoldState = scaffoldState) {
        Column(modifier = Modifier.padding(16.dp), verticalArrangement = Arrangement.spacedBy(16.dp)) {
        Text("Counter: $count", style = MaterialTheme.typography.h4)
        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
        Button(onClick = {
        count++
        if(count == 10) scope.launch { scaffoldState.snackbarHostState.showSnackbar("Count reached 10!") }
        }) { Text("+") }
        Button(onClick = { count = 0 }) { Text("Reset") }
        }
        }
    }
}

Counter shows a Snackbar alert when it reaches 10.

Let’s Try →

Frequently Asked Questions about Jetpack-compose

What is Jetpack-compose?

Jetpack Compose is Android’s modern toolkit for building native UI using Kotlin, offering a declarative approach to designing app interfaces and simplifying UI development for Android.

What are the primary use cases for Jetpack-compose?

Native Android app development. Apps requiring reactive UI updates. Modernizing legacy Android apps. Enterprise Android apps with dynamic content. Rapid prototyping of Android interfaces

What are the strengths of Jetpack-compose?

What are the limitations of Jetpack-compose?

How can I practice Jetpack-compose typing speed?

CodeSpeedTest offers 8+ real Jetpack-compose code examples for typing practice. You can measure your WPM, track accuracy, and improve your coding speed with guided exercises.