Learning how to build Kodi for Android is useful if you want to test the latest development version, modify Kodi’s source code, or create a custom APK. This is different from installing a “Kodi build,” which usually means a preconfigured collection of add-ons, skins, and settings. Compiling Kodi means creating the Android application itself from official source code.
The process requires a computer, development tools, storage, and patience. The instructions below focus on a legitimate source build for testing or personal development.
What You Need Before You Build Kodi for Android
You cannot compile Kodi directly on most Android phones or tablets. Use a desktop or laptop running Linux, macOS, or Windows with a Linux environment such as WSL2.
Recommended resources include:
- A 64-bit operating system
- At least 8 GB of RAM; 16 GB is more comfortable
- 30 GB or more of free storage
- A reliable internet connection
- Git
- CMake
- A Java Development Kit supported by the Kodi branch you are compiling
- Android Studio and the Android SDK
- Android NDK and command-line build tools
Kodi’s Android requirements can change between releases, so always check the official Kodi GitHub repository and Android build documentation before selecting SDK, NDK, or Java versions. Using the versions listed for your chosen Kodi branch prevents many configuration errors.
You should also decide whether you need a stable release branch or the development branch. A stable branch is generally easier to compile and test, while the development branch may include unfinished features.
Prepare the Kodi Android Build Environment
Start by installing Git, CMake, a compiler, Python, and other basic development packages through your operating system’s package manager. On Ubuntu-based Linux systems, this commonly includes packages such as git, cmake, ninja-build, python3, curl, and standard build tools.
Install Android Studio from Google’s official developer website. In Android Studio’s SDK Manager, install the Android SDK platform and build tools required by the Kodi documentation. Install the matching Android NDK as well, and note the installation paths.
Set environment variables so build tools can find the SDK and NDK. For example, a Linux shell configuration may contain:
``bash export ANDROID_HOME=$HOME/Android/Sdk export ANDROID_NDK_HOME=$ANDROID_HOME/ndk/<version> export PATH=$ANDROID_HOME/platform-tools:$ANDROID_HOME/cmdline-tools/latest/bin:$PATH ``
Replace <version> with the NDK version you installed. Reload your shell afterward or open a new terminal. Check the setup with:
``bash adb version cmake --version git --version ``
The exact environment variable names may differ by operating system. Kodi’s current documentation should take priority over older tutorials.
Download Kodi Source Code
Create a workspace and clone the official Kodi repository:
``bash mkdir -p ~/kodi-work cd ~/kodi-work git clone https://github.com/xbmc/xbmc.git cd xbmc git submodule update --init --recursive ``
The submodule command is important because Kodi depends on additional repositories. Skipping it can cause missing-file or dependency errors later.
To compile a specific stable version, list available branches and tags:
``bash git tag git branch -a ``
Then check out the version you want, for example:
``bash git checkout <release-tag> git submodule update --init --recursive ``
Use a tag or branch that matches the Android SDK, NDK, and Java versions documented for that release. Avoid downloading source code from random file-sharing sites. The official repository provides the most trustworthy code and build instructions.
Configure and Build Kodi for Android
Kodi’s current build system uses CMake presets in many supported configurations. From the root of the source tree, try the Android preset documented for your selected branch:
``bash cmake --preset android cmake --build build --target apk --parallel 4 ``
The preset normally configures the Android architecture, compiler, SDK paths, and required Kodi options. On some branches, you may need to provide SDK or NDK locations manually, or use a different preset name. Read the README and platform instructions included with the source tree if the command is rejected.
The build may take a considerable amount of time because Kodi compiles its own components and third-party dependencies. The --parallel 4 option uses four simultaneous build jobs. Increase the number if your computer has more CPU cores and enough memory, or reduce it if the system becomes unstable.
When compilation succeeds, search the build directory for the generated APK:
``bash find build -type f -name "*.apk" ``
The output location can vary by Kodi version and build configuration. Keep the APK together with its build information so you know which source revision created it.
Install and Test the Custom APK
Before installing a self-compiled APK, enable Developer Options and USB debugging on the Android device. Connect it with a USB cable, approve the computer authorization prompt, and confirm that Android Debug Bridge detects it:
``bash adb devices ``
Install the APK with:
``bash adb install -r /path/to/kodi.apk ``
The -r option attempts to preserve the existing Kodi application data. If Android reports a signature conflict, uninstall the existing Kodi version first. Doing so may remove its settings, so back up your Kodi userdata directory before proceeding.
A custom APK may not update normally through Google Play, and future builds signed with a different key may not install over it. Treat test builds as separate from your everyday Kodi installation. Test video playback, audio passthrough, subtitles, hardware acceleration, remote controls, and add-ons on the specific Android device you plan to use.
Common Problems When You Build Kodi for Android
CMake cannot find the Android SDK or NDK: Check the installed paths, environment variables, and required versions. Restart the terminal after changing them.
Gradle, Java, or SDK errors appear: Your Java, Android Gradle, SDK, or NDK version may not match the Kodi branch. Follow the branch-specific documentation rather than combining versions from different guides.
The build runs out of memory: Lower the parallel job count, close other applications, and ensure adequate free storage. Large builds also need temporary disk space.
The APK installs but crashes: Capture diagnostic output with:
``bash adb logcat ``
Check whether the crash involves unsupported hardware, missing permissions, a graphics driver, or a faulty source change.
Add-ons are missing: A source APK may not include every binary add-on. Build required add-ons separately or install compatible add-ons through Kodi’s official repository where available.
FAQ: Building Kodi on Android
Can I build Kodi for Android on an Android phone? It is technically possible with advanced Linux environments, but it is slow, complicated, and often limited by storage and memory. A desktop Linux system or Linux virtual machine is the practical choice.
Is a self-built Kodi APK safe? It can be, provided you obtain the source from the official Kodi repository, inspect any modifications, and protect the APK with your own signing key. Avoid pirated preconfigured APKs.
What is the difference between building Kodi and installing a Kodi build? Building Kodi means compiling the application from source code. Installing a Kodi build usually means importing a preconfigured interface, settings, and add-ons into an existing Kodi installation.
Conclusion
To build Kodi for Android, install the correct development tools, clone the official source repository, select a compatible branch, configure the Android preset, and compile the APK with CMake. Start with a stable release, follow its version requirements closely, and test the resulting app on a spare device before replacing your regular Kodi installation.
