Mindstride is a focused browser-based reading prototype built around RSVP reading: displaying text one
word or chunk
at a time so the reader can stay in a narrow attention lane instead of constantly scanning, scrolling,
losing place,
and restarting. The goal is not to magically “make people smarter.” The goal is to reduce reading
friction and give
the mind a steadier rhythm for consuming text.
Reading is not just about the words. It is about attention, motion, and fatigue.
Digital reading can be slowed by subvocalization, eye movement, scrolling fatigue, visual clutter,
and loss of focus.
A normal page asks the reader to manage many things at once: where the eyes are, where the next line
begins, how far
they have scrolled, what paragraph they were in, and whether they are still absorbing the material.
This is especially noticeable with dense articles, documentation, research notes, AI outputs, pasted
transcripts,
exported text, or long-form material that was not designed for comfortable reading. The user may
technically have the
information, but the interface makes it harder to move through it.
Mindstride treats reading as a workflow problem: reduce unnecessary movement, stabilize attention,
and let the user
control pace instead of being pulled around by the shape of the page.
The Solution
A controlled reading lane.
Mindstride displays text in a focused RSVP reading window. Instead of moving the eyes across a full
page, the user reads
one word or a small chunk at a time. The interface gives control over words per minute, chunk size,
and visual theme so
the reading experience can be tuned to the material.
The real value is rhythm. Once the text is cleaned, tokenized, and presented at a steady pace, the
user can stay with
the stream of meaning without constantly re-finding their place.
What It Does For The Mind
Less page management, more comprehension bandwidth.
Reduces eye travel across lines and paragraphs.
Creates a steady pacing mechanism for reading practice.
Helps prevent “where was I?” moments caused by scrolling and visual clutter.
Can support focus during long AI responses, documentation, notes, and research material.
Encourages adjustable reading speed instead of one fixed interface for every kind of text.
Key Features
Current and planned reading workflow features.
WPM ControlAdjustable words-per-minute pacing for different reading goals and difficulty
levels.
Chunk ControlSupport for one-word display or grouped chunks to test different reading rhythms.
Theme DirectionAccessibility-minded visual comfort, contrast, and reduced-distraction
presentation.
RSVP-style focused text display with WPM and chunk controls.
Designed to reduce eye movement and support focused reading practice.
Clean browser UI for quick text paste, playback, speed adjustment, and repeat use.
Planned or related concepts include EPUB support, CBR/comic reading experiments, web article
fetching, local session saving, persistent notes, and library-style workflows.
Demonstrates text-processing UI, productivity tooling, Flask/JavaScript prototyping, and
reading-interface experimentation.
Technical Implementation
How the browser reading pipeline works.
The implementation is intentionally lightweight: a Flask-served browser application with JavaScript
handling the
interactive reading loop. The app does not need a heavy database or complex backend to prove the
core interaction.
The important pieces are text intake, cleanup, tokenization, pacing, display state, and user
controls.
1
Text intakeUser provides pasted text, imported content, or future fetched article/book
text.
2
Text cleanupWhitespace, line breaks, repeated spacing, and formatting noise are normalized before
reading.
3
Tokenization and chunkingThe text is split into words or controlled chunks so the reader can choose pace and
density.
4
Timed playback loopJavaScript uses timing intervals derived from WPM to update the display
predictably.
5
Reader stateThe interface tracks current position, pause/play state, speed, chunk size, and
progress.
Implementation Notes
The core logic is small, but the experience depends on the details.
A speed reader can be built with a simple timer, but a useful speed reader needs the right controls.
WPM, chunk size,
pause/resume, restart, progress, typography, contrast, and input cleanup all matter. The tool needs
to feel predictable,
because unpredictable motion increases cognitive load instead of reducing it.
Core concepts:
- Flask route serves the browser app.
- JavaScript manages text state and reading playback.
- WPM determines delay between display updates.
- Chunk size determines how many tokens appear at once.
- CSS controls contrast, spacing, focus, and visual comfort.
- Future storage can preserve sessions, reading history, and notes.
- Future import tools can bring in EPUB, articles, transcripts, AI outputs, and documentation.
Use Cases
Where this kind of reader helps.
Long AI outputs that are hard to read in chat format.
Documentation and technical notes.
Research snippets collected from the web.
Writing drafts that need review without editing distractions.
Transcripts, exported notes, copied articles, and plain text archives.
Reading practice where pace and focus are more important than layout.
Future Direction
From prototype to reading workspace.
The larger direction is not just “speed reading.” It is a focused reading workspace for personal
knowledge. That could
include saved sessions, imported documents, notes, highlights, reading history, article extraction,
EPUB support,
and a library of material the user wants to move through over time.
A useful long-term version could connect with OCR tools, summarizers, personal notes, and local AI
systems so that text
can move from capture → cleanup → reading → notes → recall.
The same idea appears across TrelloTriage Labs: take messy information, reduce friction, and build a
small interface
that makes the next action easier. In this case, the messy input is text and the next action is focused
reading.