I spent seven months trying to read faster without cheating

Velo is on the App Store. Here's the honest version of how it got built — including the parts that don't fit on a landing page.

Seven months ago I forked a small, MIT-licensed open-source project called rsvp-reading — a bare-bones web demo that flashes text one word at a time. It was a weekend-toy version of an idea I'd been circling for years: that a lot of the reading we do all day is slower than it needs to be, and not because we're bad at reading.

I didn't set out to spend seven months on it. But 1,374 commits later — sustained the whole way, 37 in January, 360 in the busiest month, still shipping in July — I have a native app for iPhone, iPad, and Mac that I actually use every day. This is the story of what I learned and what I got wrong.

Why RSVP is underrated — and where it genuinely fails

RSVP stands for Rapid Serial Visual Presentation. Instead of your eyes sweeping across lines, the words come to you, one at a time, at a fixed point on screen. The idea is old and the research is real: a huge amount of reading time is spent not on comprehension but on mechanics — the tiny eye jumps (saccades) between words, the constant hunt to find where the next line starts. Kill the eye movement and you free up attention for the actual meaning. (I wrote up what the research actually says about RSVP separately, including the parts that don't flatter it.)

There's a detail most apps skip. In each word, one letter is tinted red — the Optimal Recognition Point, the spot your eye naturally lands on to recognize a word fastest. Velo computes it per word and holds it locked to the same pixel, so your gaze never has to re-aim. That's the difference between a gimmick and something you can do for twenty minutes without a headache.

But I'm not going to pretend RSVP is magic, because the honest answer is that it fails at some things badly. It's wrong for a novel you want to savor. It's wrong for a dense technical passage where you need to stop, backtrack, and stare at the ceiling. Push the speed past about 800 words per minute on unfamiliar material and comprehension falls off a cliff — anyone who tells you otherwise is selling something.

Where RSVP genuinely shines is the middle category nobody markets: the reading that's important enough to have on your radar but not dense enough to deserve full attention. The backlog of 40 saved articles. The report you need the gist of. The book you're re-reading. For that — sufficient comprehension, not perfect recall — RSVP is a tool, not a trick. So Velo ships with a classic paginated reader right next to it, sharing one position. Hit pause at word 1,847 in flash mode, switch to the page view, and you're at word 1,847. Match the mode to the material. That's the whole philosophy.

The technical journey: web demo → native → platform

The fork was a web app, and for the first month I kept it a web app. Then I hit the wall every web-reading-app hits: the browser is a bad place to keep someone's library, their reading position, and a 40MB EPUB. So in February I did the pivot — wrapped it in Capacitor, wrote a native EPUB reader, and it stopped being a demo.

From there it snowballed into an actual platform. A dual PDF/EPUB pipeline that unifies wildly different file formats into one schema-validated content structure — chapters, paragraphs, footnotes, images — so both reading modes render from the same tree. That pipeline is most of the work; academic PDFs are much harder than they look, and two-column resequencing alone ate weeks. Cross-device sync so your position follows you. Then, in a single week in July, I brought a Mac app from a bare PDF-viewer prototype to full feature parity — a real native SwiftUI/SwiftData app, not a Catalyst port, sharing only the backend and the extraction engine.

Here's my favorite unglamorous war story from that stretch. RSVP sounds like it's just a setTimeout loop — show a word, wait, show the next. It is not. Constant-rate flashing feels robotic and comprehension suffers, because natural reading isn't constant-rate. A period deserves a beat. A comma deserves a half-beat. A fourteen-letter word needs more time on screen than "the," and it needs to shrink so the red focal letter stays put instead of jumping. Getting that pacing to feel human — so 400 words per minute reads like a comfortable voice and not a strobe light — was weeks of fiddling with per-word timing, not an afternoon. The stuff that looks trivial is where the craft hides.

Real on-device AI, not an API call

Velo analyzes what you read — summaries, key ideas, a "catch me up" recap for when you come back to a book after a fortnight. The obvious way to build that in 2026 is to POST your text to an API and bill you for tokens. I decided not to.

Instead the analysis runs on Apple's on-device foundation models, right on your phone. Two reasons. First, privacy: your books and your reading habits are nobody's business, and "on-device" isn't a marketing word here — the text never leaves your hardware. Second, economics: an on-device model has no per-request cost, which is the only honest way to give it away for free instead of quietly charging you for someone else's GPU.

It was harder. The on-device model has a hard input cap and will flatly refuse certain structured-output requests, so I had to probe its actual failure modes and build plain-prose fallbacks for when guided generation balks. But an app that works offline, costs nothing to run, and keeps your library private was worth the extra fight.

The same logic drove read-aloud. Velo's Listen mode uses the system speech engine on your device rather than a cloud voice. Cloud voices genuinely sound better — I'm not going to pretend otherwise — but the arithmetic is brutal once you're voicing books instead of articles. A typical book is about 480,000 characters, roughly forty times a blog post. At the going rate for the best cloud voices that's more per book than a month of subscription revenue, and a reader who listens to two books a month would cost me more than they pay. On-device is free, works on a plane, and never uploads the book. That trade felt obvious once I'd done the multiplication.

The unglamorous part: shipping it clean

The last stretch of any app is the part nobody blogs about — making it survive App Review. Two stories stand out.

Velo ran a live public TestFlight beta at the same time as the App Store submission, which is a great way to accidentally ship your debug console to reviewers. The safeguard is a build-channel system: a single flag drives which surfaces compile in, and the release build script physically refuses to archive unless a marker file says release. I don't trust that from the source, though — I trust it from the shipped binary. So I grepped the actual compiled bundle going to Apple and confirmed the beta modal, the debug console, and the test bridge were provably absent, not just believed absent.

The second: the very first real end-to-end release build archived fine and then failed at export, because the release signing lane was missing a code-signing block the beta lane already had. That's exactly the kind of thing that surfaces as a baffling failure during submission — unless you run it for real the night before, which is why I did. Fixed, re-verified with a clean upload. Along the way I also caught and fixed a genuine security bug — the backend wasn't verifying the signature on Apple's sign-in token, an account-takeover-class hole — and closed it once across all three platforms.

Verify, don't assume. That's the whole discipline.

What you get

Velo is live on the App Store for iPhone and iPad. The Mac build — native SwiftUI, not a Catalyst port — has cleared App Review and lands right behind it.

The free tier is meant to be genuinely useful, not a demo: all three reading modes, adjustable speed, three of your own PDFs or EPUBs, an unlimited shelf of public-domain classics — and the on-device AI analysis, because it runs on your hardware and costs me nothing to give you. Pro unlocks the unlimited personal library, cross-device cloud sync, and the heavy server-side document processing for the really ugly academic PDFs, with a 7-day free trial.

Velo reads DRM-free EPUBs and PDFs — the ones you own outright. If you're not sure where to find those, I put together a guide to DRM-free ebook sources that's useful whether or not you ever install this. And if you're weighing it against what you already use, there's an honest comparison table that says plainly where the competition wins — plus a longer Velo vs Readwise Reader breakdown, since that's the comparison people ask about most.

No hype — just a reading app built by someone who wanted it to exist.

— Ben

← More writing & guides