In the second half of 2025, several teams that had pushed casual games into super-apps began auditing the same overlooked metric: the time from a user's first tap to the first painted frame. The reason it suddenly mattered is that the money moved. WeChat's mini-games took in RMB 53.5 billion in 2025 with more than 500 million monthly players; Telegram Mini Apps crossed a billion dollars in annual transaction volume on 450 million-plus monthly users; Discord's monthly actives reached 260 million. The entire bet rests on "tap and play" — a user taps, and the thing must be on screen immediately. When a mini-program shows a two-second white screen on first open, most people have already swiped away. To an observer, this is not a "tune the performance" problem; it is the entry ticket to the table.

The two seconds, broken down, are three taxes

The white screen is not magic failing; it is three costs paid in sequence, and each is most expensive on the first open. The first is engine allocation: the runtime must hand this mini-program its own JS engine instance, build a heap, and initialize. The second is parsing and compilation: a few hundred KB of JS has to be parsed and compiled to bytecode. The third, and the nastiest, is bridge warm-up: before the mini-program logic and the native layer call each other for the first time, the two sides of the bridge must shake hands and build a channel, and any call before that is blocking.

What makes "first open" unfixable is V8's code-cache tiers. V8 caches compiled output at three levels: cold (caches nothing, recompiles every time), warm (caches the script top level but not inline caches or hidden classes), and hot (caches the optimized-compilation result too). The catch is that the tier upgrades based on how many times a script has been accessed at that origin. The first open always lands in cold — the engine compiles from scratch, and the open that decides whether the user stays is exactly the globally coldest one. The "instant open" a developer measures locally is actually the second or third open, because repeated local opens have already pushed the cache to hot.

More insidious is the JIT tier. On mid-to-high-end devices V8 runs the full optimizing compiler; on memory-starved devices the runtime may drop to lite mode and skip JIT entirely, running everything through the interpreter. That means the same code runs not only slower to cold-start on a low-end phone, but at a different steady-state speed entirely. Treating the desktop number as the user's number is the most common misjudgment in this kind of audit.

Different hosts handle cold start differently

Pull the lens back to the host, and WeChat, Telegram, and Discord treat cold start very differently — which also decides the lever a developer actually has. WeChat approximates "pre-download plus subpackages": the mini-program's package is scheduled by the platform in a sense, and what the developer controls is mainly the main-package size. Telegram's Mini App is essentially a web page running in a native WebView, so cold start is close to a web first paint, with the engine instance and WebView both managed by the system. Discord's Activities move rendering onto a mix of cloud streaming and local WebView, and first entry usually crosses a connection handshake.

For third-party developers the conclusion is consistent: none of engine allocation, parsing, or bridge warm-up is truly in hand. The one thing a developer can repeatedly verify is how much work the first open actually does. Betting on "the host will optimize for me" tends to produce unexplained, unreproducible differences in the field.

Warm-preload: works in the office, backfires in the field

The instinct when first open is slow is preloading — spin up the runtime and prefetch the first route before the user taps. This plays beautifully on the team's test phones, because those are last year's flagships with memory to spare; the OS never touches the preloaded instance.

Post-launch the picture inverts. In 2025, about 89% of smartphones sold in Southeast Asia were under $200, and in Vietnam that share was 51%; these are devices with 2–4 GB of RAM and a WebView engine two major versions behind. The memory borrowed for preload is reclaimed on the OS's terms — not a negotiation, the Low Memory Killer simply cuts it. It cuts precisely when the preloaded card is about to show, turning a white screen into a black one or a straight ANR. One real case: a casual-game team enabled preloading at launch, low-end crash rates went up, and they fell only after turning it off. Warm-preload is a nice-to-have on devices that have memory to spare and a liability on devices that don't — and in 2025 the latter are most users.

The only hard lever: shrink the first screen

The engine belongs to the runtime, preload cannot be trusted, and host strategy cannot be changed. The one lever a developer can repeatedly verify is to stop the first open from doing so much. Concretely: keep first-screen JS under a budget (many teams use ~200 KB as the line), lazy-load anything that can wait, and render only the viewport on first paint. This is not a clever trick; it is discipline. Every extra synchronous first-screen dependency is another tax on the user's first open.

StageFirst openFrom second openDeveloper control
Engine allocationFull priceAlready existsNone
Parse and compileCold tier, full recompileHot tier, cache hitIndirect (write less, subpackage)
Bridge warm-upBlocking handshakeChannel builtNone
JIT tierMay drop to liteMay upgradeNone, but reduce load
First-screen loadYour callYour callYes, and the heaviest

How to measure the real number? Do not trust local. Take a real low-end Android, clear every runtime cache, and cold-start from onLaunch to first frame. A repeatedly validated baseline is a 3 GB RAM, Android 11, WebView 94 device — any higher-end number is only good for comforting the team. One team cut first-screen JS from 800 KB to 180 KB, dropping first open from 2.1s to 0.9s and lifting next-day retention by a few points; the gain came not from a black art but from "on first open it genuinely had little to do."

The bottom line

The first-open white screen is not a bug; it is the mini-program's first sentence to the user. That sentence gets one chance, and V8's cache tiers, the JIT tier switch, and the OS memory reclaim will not give a second. The framework and runtime belong to someone else; the first-screen size belongs to you. Shrink it first, then talk about other optimizations.

Sources