Home Page » News » How To » How to Create a Custom Android Boot Animation (No Root Required)

How to Create a Custom Android Boot Animation (No Root Required)

14 min read Learn step‑by‑step how to design, package, and install a custom boot animation on Android without rooting your device, with fallback methods for rooted phones. October 10, 2026 04:30

When you power on an Android phone the first thing you see is the boot animation – a short loop of images that runs while the system loads. Replacing it with something personal (your logo, a favorite GIF, or a seasonal theme) gives your device a unique feel without installing a full‑blown custom ROM.

What this tutorial solves: It shows you how to design a boot animation, package it correctly, and install it on a stock Android device without needing root. If you have root, we also cover the simpler system‑wide method.

Before you start

Charge your phone to at least 50 % to avoid interruptions.
Make sure you have a computer with adb installed (part of Android Platform‑Tools).
Enable Developer options → USB debugging on the phone.
Install a file‑manager app that can copy files to the /sdcard/ folder (e.g., Files by Google).
Prepare a folder on your PC where you will keep the animation frames (PNG or JPG) and a text file named desc.txt.

Understanding how Android boot animations work

Android expects a single bootanimation.zip file placed in /system/media/ (root) or /sdcard/ (non‑root). The zip must contain:

A desc.txt file that tells the system the animation’s resolution, frame rate, and how many times each part should loop.
One or more sub‑folders (named part0, part1, …) that hold the sequential image frames.
- Frames are named 00001.png, 00002.png, etc., zero‑padded to five digits.

The device reads desc.txt first, then displays the frames in order. When the last part finishes, the animation stops and Android continues booting.

Step 1 – Design your frames

Decide the final resolution. Most modern phones use 1080×1920 (portrait) or 1080×1080 (square). Using a resolution that matches your device’s native screen avoids scaling artifacts.
Choose a frame rate. 30 fps gives smooth motion but creates larger files; 15 fps is usually sufficient for simple logos.
Create the frames in an image editor (GIMP, Photoshop, or a free online GIF‑to‑PNG converter). Export each frame as a PNG with transparency if you want a transparent background.
Save the frames in a folder called part0. If you want a two‑part animation (e.g., a logo that stays on screen after the first part), create a second folder part1 and place the remaining frames there.
Rename the files sequentially: 00001.png, 00002.png, … Ensure the numbering starts at 1 and uses five digits.

Step 2 – Write the descriptor file

Open a plain‑text editor and create desc.txt in the same directory that contains part0 (and part1 if you have one).
Use the following syntax (values are space‑separated):
```
width height fps loop_count
```
- width – horizontal pixel count (e.g., 1080)
- height – vertical pixel count (e.g., 1920)
- fps – frames per second (e.g., 30)
- loop_count – number of times this part repeats. Use 0 for infinite looping.
Example for a single‑part animation that loops forever:
```
1080 1920 30 0
```
If you have a second part that should play once after the first loop, add a second line:
```
1080 1920 30 1
```
Save the file exactly as desc.txt (lower‑case).

Step 3 – Package the animation into a zip

Open a command prompt (Windows) or terminal (macOS/Linux) and navigate to the folder that contains desc.txt and the part* directories.
Run the following command to create the zip without compression (Android expects the zip to be stored, not deflated):
```
zip -r -0 bootanimation.zip *
```
- -r – recurse into sub‑folders.
- -0 – store files without compression.
Verify the zip structure by opening it with any archive viewer. You should see desc.txt at the root and the part0 (and optionally part1) folders inside.

Step 4 – Install the animation without root

Android’s stock bootloader only reads bootanimation.zip from /system/media/. However, many OEMs (Pixel, OnePlus, Samsung) also look in /sdcard/ as a fallback when the system folder is read‑only. This fallback works on most recent Android versions (8.0+).

Connect your phone to the computer via USB.
Open a terminal and confirm ADB sees the device:
```
adb devices
```
You should see a line with your device’s serial number.

Push the zip to the internal storage:

adb push bootanimation.zip /sdcard/bootanimation.zip

Reboot the device:
```
adb reboot
```
When the phone boots, you should see your custom animation. If the stock animation still appears, the device does not support the /sdcard/ fallback. In that case, proceed to the “Root method” below.

Step 5 – Installing on a rooted device (optional but simpler)

Ensure you have a working root (Magisk, SuperSU, etc.).
Remount /system as read‑write:
```
adb root
adb remount
```

Copy the zip to the system media folder:

adb push bootanimation.zip /system/media/bootanimation.zip

Set the correct permissions (read‑only for owner, readable for group/others):
```
adb shell chmod 644 /system/media/bootanimation.zip
```
Reboot:
```
adb reboot
```
The custom animation should now replace the stock one on every boot.

Step 6 – Using a third‑party app as a workaround (no root, no ADB)

If your device does not accept the /sdcard/ fallback and you cannot root it, you can use an app that leverages the hidden BOOTANIMATION permission. Apps such as “Boot Animation Designer” (available on the Play Store) request the permission via the Android WRITE_SECURE_SETTINGS flag, which only system apps can hold. Some manufacturers expose a “boot animation” setting in the developer options; check Settings > System > Advanced > Developer options > Boot animation if present.

These apps usually guide you through the same zip‑creation process and then copy the file to the appropriate location using the privileged permission granted by the OEM. The steps are app‑specific, so refer to the app’s own help page.

Step 7 – Verify the result

Power off the device completely (not just a soft reboot).
Turn it back on and watch the first few seconds. You should see the frames you designed.
If the animation freezes or shows a black screen, the device likely rejected the file because of size, resolution, or permission issues.

Troubleshooting

1. Boot animation does not change at all

Check the file location. On non‑root devices the file must be exactly /sdcard/bootanimation.zip. Any sub‑folder (e.g., /sdcard/Animations/bootanimation.zip) will be ignored.
Verify the zip format. Use an archive viewer to confirm there is no extra top‑level folder inside the zip. The root of the zip should contain desc.txt and part0.
Match the resolution. If your device’s screen is 1080×2400 but the zip says 1080×1920, Android will fall back to the default animation.

2. Device enters a boot loop after installing via `/system`

Boot into recovery mode (usually Power + Volume Down on most phones).
Use the recovery’s “Mount /system” option, then delete the offending file:
```
adb shell rm /system/media/bootanimation.zip
```
Reboot. The stock animation will return.
Root method tip: always keep a backup of the original bootanimation.zip before overwriting.
```
adb pull /system/media/bootanimation.zip backup_bootanimation.zip
```

3. Animation is choppy or shows visual artifacts

Reduce the frame rate to 15 fps.
Make sure all frames are the exact same dimensions; a single mismatched frame will cause Android to abort the animation.
Compress PNGs losslessly; avoid using JPG unless you need smaller file size (JPG adds compression artifacts that look worse on a loop).

4. “Permission denied” errors when pushing via ADB

For non‑root devices, you can only write to /sdcard/. Trying to push to /system/ will fail.
If you see adb: error: failed to get feature set: device offline, reconnect the USB cable and ensure USB debugging is still enabled.

Safety warnings

Modifying /system without a proper backup can brick the device. Always keep a copy of the original bootanimation.zip and, if possible, a full Nandroid backup via custom recovery.
Do not use frames larger than the device’s native resolution; oversized images increase RAM usage during boot and may cause a delayed start.
Never install a boot animation from an untrusted source. Malformed zip files can trigger a boot loop.

Summary

Creating a custom boot animation is a fun way to personalize Android without flashing a new ROM. The core steps are:

Design frames at the device’s native resolution.
Create a correctly formatted desc.txt.
Package everything into a bootanimation.zip with no compression.
Push the zip to /sdcard/ (no‑root) or /system/media/ (root).
Reboot and verify.

With the troubleshooting section you now have a safety net for the most common pitfalls. Enjoy your newly branded startup screen!

User Comments (0)

Add Comment

No comments added yet.

Add Comment

Your Name: *

Comment Title: *

Your E-mail: * We'll never share your email with anyone else.

Your Comment: *

Comments will not be approved to be posted if they are SPAM, abusive, off-topic, use profanity, contain a personal attack, or promote hate of any kind.