Desktop Typing Speed Test App with WPM Tracking and Accuracy Analytics (Python)

A desktop typing speed test app with WPM tracking and accuracy analytics is a Python desktop application that measures how fast and how accurately a user types a given passage. It presents a passage on screen, records every keystroke against the expected text, and converts the result into two headline numbers: words per minute and accuracy percentage. Many students type for hours every day — assignments, code, reports — yet never measure the skill, so weak keys and error habits go unnoticed for years. Existing browser typing tests need an internet connection, show advertising, and store results on someone else's server, which makes them awkward for classroom use and for a viva demonstration. A local desktop app solves this directly: it works fully offline, keeps all session history on the student's own machine, and exposes the scoring formula openly so every number on the results screen can be explained, reproduced, and defended.

The typing test app works end to end like this: the user picks a test duration, clicks the passage, and starts typing; the timer begins on the first keystroke and the app compares each keystroke with the expected character live. Correct keystrokes advance the progress count and feed the WPM calculation, while incorrect keystrokes are highlighted and counted against accuracy; backspace lets the user correct a mistake, and corrected errors still count in the raw keystroke total so the accuracy figure stays honest. When the timer reaches zero or the passage is finished, the app stops the test and computes the final numbers from the recorded counts: net WPM from correct characters only, raw WPM from all keystrokes, accuracy from correct divided by total keystrokes, and a consistency score from the error rate. The session is saved to the local history store, and the history view updates its trend bars alongside earlier sessions.

1. The user selects a test duration (30, 60 or 120 seconds) and a practice passage from the built-in library.
2. Clicking the passage focuses the input; the timer stays idle until the first keystroke, so preparation time never counts against the score.
3. Each keystroke is compared with the expected character at the current position and coloured correct or incorrect immediately.
4. Live stats update on every keystroke: current WPM from correct characters so far, running accuracy, time left and passage progress.
5. Backspace removes the last typed character so a mistake can be corrected, while the raw keystroke total keeps the original error on record.
6. When the timer reaches zero or the passage is complete, the test stops and the results screen is computed from the recorded counts.
7. The session is written to the local SQLite history store, and the history view refreshes its trend bars and top-session line.

Tech stack:

• Python 3
• Tkinter · desktop UI
• SQLite · local session history
• JSON passage library
• CSV · session history export
• PyInstaller · standalone executable

The app's core capabilities are live WPM and accuracy tracking, timed tests with selectable durations, and a local session history with per-session analytics. Live tracking updates speed and accuracy on every keystroke, so the user sees performance change in real time instead of waiting for a final score. Timed tests run for 30, 60 or 120 seconds, and the timer starts on the first keystroke, matching how real typing tests behave. After each test, a results screen reports net speed, raw speed, accuracy, consistency and a correct-versus-incorrect character breakdown. Every completed session is stored locally and shown in a history view with a WPM trend, so progress across days and weeks is visible without any account or internet connection. A first-principles scoring rule keeps the numbers honest: WPM equals correct characters divided by 5, divided by minutes elapsed.

• [Live WPM and accuracy tracking] Speed and accuracy update on every keystroke during the test, with correct characters shown in dark text and mistakes highlighted immediately. Implemented in the base build.
• [Timed tests with selectable durations] Tests run for 30, 60 or 120 seconds, and the timer starts on the first keystroke rather than on page load. Implemented in the base build.
• [Results breakdown screen] Each finished test reports net WPM, raw WPM, accuracy, a consistency score, and the counts of correct, incorrect and total keystrokes. Implemented in the base build.
• [Local session history and trend view] Every completed session is saved to a local SQLite store and shown in a history table with a WPM trend bar per session. Implemented in the base build.
• [Backspace correction with honest scoring] Backspace corrects a mistake, but corrected errors still count in the raw keystroke total, so accuracy cannot be inflated by retyping. Implemented in the base build.
• [Passage library and CSV export] Multiple built-in practice passages are included, and session history can be exported as a CSV file for the project report. Implemented in the base build.
• [Custom passages (optional customization)] Loading the user's own passages from a text file can be added on request; it is not part of the base build.
• [Per-key error heatmap (future scope)] A keyboard heatmap showing which keys produce the most errors is a possible extension, not included in the base build.

• Complete Python source code (Tkinter desktop app)
• Standalone packaged executable for the student's machine
• Built-in practice passage library (JSON)
• Local SQLite history store with schema documentation
• CSV export of session history
• Project report PDF (background, WPM mathematics, methodology, demo-run results)
• PPT presentation for final review
• Viva Q&A preparation document (WPM formula, accuracy definition, timer design, local storage)

Delivery timeline

• Requirement confirmation and passage selection: Approximately 1–2 working days.
• App build (typing engine, timer, results screen, history store): Approximately 4–5 working days.
• Documentation and viva kit (report, PPT, Q&A): Approximately 2–3 working days.
• Total delivery window: Approximately 1–2 weeks from confirmed requirements, subject to feedback rounds.

Support

• Setup help on the student's machine (Python environment or packaged executable) is included with delivery.
• Bug fixes for the delivered build are covered for 30 days after delivery.
• Small customizations (extra passages, duration options, colour theme) can be added on request after delivery.
• A walkthrough of the code and the WPM calculation is included so the student can explain the app in the viva.