The Benchy Regatta

What SailfishOS phones and tablets score in Benchymark, from runs people posted in the forum thread. Every boat counts. Higher is better in every column.

4 runs from 2 people on 4 devices. Only runs of Benchymark 2.2 and later are listed: 2.2 changed how every graphics stage measures, so older scores do not compare. To add yours, post the run's JSON file in the thread.

Device	Benchy large boats/s	Benchy small boats/s	Benchy glow Mpx/s	Shader light Mpx/s	Shader heavy Mpx/s	Table from UBO M reads/s	Table from SSBO M reads/s	Table from texture M reads/s	Overdraw layers/s	Cascade squares/s	Icon storm icons/s	CPU prime events/s	CPU single core events/s	Memory throughput MB/s	One million M/s	Storage R/W MB/s	User	GPU	OS	Arch	Date	Peak °C
Jolla C2	1000	2361	38.6	48.0	8.6	414	415	978	929	87583	29264	9819	1710	638	266.67	26/24	mosen	Mali-G57	5.1	arm64	2026-10-19	42
Sony Xperia XA2 - Dual SIM	12499	13226	45.7	50.5	17.4	635	615	639	2284	94114	17222	9653	1365	1523	52.08	45/17	mosen	Adreno (TM) 508	4.4	arm	2026-10-19	41
Jolla Phone (2026)	9616	19001	268	253	42.4	2156	2444	3904	7328	558795	102429	16175	2872	6217	298.81	46/40	ahjolinna	Mali-G610 MC2	5.2	arm64	2026-10-19	53
Jolla Tablet	2326	5077	19.6	30.2	7.3	326	–	147	756	87595	17102	1297	359	923	287.36	–	mosen	Intel(R) HD Graphics for BayTrail	4.6	i386	2026-10-19	59

Click a column to sort it, highest first. By default each person's newest run per device is shown. ~ noisy: the two halves of the measurement differ by more than 10 %. * stopped early. A dash means the stage was not run; on a desktop, hover it for the reason.

Reading the scores

Every graphics stage draws the same fixed work on a 720 × 1600 canvas, off screen, as fast as the device can. That is drawing throughput under full load, CPU and GPU together, not the frame rate an app gets on screen.

A throttled run is a real result, but its CPU-heavy scores are lower bounds. One million depends on the package's architecture, so compare it only within one.

What each stage counts

Benchy large (boats/s): Boats drawn per second: two large 3DBenchy wireframes, each drawn many times. Shows how fast the phone turns 3D lines into a picture, the CPU projecting every line and the GPU drawing it.
Benchy small (boats/s): Boats drawn per second: six small wireframes, half the lines' length each. Next to Benchy large it tells what holds the phone back: alike, the CPU; far ahead here, drawing the lines.
Benchy glow (Mpx/s): Megapixels blurred per second: two golden halos over the whole picture. Shows how well the GPU handles soft effects, like the blurs and glows of the interface.
Shader light (Mpx/s): Megapixels of noise field per second: a moving cloud computed for every pixel. Shows the GPU's raw arithmetic, as animated backgrounds and wallpapers use it.
Shader heavy (Mpx/s): Megapixels of warped field per second: the cloud warped twice, many times the math per pixel. Shows how the GPU copes with really heavy shaders, as games use them.
Table from UBO (M reads/s): Million table reads per second, the table in a uniform buffer. Shows how fast the GPU looks up data while it draws; next to the other two table stages, which way suits this GPU. Needs OpenGL ES 3.0.
Table from SSBO (M reads/s): Million table reads per second, the table in a storage buffer. The way newer graphics code hands large data to the GPU; compare with the other two table stages. Needs OpenGL ES 3.1 and a driver that allows it in fragment shaders.
Table from texture (M reads/s): Million table reads per second, the table in a texture. The classic way to hand data to the GPU, and the baseline for the two buffers. Needs OpenGL ES 3.0.
Overdraw (layers/s): Translucent layers blended per second, each covering much of the screen. Shows the fill rate: how often per second the GPU can paint over the screen, what stacked windows and transparent effects cost.
Cascade (squares/s): Squares moved per second, rounded and smoothed, in two rings that scale and turn. Shows how many moving elements the interface engine (Qt Quick) handles, CPU and GPU together.
Icon storm (icons/s): Icons drawn per second, each placed anew every frame on spiral arms. Shows how a busy interface with many small moving images runs; this leans on the CPU.
CPU prime (events/s): Prime counts per second on all cores, sysbench's classic test; every count lights a cell of the spiral if its number is prime. Shows the processor's total power, what installs, compression and many apps at once lean on.
CPU single core (events/s): Prime counts per second on one core. Shows how fast a single task runs, what most apps and the interface depend on; next to the all-core score, how much the other cores add.
Memory throughput (MB/s): Megabytes copied per second between two large buffers. Shows how fast the phone moves data in its memory, what large images, video and app starts depend on.
One million (M/s): Million steps per second of a JavaScript counting loop. Shows how fast the app's script engine runs plain code; the logic of SailfishOS apps runs in this engine.
Storage R/W (MB/s): Megabytes per second written and read in small blocks past the cache. Shows how fast the flash itself stores and loads, what installs, updates and app starts depend on. Off by default: it wears the flash a little every run.