Devlog // Double It
One game, every Android: a five-tier device classification system
The same WebGL2 build has to feel premium on a flagship and stay smooth on an entry-level phone someone bought for $80. This is the system that makes that decision — before the player notices there was one.
The problem with guessing from capabilities
The classic web approach — read navigator fields, count
cores, squint at the GPU string — collapses on Android because the
ecosystem is too wide. Eight cores means nothing when four of them
are efficiency cores from 2019. My first version was capability-only
and it made two opposite mistakes: it shipped full quality to phones
that could not hold 30 fps, and it insulted flagships with reduced
effects because their vendor string looked unfamiliar.
Three signals instead of one
The shipped system blends three sources, each covering the others' blind spots:
- A known-device profile layer. On Android, Capacitor gives me the device model and RAM. A curated database maps models and SoCs I have researched to one of five tiers — from tier 1 (entry level, e.g. low-end Unisoc and older Helio chips) to tier 5 (current flagships). A known device gets an informed starting point instantly.
- A GPU family classifier. Unknown models fall back to classifying the WebGL renderer string by GPU family and generation — Adreno, Mali, PowerVR, Xclipse, IMG — which is far more stable than model names. An Adreno 740 is a flagship GPU no matter which phone wraps it.
- A startup benchmark. Finally, a short real-work benchmark measures what the device actually does with the game's own shader. The measurement can promote or demote the guess — it settles every argument, because it is not an opinion.
The profile acts as a hint and a clamp, not a verdict: the benchmark decides inside the range the profile allows. That ordering matters. A benchmark alone can be fooled by a thermal spike or a background update; a profile alone is stale the day a new phone launches. Together they are boring and right, which is exactly what you want from infrastructure.
A quality ladder with a floor
At runtime the game walks a quality ladder — resolution scale, glow taps, particle counts, background detail. The adaptive controller watches frame pacing and steps down under sustained pressure, but every tier also carries a floor: a rung below which the game refuses to fall, because past that point degradation reads as brokenness rather than adaptation. A tier-1 phone keeps the liquid metaball identity (see the renderer entry) with reduced effects; a tier-5 phone gets everything and never wastes battery proving it.
Quality-first policy: the controller's job is not to hit 60 fps at any cost. It is to find the highest stable rung and stay there without oscillating. A game that flickers between pretty and plain feels worse than one that is honestly plain.
What shipped, measurably
- Five tiers covering the whole ecosystem, from entry Unisoc/Helio to Snapdragon 8-class and Tensor.
- A GPU classifier that recognizes the major mobile GPU families and their generations.
- Per-tier quality floors, so degraded never means unrecognizable.
- The benchmark hint/clamp integration, so real measurements refine — but never fully override — informed expectations.
The best compliment this system can receive is silence: players on wildly different hardware simply see "the game", each at the best version their device can honestly hold. Nobody chose a graphics preset, and nobody had to.
DOUBLE IT is playable free in the browser at doubleit.b-smart.xyz — more entries in the devlog.