Free, open-source Android apps and developer tools, built for small screens, one-handed use and offline work.
🌐 Website: android-shop.github.io · All projects · Small-screen design guide · App ideas
Android Shop is a growing collection of free, open-source Android apps and developer tools. Every project is small and focused, works one-handed and offline, and shares data without a server or account. Each one is also a readable Kotlin and Jetpack Compose example you can learn from or build on.
| Project | What it is | Links |
|---|---|---|
| ⚡ android_scaffold | Developer tool. A single Python script that turns Kotlin files into a running Android app, with live reload on every save. | Overview · Quick start · Download |
| 🧺 Thumb Inventory | Android app. A one-thumb stock counter for shelves, fridges and stockrooms, with offline storage and CSV sharing between phones. | Walkthrough · Source |
| 🔜 More on the way | New apps and tools are added regularly. | All projects |
Build an Android app from plain Kotlin files in one command: no Android Studio, no Gradle setup, no XML.
Project page ·
Quick start ·
Live reload ·
Reference
android_scaffold is a free, open-source Python script that turns Kotlin and Jetpack Compose source files into a complete Android Gradle project, then builds the APK, boots the Android emulator (or uses your USB-connected phone), installs and launches the app, and live-reloads it every time you save. It is the fastest way to build an Android app from the command line without Android Studio, prototype an idea, or ship a small internal tool as an APK.
python3 android_scaffold.py my-app --name "My App" --watch⬇️ Get the script: android_scaffold.py · direct download
curl -LO https://android-shop.github.io/android_scaffold.py- Build an Android app without Android Studio using only Python, a JDK and the Android SDK
- Turn a single Kotlin file into an APK you can send to any phone
- Live reload / hot reload on the emulator: rebuild, reinstall and relaunch on every save
- Rapid Android prototyping of Jetpack Compose and Material 3 UIs from any editor
- Paste Kotlin code from ChatGPT, Claude or a blog and run it, Markdown fences and all
- Auto-generate
AndroidManifest.xml, Gradle files and the Gradle wrapper - Learn to design for small screens: thumb zone, touch targets, haptics, offline-first, sharing without a backend
A phone is the most capable computer most people carry: a touchscreen, vibration, a camera, Wi-Fi, local storage, and a share menu that reaches every other app. Yet even a one-button Android app needs a whole project before your code can run:
my-app/
├── settings.gradle.kts ← repositories, module list
├── build.gradle.kts ← plugin versions
├── gradle.properties ← JVM flags, AndroidX switches
├── local.properties ← path to your SDK
├── gradlew gradlew.bat ← wrapper launchers
├── gradle/wrapper/… ← wrapper jar + properties
└── app/
├── build.gradle.kts ← SDK levels, Compose, dependencies
└── src/main/
├── AndroidManifest.xml ← every Activity, launcher intent
├── res/drawable/… ← an app icon
└── java/com/example/app/
└── MainActivity.kt ← the only file you actually care about
That's 12 files and about 220 lines of configuration across Gradle, XML and properties formats, plus matching versions of the Android Gradle Plugin, Kotlin and Compose. You also have to update the manifest every time you add a screen. For a quick internal tool or a prototype, that setup is often what stops the idea from getting built.
android_scaffold.py takes that setup over, so you only write the app.
tap-counter/
└── MainActivity.kt
package com.example.tapcounter
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableIntStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
var taps by remember { mutableIntStateOf(0) }
Button(onClick = { taps++ }) { Text("Tapped $taps times") }
}
}
}python3 android_scaffold.py tap-counter --name "Tap Counter" --runThat one command:
- generates the full Gradle project, manifest and launcher icon,
- builds a debug APK,
- boots an emulator, or uses the phone you've plugged in,
- installs and opens your app,
- copies the APK to
apk/, ready to send to anyone's phone.
| You'd normally… | The script… |
|---|---|
| Choose and match AGP, Kotlin and Compose versions | Uses a known-good set of versions with Jetpack Compose and Material 3 |
Create the com/example/app/ folder tree |
Puts each file in the right folder based on its package line |
Register every Activity in AndroidManifest.xml |
Finds your Activities and registers them, with MainActivity as the launcher |
| Choose an application ID | Uses the package of your MainActivity |
| Install Gradle, or commit a wrapper | Creates the Gradle wrapper for you |
| Point the build at your SDK | Finds the SDK on macOS, Windows or Linux |
Remember adb and emulator commands |
Runs them, and prints a cheat sheet in case you want to run them by hand |
| Clean up code pasted from a chat | Removes leftover ``` fences |
Start with one file. When the app grows, add more files, packages and screens to the folder. Everything is picked up and registered automatically, with no build files to edit. The example app below is 26 Kotlin files across six packages, built with the same one-line command.
python3 android_scaffold.py tap-counter --watchWatch mode turns the script into a live prototyping loop. It boots the emulator and opens your app once, then watches your source folder. Every time you save a .kt file, it:
- waits for the save to finish, so a "save all" across several files triggers one reload,
- syncs only the changed files into
android_build/, - rebuilds incrementally (the Gradle daemon stays running between builds),
- reinstalls and relaunches the app on the emulator.
[*] Watching 'tap-counter' for Kotlin changes. Press Ctrl+C to stop.
[*] Changed: MainActivity.kt
[+] Reloaded in 2.8s. Watching for changes...
New files are picked up, deleted ones are removed, and new screens are registered. If a save doesn't compile, the error is printed and watching continues, so you fix it and save again. Press Ctrl+C to stop.
| Python | 3.8+ (standard library only) |
| JDK | 17 or newer, on PATH or set with JAVA_HOME |
| Android SDK | Found through ANDROID_HOME / ANDROID_SDK_ROOT, or the default Android Studio location |
| Internet | First build only, to fetch the Gradle wrapper and dependencies |
| Device | An emulator (Android Studio → Device Manager) or a phone with USB debugging, for --run and --watch |
python3 android_scaffold.py <source> # generate / refresh the project
python3 android_scaffold.py <source> --build-apk # + build the APK
python3 android_scaffold.py <source> --run # + install and launch
python3 android_scaffold.py <source> --watch # + reload on every save
python3 android_scaffold.py <source> --list-emulators # list installed emulators
python3 android_scaffold.py <source> --start-emulator # boot the first emulator
python3 android_scaffold.py <source> --start-emulator Pixel_8_Pro_API_33<source> is a folder of .kt files (searched recursively) or a single .kt file. Rerunning any command is incremental: the existing project is reused and only changed files are copied.
| Option | Default | Description |
|---|---|---|
-o, --output |
./android_build |
Where the generated project goes. You can also open it in Android Studio. |
-n, --name |
ThumbInventory |
App name under the launcher icon |
--apk-dir |
apk/ next to the source |
Where a copy of the APK is placed |
--build-apk |
off | Build the debug APK |
--run |
off | Build, install and launch |
--watch |
off | Like --run, then rebuild, reinstall and relaunch whenever a .kt file changes |
--start-emulator [AVD] |
off | Boot an emulator, optionally by name |
--list-emulators |
off | List installed emulators and exit |
| Symptom | Fix |
|---|---|
Android SDK : Not auto-detected |
export ANDROID_HOME=~/Library/Android/sdk (or your SDK path) |
No installed Android Virtual Devices |
Create one in Android Studio → Device Manager, or plug in a phone with USB debugging enabled |
Could not download gradle-wrapper.jar |
Connect to the internet for the first build, or run gradle wrapper in the output folder |
| Build fails after a JDK change | Point JAVA_HOME at JDK 17 or newer |
Once setup costs nothing, it's worth building small apps that do things a laptop or a web form can't. These are the Android strengths worth designing around.
A lot of useful data is out in the field: on a shelf, at a job site, next to a machine, at a customer's door. A laptop needs a surface and two hands, and a desk-based workflow means remembering things and typing them in later, which is where mistakes creep in.
A phone app can:
- record the moment you see it, one-handed, while you're standing in front of the thing you're counting or checking,
- save every change instantly on the device, so nothing is lost if you're interrupted,
- work fully offline in basements, cold rooms, warehouses and anywhere else without signal,
- confirm each action with a vibration, so your eyes stay on the work instead of the screen.
Good fits: stock counts, site inspections, attendance, meter readings, delivery checklists, field surveys, equipment logs. See small Android app ideas.
On-screen keyboards are slow and error-prone, especially while walking. Most data entry on a phone can be designed around the screen and your thumb instead:
| Android building block | Use it for |
|---|---|
| Large tap targets | The most common action, one tap away |
| Swipe gestures | Opposite or destructive actions, like decrementing or dismissing |
| Double-tap | Quick toggles such as flags and favourites |
| Long-press | Opening extra options without cluttering the screen |
| Bottom sheets | Menus and choices where the thumb already rests |
| Haptic feedback | Confirming an action without looking |
| Undo instead of "Are you sure?" | Keeping the flow fast while still forgiving mistakes |
Keep typing for the rare cases that truly need it.
Android already connects apps and devices, so a small app often needs no server or accounts at all:
- The system share menu sends data through WhatsApp, email, Bluetooth, Quick Share, Slack and any other app the user has.
- "Open with…" lets your app receive files shared or tapped anywhere on the phone.
- The storage picker saves and loads files from Downloads, Documents, Google Drive and other cloud folders the user has connected.
- Local Wi-Fi or a hotspot moves data directly between phones, with no internet.
- Plain formats like CSV keep the data readable in Excel and Google Sheets, so nothing is locked into your app.
The website expands each idea above into a practical guide, with Jetpack Compose examples, for anyone building apps for phones and other portable devices:
| Guide | What you'll learn |
|---|---|
| Designing for small screens | The principles, plus Android settings that make your own phone easier to use |
| The thumb zone | One-handed reach, bottom navigation, where to put primary actions |
| Touch targets and gestures | 48dp targets, swipe, double-tap, long-press, undo instead of confirmation dialogs |
| Haptics and feedback | Confirming actions without looking at the screen |
| Readable text and contrast | sp units, contrast ratios, sunlight, dark mode, 200% font scale |
| Offline-first field apps | Saving every change on the device and working without signal |
| Designing for interruptions | Calls, rotation, process death and battery |
| Sharing without a backend | Share sheet, Open with, Storage Access Framework, Wi-Fi between phones |
Thumb Inventory is an Android Shop app, and the first one built with android_scaffold. The src/ folder holds the complete app: a one-thumb stock counter for shelves, fridges and stockrooms. Read the walkthrough.
| Idea | How the example uses it |
|---|---|
| Mobility | Count at the shelf with one hand. Each change is saved instantly and works offline. Zone tabs sit at the bottom of the screen within thumb reach. |
| Touch first | Tap or swipe to add and remove, double-tap to flag, hold for a bottom sheet with bigger controls. Each change vibrates and shows a short notice with Undo. Day-to-day counting needs no typing. |
| Sharing without a backend | Inventories move as CSV through the share menu, "Open with…", the storage picker, or straight to another phone over Wi-Fi or a hotspot. The receiver chooses whether to merge or replace. |
Run it on an emulator or a connected phone with live reload:
python3 android_scaffold.py src --watchThen change anything in src/, save, and watch the app reload. The fastest way to learn is to change something and see what happens.
The Android Shop website at android-shop.github.io is generated from this repository by a standard-library Python script, the same way the app is:
python3 scripts/build_site.pyIt reads the page manifest site-src/pages.json, wraps each fragment in site-src/pages/ with site-src/layout.html, and writes index.html and 404.html at the root and every other page under site/. It also writes sitemap.xml, robots.txt, Open Graph tags and schema.org structured data (articles, breadcrumbs, FAQ), and fails the build if any internal link is broken. Serve it locally with python3 -m http.server and publish it with GitHub Pages from the repository root.
android shop, open source android apps, free android apps, android developer tools, kotlin android projects, jetpack compose example apps, android without android studio, build android app command line, kotlin to apk, single file android app, jetpack compose, material 3, compose starter, android project generator, gradle generator, androidmanifest generator, android scaffold, android boilerplate, android template, android live reload, android hot reload, emulator auto reload, adb install, gradlew assembleDebug, rapid prototyping, internal tools, python android build script, kotlin android tutorial, small screen design, mobile ux, one-handed design, thumb zone, touch targets, haptic feedback, offline-first, field data collection, inventory app, stock counting app, csv share, android share intent, storage access framework
Copyright (C) 2026 Abhishek Sengar
All Android Shop projects, including android_scaffold and Thumb Inventory, are free software: you can redistribute them and/or modify them under the terms of the GNU General Public License, version 2 or (at your option) any later version (GPL-2.0-or-later), as published by the Free Software Foundation.
They are distributed in the hope that they will be useful, but without any warranty, without even the implied warranty of merchantability or fitness for a particular purpose. See the LICENSE file for the full text.
Every source file starts with the identifier SPDX-License-Identifier: GPL-2.0-or-later.