Assets & configuration

The Android splash screen guide for HTML apps

Why so many HTML apps show two splash screens and then a white flash, measured frame by frame on a real phone, and the one change that cut our launch time from 3.3 seconds to 1.4.

10 min read Updated November 2026 By Faisal Nadeem Tested on a Galaxy A05, November 2026
1 min 21 s explainer with real recordings from the test phone. Captions available.

An HTML app needs exactly one splash screen, in your brand colour, shown until the first page has loaded and not a moment longer. Since Android 12, every app already gets a splash screen from the system. If your app adds a second splash on a timer, people see two different screens, then often a blank white page, before your content appears. We measured both setups on a budget Android phone. With two splashes, it took 3.3 seconds from tap to first page. With one splash held until the page loaded, it took 1.4 seconds, and the grey screen and white flash were gone.

This guide is about timing and behaviour, the part a design tool can't show you. For icon sizes and the 432dp safe zone, use the splash screen generator.

Splash Screen GeneratorPreview and export an Android splash screen Open the tool

What happens when someone taps your HTML app

An app that shows HTML can't show your page straight away. Android has to start the app's process, create the WebView (a whole browser engine), and then load and draw your first page. A splash screen exists to cover that gap. Here's what fills the gap, in order:

  1. The system splash. On Android 12 and newer, the system draws it for every app before any of your code runs. It's a background colour with your icon in the middle. If the app's theme doesn't set a splash colour, Android uses the theme's ordinary window background instead.
  2. Your own splash screen, if the app has one. Many WebView templates still include a separate splash screen from the Android 11 era, often on a fixed timer.
  3. The WebView before its first paint. Until your page draws, the WebView is a blank white rectangle.
  4. Your page.

Every step you see here is time the user spends waiting. The goal is to make steps 1 to 3 look like one calm screen, and to end it the moment step 4 is ready.

How we tested

We used the recipe page from our mobile-ready guide and built it into four Android apps, all identical apart from how they start:

We installed each app on a Samsung Galaxy A05 (Android 15, WebView 157) and recorded four cold starts with adb shell screenrecord, closing the app completely before each one. Then we classified every frame of the recordings, 60 per second, as system splash, brand splash, transition, blank WebView or page. All times below are measured from the tap.

Frames from the first launch of each app. Two splashes: a grey system splash, then a terracotta splash screen, then a blank white WebView with a spinner, then the page at 4.57 seconds. One splash: a terracotta splash, then the page at 1.75 seconds
The worst case: the very first launch after installing. The two-splash app shows three different screens before the page appears.
Setup (Galaxy A05)First launch after installLater launches (median)What the user sees
Two splashes, page bundled4.57 s3.27 sGrey screen → brand screen → (white on first launch) → page
Two splashes, live URL3.82 s3.22 sSame
One splash, page bundled1.75 s1.40 sBrand screen → page
One splash, live URL2.15 s1.45 sBrand screen → page
Bar chart of tap-to-page time: two splashes took 3.27 and 3.22 seconds, mostly a fixed-time brand splash after a grey system splash; one splash took 1.40 and 1.45 seconds
Where the time goes. The two-splash bars are mostly the fixed timer, not loading.

What the numbers say

How to build one splash held until the page loads

If you build the Android side yourself, whether in Android Studio or by editing a template, this is the setup we tested, as it ran on the phone. It uses Jetpack's SplashScreen library, which also gives older Android versions the same behaviour.

1. Add the library

// app/build.gradle.kts
dependencies {
    implementation("androidx.core:core-splashscreen:1.0.1")
}

2. Give the splash your brand colour and icon

<!-- res/values/themes.xml -->
<style name="Theme.App.Starting" parent="Theme.SplashScreen">
    <item name="windowSplashScreenBackground">#C96A4A</item>
    <item name="windowSplashScreenAnimatedIcon">@drawable/app_icon</item>
    <item name="postSplashScreenTheme">@style/Theme.App</item>
</style>

Use the same colour as the top of your first page. Our page header is that terracotta, so the moment the splash lifts, the header is already in place and the change barely registers. The icon is masked to a circle, which is why the tool above places your artwork inside the safe zone.

3. Make the WebView screen the launcher

Delete the separate splash activity and launch straight into the screen that holds the WebView, using the starting theme:

<activity
    android:name=".MainActivity"
    android:exported="true"
    android:theme="@style/Theme.App.Starting">
    <intent-filter>
        <action android:name="android.intent.action.MAIN" />
        <category android:name="android.intent.category.LAUNCHER" />
    </intent-filter>
</activity>

4. Hold the splash until the page has loaded, with a time limit

import androidx.core.splashscreen.SplashScreen.Companion.installSplashScreen

class MainActivity : AppCompatActivity() {
    @Volatile private var pageShown = false

    override fun onCreate(savedInstanceState: Bundle?) {
        val start = SystemClock.uptimeMillis()
        installSplashScreen().setKeepOnScreenCondition {
            // Keep the splash until the page is ready, but never more than 5 s.
            !pageShown && SystemClock.uptimeMillis() - start < 5000
        }
        super.onCreate(savedInstanceState)
        // … set up the WebView as usual, then:
        webView.webViewClient = object : WebViewClient() {
            override fun onPageFinished(view: WebView, url: String) {
                pageShown = true
            }
        }
    }
}

Two details matter. installSplashScreen() has to run before super.onCreate(). And the 5-second limit is essential: on a dead connection, onPageFinished may come late or show an error page, and nobody should be stuck looking at a logo. After 5 seconds the splash lifts, and your page loader or offline screen takes over.

If you use a converter and can't change the native code

You still control more than you think, and you can measure the result yourself.

Adaptive Icon PreviewerSee your icon under every launcher mask Open the tool

Measure your own app's launch

With your phone connected over USB debugging, these commands reproduce our test. Replace the package name with your app's.

# close the app completely, then record 8 seconds of screen
adb shell am force-stop com.example.app
adb shell screenrecord --time-limit 8 /sdcard/launch.mp4 &

# launch it (in a second terminal, or after a short pause)
adb shell monkey -p com.example.app -c android.intent.category.LAUNCHER 1

# copy the video to your computer and step through it frame by frame
adb pull /sdcard/launch.mp4

Count the distinct screens before your page appears. One is the goal. Two different colours, or a white frame, means there's time to win back.

Common mistakes

What to do next

Get the icon right first. It appears on the launcher, the splash and the Play listing, and the Android app icon guide covers every size. Then follow the complete HTML to APK guide to build and install the app.

Questions people ask

How long should a splash screen show in an Android app?

Only until the first screen is ready to draw. In our tests on a budget Android phone, a splash held until the HTML page finished loading lasted about 1.2 to 1.3 seconds. Fixed timers on top of that only add waiting.

Why does my app show two splash screens?

Since Android 12, the system shows its own splash for every app. If your app also has a separate splash screen, users see both, usually in two different colours. Remove the separate one and give the system splash your colour and icon.

Why is there a white screen after my splash screen?

That's the WebView before it has drawn your page. In our tests it showed for about a third of a second on the first launch after install. Holding the splash until the page has finished loading removes it completely.

Can I make my splash screen in HTML?

No. During the splash, your WebView doesn't exist yet. An HTML loading screen can only appear after the native splash, as part of your page. Use it as a page loader, not as the splash.

Does a splash screen make an app slower?

A fixed-time splash does. In our tests, apps with a 1.8-second splash timer took 3.2 to 3.3 seconds from tap to page, against 1.4 to 1.45 seconds for an identical app whose splash ended when the page had loaded.

Read next

Ready to turn your site into an app?

Upload an HTML file or a ZIP, set your icon and name, and download a signed Android app. No Android Studio, no command line.

Open the builder