RapidBench app icon RapidBench Get the beta

How it works Score version 1.0 · every step, in plain words

What happens when you tap Run.

RapidBench gives your iPhone four real AI jobs, exactly the same on every phone, and turns how fast it gets through them into one score. This page walks through what happens: what it downloads, what each test does and times, how times become points, and why heat changes everything. Plain words first, with the numbers alongside for anyone who wants them.

  1. 01The short version
  2. 02Before the first run
  3. 03The four tests
  4. 04From stopwatch to points
  5. 05Heat
  6. 06Fair by design
  7. 07Your results
  8. 08Questions

One tap, five steps.

About five minutes on an iPhone 18 Pro, plus a one-time download.

  1. 1
    Download the models

    Three AI models, about 6.4 GB in all, come down once and stay on your phone. A fourth is built into the app.

  2. 2
    Make sure the phone is cool

    A phone that’s already hot is slower before anything starts, so RapidBench waits up to five minutes for it to cool down.

  3. 3
    Run four tests, always in the same order

    Sharpen a photo on the Neural Engine, solve math problems with a language model, teach a model something new, and paint three pictures.

  4. 4
    Turn the times into points

    Every timing is compared with an iPhone 18 Pro, which scores 5,000. Twice as fast scores twice as much.

  5. 5
    Save it, share it, compare it

    The run is saved on your phone as a report. If you like, your score goes to Game Center, where phones are ranked against each other.

First, the models.

Real models, not tiny stand-ins. That’s what makes the numbers mean something.

RapidBench runs the same kind of AI models apps actually ship, so the first run starts with a download. It’s about 6.4 GB, and you only do it once:

Gemma 4 E2BGoogle’s small language model · Inference test
22 GB
Bonsai ImageFLUX.2 [klein] 4B, ternary · Image test
38 GB
Qwen3 0.6BAlibaba’s small language model · Training test
351 MB
EDSRPhoto super-resolution · Neural Engine test
3 MB · built in

The downloads run in the background, so you can lock the phone or switch apps. A Live Activity follows them in the Dynamic Island and on the Lock Screen, and tells you when they’re ready. If the Wi-Fi drops, they pick up where they left off. The models are kept out of your iCloud backup, and you can delete any of them from Home → Models. Wi-Fi is a good idea.

Then, a cool phone.

A phone that’s already warm from a game, a long video call or a sunny windowsill is slower before the test even begins. So if iOS reports that the phone is hot (the thermal state called serious), RapidBench waits up to five minutes for it to cool down. In a hurry? There’s a Skip button, and the run starts anyway.

And keep it on screen.

Once it starts, leave RapidBench open. iOS doesn’t give the graphics chip to apps in the background, so the full benchmark stops if you switch away. On an iPhone 18 Pro it takes about five minutes. Each test’s score counts up on screen as it finishes, and the whole thing ends back on Home with your number and a little confetti.

Four jobs, in this order.

Each test is a real AI workload you’d recognize: sharpening a photo, answering questions, learning something new and painting a picture. Each one times two or three things, and each timing has a weight that says how much it counts. Three of the tests also check that the work came out right.

01 Neural Engine Runs first

Sharpens a photo on every engine the chip has.

The Neural Engine is the part of the chip built only for AI. Your iPhone leans on it for photo processing, Face ID and on-device models, and it does that work fast while using very little power. This test gives it a job it was made for: making a photo bigger and sharper.

The photo is a 1024 × 1024 shot of a harbor, cut into 25 overlapping squares so the joins never show. A small model called EDSR doubles each square in size and fills in detail that a plain resize can’t.

One lane, then two

The squares go down one lane first, then two lanes at once. A single Neural Engine takes one job at a time, so on most chips the second lane just waits its turn. The A20 Pro in the iPhone 18 Pro has two Neural Engines, so both lanes run together: 145 squares a second instead of 85. Then the same work runs on the graphics chip (GPU) and the main processor (CPU), so you can see what the Neural Engine is really worth.

Why it goes first

After a few minutes of hard GPU work, every part of the chip slows to about half speed, and the second engine’s advantage disappears completely. So this test runs while the phone is still cool. It uses Apple’s Core AI, which needs iOS 27.

02 Inference

Solves twenty math problems, showing its work.

This is the chatbot test. Gemma 4 E2B, a small language model from Google, answers the first 20 word problems from GSM8K, a set of grade-school math questions researchers use to check whether a model can reason step by step. It writes out its working, then the answer.

Language models write one token at a time. A token is a chunk of a word, often three or four letters, so tokens per second is simply how fast the model writes. Every phone writes the same answers word for word: the model always picks its single most likely next token, and stops at 512 tokens.

Speed, measured twice

Writing speed is timed on the first five problems and again on the last five. On the reference iPhone 18 Pro it starts at about 86 tokens a second and, once the chip is warm, settles near 40. Timing both ends means a phone that keeps its pace scores better than one that only sprints. The third timing is how long you wait for the first word: about a tenth of a second.

Getting it right

The answers are checked too. The reference phone gets 16 of the 20 right, the same 16 the model gets on a Mac. A phone that gets fewer right loses points in proportion: 12 of 20 multiplies the score by 0.75.

Squeezed to fit

Gemma is stored as a compact mix of 2-bit and 4-bit numbers, 2.2 GB in all. On first use, RapidBench rewrites it into a form Apple’s MLX can run, on the phone, in about two seconds.

03 Training

Teaches a model something new, right on the phone.

Running a model is one thing. Teaching it is much harder work, and almost no benchmark tries it on a phone. Here the phone fine-tunes Qwen3 0.6B, a small language model from Alibaba, to turn plain questions into SQL, the language databases speak. It learns from 500 examples in WikiSQL, a dataset of questions paired with the right query.

How it learns

Retraining every part of a model would take far more memory than a phone has. So it uses QLoRA: the model stays frozen and compressed to 4 bits, and small add-on layers on its last 16 layers do the learning. It takes 150 steps of four examples each, from a fixed starting point, so every phone does exactly the same work.

Before and after

Before training, the model is asked three everyday questions it never trains on: the capital of Japan, who directed Inception, and how long a day is on Mars. It’s asked again at the end, so you can watch it go from rambling to a clean SQL query. The app also measures the validation loss, a number for how wrong the model still is on examples it didn’t train on. On the reference phone it falls from 3.25 to 1.24.

What counts

How many training steps the phone gets through each second, and the total time including loading the model and the before-and-after checks. Finishing with a worse loss than the reference lowers the score.

04 Image

Paints three pictures from a sentence.

The last test is text to image. Bonsai Image is Black Forest Labs’ FLUX.2 [klein], squeezed by PrismML so that every weight is just −1, 0 or +1. It paints three 512 × 512 pictures: a bonsai tree, a fox asleep in the snow and a neon city in the rain.

Each picture starts as random noise and gets cleaned up in four steps. The prompts and the random seeds are fixed, so every phone paints the same three pictures.

Four billion parameters in your pocket

The model has three parts: a text encoder that reads the prompt, a transformer that does the painting, and a decoder that turns the result into pixels. They load one at a time, so the whole thing peaks at about 3 GB of memory. While it works, the app shows the model’s own guess at the finished picture after every step, getting sharper each time.

What counts

Pictures per minute, worked out from the middle (median) picture so one slow start doesn’t skew it, and denoising steps per second. On the reference phone a picture takes about 16.6 seconds.

From stopwatch to points.

An iPhone 18 Pro scores 5,000. Everything else is measured against it.

Every timing a test takes is compared with the same timing on an iPhone 18 Pro. Match it and that timing is worth 5,000 points. Twice as fast is worth 10,000; half as fast, 2,500. Points grow in a straight line with speed and there’s no ceiling, so next year’s phones have room to show off.

Why a real phone? A score only means something next to another score, so we pegged the scale to a phone you can picture. Every reference number on this site was measured on it.

One score per test

Each test’s timings are blended by their weights with a geometric mean. It’s the fair way to average speed-ups: doubling one timing and halving another leaves you exactly where you started, and no single timing can carry a test on its own.

Quality can only take points away

Speed is what earns points. But a phone that’s fast because it gets things wrong shouldn’t win, so three of the tests also check their output: are the math answers right, did the model actually learn, is the photo actually sharper. Match the reference and nothing changes. Fall short and the score drops in proportion, but never below half. Doing better than the reference never adds points.

One number overall

The overall score is the geometric mean of the four test scores, so every test counts the same, and being twice as fast at any one of them is worth the same.

Worked example

A phone that’s 20% faster than an iPhone 18 Pro at three tests and 10% slower at pictures:

6,000Neural Engine 6,000Inference 6,000Training 4,500Image 5,584Overall

Memory and heat sit beside it

Peak memory, and how much speed a phone keeps once it’s warm, are shown as badges next to the score rather than mixed into it. They matter, and folding them into one number would hide them.

Reports keep the raw measurements, not just the points, so if the reference ever changes, old runs are simply rescored. Scores only compare within a score version. This is version 1.0.

Hot phones are slow phones.

Every phone does it. The question is how much.

Push a chip hard and it heats up. To protect the battery and your hand, iOS then slows it down. It’s normal, every phone does it, and it’s a big part of how fast a phone really is when you use it for more than a few seconds.

On the reference iPhone 18 Pro, Gemma writes about 86 tokens a second for its first eleven answers. Then the heat catches up and it settles around 40, less than half. Run the Neural Engine test after minutes of GPU work and it halves too.

What RapidBench does about it

  • Runs the Neural Engine test first, while the chip is still cool.
  • Waits up to five minutes if the phone starts out hot.
  • Times the first five math problems and the last five separately, so keeping your pace is rewarded.
  • Shows how much speed holds (the last five ÷ the first five) as a badge beside the score.
  • Shows iOS’s thermal state (nominal, fair, serious or critical) in the header of every tab while it runs.

The reference numbers came from a phone charging over USB, which runs a little hotter than on battery.

Watch a hot chip and a cool one side by side

Nothing bends to fit a phone.

So the only thing left to compare is the chip.

A benchmark is only useful if every phone does exactly the same work. So nothing in RapidBench changes from one phone to the next:

  • 4models, the same files at the same settings
  • 20math problems, answered the same way, up to 512 tokens
  • 500training rows, 150 steps, one fixed starting point
  • 3prompts with fixed seeds, 4 steps each, at 512 × 512
  • 25tiles of the same 1024 × 1024 photo
  • 1order: Neural Engine, Inference, Training, Image

Nothing leaves your phone

Everything runs on the phone itself. Nothing you type, no picture it paints and no report is sent anywhere. After the download it works in airplane mode. The only thing that ever leaves is your score, and only if you’re signed in to Game Center.

What it doesn’t measure

RapidBench measures AI and nothing else. It doesn’t test battery life, games, the camera or how fast apps open. A phone can be great at those and middling here, or the other way round.

Yours to keep, and to compare.

Saved on your phone. Shared only if you want.

Every finished run is saved on your phone as a report: every number it measured, the three pictures it painted and the sharpened photo. The Leaderboard ranks your best full runs and your best score on each test, the gallery keeps every picture, and you can delete any report you don’t want.

Share score makes a card with your score, your phone and chip, and where it ranks, sized for Messages or Instagram.

Game Center, if you want it

Sign in to Game Center and your scores go to five leaderboards: overall, plus one for each test. Each score carries the phone that made it (its model, chip, memory and iOS version), so RapidBench can rank phone models against each other: every phone in the top 500 scores, ranked by its owners’ median. Not signed in? Nothing leaves the phone.

Questions.

How long does it take?

About five minutes on an iPhone 18 Pro, plus the one-time download. Slower phones take longer, which is rather the point.

Which iPhones and iPads can run it?

RapidBench runs on iPhone and iPad with iOS 18 or later. The Neural Engine test uses Apple’s Core AI, so it needs iOS 27. The models are big, so older devices with less memory may struggle with some tests.

Can I run just one test?

Yes. Each test has its own tab. A single test gets its own score, and with Game Center on it counts toward that test’s leaderboard. The overall score only comes from a full benchmark.

Does it need the internet?

Only to download the models, and for Game Center if you use it. The tests themselves run fully offline.

Can I use my phone while it runs?

Not during the full benchmark. Keep RapidBench on screen or it stops, because iOS doesn’t let apps use the graphics chip in the background.

Is it bad for my phone?

No more than a demanding game. It works the chip hard for a few minutes, iOS manages the heat as it always does, and RapidBench waits for a hot phone to cool before it starts.

Why did I get a different score this time?

Heat, mostly. A phone that’s warm, charging, in a thick case or in the sun runs slower. Background work, like a photo library sync, can take a little time too. Run it again once the phone is cool; the Leaderboard keeps your best.

What’s a token?

A chunk of a word, often three or four letters. Language models write one token at a time, so tokens per second is how fast they write. A typical English word is a little over one token.

What’s QLoRA?

A way to fine-tune a model cheaply. The model’s own weights stay frozen and compressed to 4 bits, and small extra layers learn the new skill. It’s how you teach a model something new on a phone without running out of memory.

Why these models?

They’re real, current open models of the kind apps actually ship: a small language model from Google (Gemma 4), one small enough to fine-tune on a phone (Qwen3), a state-of-the-art image model shrunk to fit (Bonsai Image, built on FLUX.2 [klein]) and a classic photo super-resolution network (EDSR).

Put your iPhone on the bench.

RapidBench is in beta on TestFlight. Drop your email and get the TestFlight link!

Get the beta