RecallFlow

Turn your notes into grounded, local-first active-recall practice.

Comment

Inspiration

I’ve always learned faster by working through practice tests at home. Test books made studying active: they exposed gaps in my understanding, provided immediate feedback, and helped me focus on what I had not mastered yet. I also didn’t want to pay for yet another app subscription. I wanted a tool I could run locally, without an account or recurring platform fee, and pay only for the AI API usage I explicitly choose to trigger. RecallFlow was inspired by both of these needs. I wanted to recreate the structure and focus of a practice-test book while giving learners control over their data, study experience, and AI costs.

What it does?

RecallFlow transforms study material into interactive active-recall sessions.

Users can:

  • Import a validated JSON quiz.
  • Generate a quiz from pasted material or a public webpage using AI.
  • Answer single-choice, multiple-choice, and true-or-false questions.
  • Receive immediate feedback and explanations.
  • Review results and track previous attempts.
  • Start a repair session containing only the questions they missed.
  • Generate and save an optional mnemonic after an incorrect answer.

RecallFlow is local-first. Quizzes, attempts, and mnemonics are stored on the learner’s device, and no RecallFlow account or hosted backend is required. AI is optional, and study material leaves the device only when the learner explicitly starts a generation action.

How we built it?

built the interface with React and TypeScript and packaged it as a cross-platform desktop application using Tauri 2.

The Rust backend owns the application’s security-sensitive operations. It communicates with SQLite through SQLx, stores API keys in the operating system’s credential manager, and makes explicit requests to the OpenAI Responses API. The frontend never receives a stored API key. For AI-generated quizzes, I built a multi-stage grounding pipeline rather than relying on a single prompt.

RecallFlow:

  1. Splits large source material into bounded regions.
  2. Generates candidate questions from each region.
  3. Resolves each candidate against exact source evidence.
  4. Independently checks grounding, clarity, and preserved qualifications.
  5. Rejects ambiguous or unsupported questions.
  6. Removes duplicates and selects questions across different source regions.

Generated quizzes remain drafts until the learner reviews and saves them.

I also created a browser preview using the same React interface. It uses local browser storage and deliberately excludes desktop-only features such as SQLite, credential access, and AI requests.

Challenges we ran into?

My biggest challenge was reducing hallucinations and preventing unsupported questions from reaching the learner.

Prompting alone was not enough. A model could return valid JSON while still introducing a subtle generalization, losing an important qualification, or creating a distractor that was also defensible from the source.

I addressed this by treating generation as a verification pipeline. Every candidate must pass evidence resolution, independent grounding checks, schema validation, ambiguity checks, and duplicate removal. A central product decision was to return fewer questions—or no questions—rather than fill a requested quota with weak content.

Another challenge was supporting both a native desktop application and a browser demo while keeping their storage and security boundaries clear. I created separate runtime adapters so the browser preview cannot accidentally invoke desktop storage, credentials, or provider APIs.

Accomplishments that we're proud of?

Building a complete learning loop from import or generation through practice, feedback, review, progress tracking, and focused repair.

Creating a fail-closed generation pipeline that prioritizes trustworthy questions over question count. Adding AI-powered mnemonic generation that helps learners remember the correct answer after a mistake, with the option to save the mnemonic for future sessions.

Keeping the core study experience local-first and usable without an account, backend, or AI provider. Storing provider credentials in the operating system’s secure credential manager instead of exposing them to the web interface.

Supporting three question formats with immediate explanations and keyboard-friendly controls. Creating a live browser demo that judges can try without installing the desktop application. Building deterministic automated checks with mocked provider responses, so tests never require real credentials or upload private study material.

What we learned?

I learned that trustworthy AI generation is a systems problem, not simply a prompting problem. Source segmentation, evidence binding, independent verification, deterministic validation, deduplication, and human review all matter.

I also learned that failure can be a useful product outcome. Returning fewer questions with a clear explanation is better than presenting polished but unsupported content.

Finally, building with Tauri taught me how to create a narrow boundary between a web-based interface and native capabilities. Moving persistence, credentials, and network requests into Rust helped me create a clearer and safer architecture.

What's next for RecallFlow?

Next, I want to:

  • Formalize RecallFlow as an open-source project and welcome community contributions.
  • Support additional source formats such as PDF and Markdown.
  • Display clearer source evidence for generated questions.
  • Add spaced-repetition scheduling and more adaptive repair sessions.
  • Explore additional AI providers and optional on-device models.
  • Add portable backup and export tools while preserving the local-first design.
  • Publish signed installers for macOS, Windows, and Linux.

My long-term goal is to build RecallFlow openly with the community and make it a private study companion that turns personal learning material into reliable, focused practice without taking control away from the learner.

Built With

Share this project:

Updates