Upload 12 files

.gitignore

@@ -0,0 +1,26 @@
+# Rust build artifacts
+target/
+
+# Compiled executables
+*.exe
+
+# Editor configs
+.vscode/
+*.code-workspace
+
+# OS files
+Thumbs.db
+desktop.ini
+
+# AutoHotkey backups
+*.ahk~
+
+# Runtime user data
+data/user_words.txt
+
+# Large generated data (misspelling-generator output)
+data/misspellings.txt
+
+# Legacy reference modules
+lib/
+misspelling-generator/

Cargo.lock

@@ -0,0 +1,173 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocorrect-type"
+version = "1.0.0"
+dependencies = [
+ "windows",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "windows"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd04d41d93c4992d421894c18c8b43496aa748dd4c081bac0dc93eb0489272b6"
+dependencies = [
+ "windows-core",
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ba6d44ec8c2591c134257ce647b7ea6b20335bf6379a27dac5f1641fcf59f99"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-result",
+ "windows-strings",
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bbd5b46c938e506ecbce286b6628a02171d56153ba733b6c741fc627ec9579b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.58.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053c4c462dc91d3b1504c6fe5a726dd15e216ba718e84a0e46a88fbe5ded3515"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-result"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d1043d8214f791817bab27572aaa8af63732e11bf84aa21a45a78d6c317ae0e"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd9b125c486025df0eabcb585e62173c6c9eddcec5d117d3b6e8c30e2ee4d10"
+dependencies = [
+ "windows-result",
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"

Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "autocorrect-type"
+version = "1.0.0"
+edition = "2021"
+authors = ["Rembrant Oyangoren Albeos"]
+description = "System-wide autocorrect engine for Windows"
+license = "MIT"
+
+[dependencies]
+windows = { version = "0.58", features = [
+    "Win32_Foundation",
+    "Win32_Graphics_Gdi",
+    "Win32_System_LibraryLoader",
+    "Win32_UI_WindowsAndMessaging",
+    "Win32_UI_Input_KeyboardAndMouse",
+    "Win32_UI_Shell",
+] }
+
+[profile.release]
+opt-level = 3
+lto = true
+strip = true
+panic = "abort"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rembrant Oyangoren Albeos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,144 @@
+# Autocorrect-Type
+
+![License](https://img.shields.io/github/license/not-algorembrant/autocorrect-type)
+![Repo Size](https://img.shields.io/github/repo-size/not-algorembrant/autocorrect-type)
+![Last Commit](https://img.shields.io/github/last-commit/not-algorembrant/autocorrect-type)
+![Rust](https://img.shields.io/badge/Rust-5-dea584)
+![Markdown](https://img.shields.io/badge/Markdown-2-083fa1)
+![TOML](https://img.shields.io/badge/TOML-1-9c4121)
+
+System-wide autocorrect for Windows. Runs silently in the background and fixes misspelled words as you type -- in any application (terminal, browser, Discord, search bar, etc.).
+
+Built with Rust + Windows API. No external APIs, no cloud dependencies, no AI -- fully offline and native.
+
+Handles 466k English words sourced from [english-words](https://github.com/dwyl/english-words).
+You can download the misspelling datasets [here](https://huggingface.co/datasets/algorembrant/generated-misspelling-words) and make sure to rename the file into `misspellings.txt` and place it on `*\data\` folder path.
+
+## Features
+
+- **System-wide** -- works in any text input across your entire system
+- **500+ common misspellings** -- instant, high-confidence corrections (e.g. `teh` -> `the`)
+- **Smart spell checking** -- edit-distance algorithm catches unknown typos against a 466k-word dictionary
+- **Clipboard-based replacement** -- corrections happen instantly, no visible cursor movement
+- **Case-preserving** -- respects your capitalization (`TEH` -> `THE`, `Teh` -> `The`)
+- **System tray** -- toggle on/off, runs silently in background
+- **Lightweight** -- single `.exe`, no runtime dependencies, tiny memory footprint
+
+## System Overview
+
+```mermaid
+graph TD
+    A[Keyboard Input] -->|WH_KEYBOARD_LL| B[hook.rs]
+    B -->|Word buffer| C{Trigger key?}
+    C -->|No| B
+    C -->|Yes| D[spellcheck.rs]
+    D -->|Known misspelling| E[Misspellings DB]
+    D -->|Unknown word| F[Edit-Distance Engine]
+    F -->|Match found| G[Dictionary - 466k words]
+    E --> H[replacer.rs]
+    G --> H
+    H -->|Clipboard swap| I[Corrected Text]
+    J[tray.rs] -->|Toggle / Exit| B
+    K[main.rs] -->|Init| B
+    K -->|Init| D
+    K -->|Init| J
+```
+
+## Requirements
+
+### To run the compiled `.exe`
+
+- Windows 10/11
+
+### To build from source
+
+- [Rust toolchain](https://rustup.rs/) (stable)
+
+## Build
+
+```bash
+cargo build --release
+```
+
+The binary will be at `target/release/autocorrect-type.exe`.
+
+## Usage
+
+### Run
+
+Double-click `autocorrect-type.exe` or run from terminal. The app appears in the system tray.
+
+```bash
+# if it didnt open then
+cargo run --release
+```
+
+### Controls
+
+| Action | How |
+|---|---|
+| Toggle ON/OFF | `Ctrl + Alt + A` or right-click tray icon |
+| Exit | Right-click tray -> "Exit" |
+
+### How it works
+
+1. Type normally in any application
+2. When you press **Space**, **Enter**, **Tab**, or punctuation, the app checks the word you just typed
+3. If it is a known misspelling or a close match to a dictionary word, it is instantly replaced via the clipboard (no cursor flicker)
+4. A small balloon notification shows the correction briefly
+
+## How the correction works (no cursor flicker)
+
+Unlike typical autocorrect tools that backspace and retype characters visibly, this engine uses a clipboard-based approach:
+
+1. Saves current clipboard contents
+2. Sends backspaces to delete the misspelled word
+3. Copies the correction to the clipboard
+4. Simulates `Ctrl+V` to paste instantly
+5. Restores the original clipboard
+
+This makes corrections appear instantaneous with no visible cursor movement.
+
+## Customization
+
+### Add words to the dictionary
+
+Add words to `data/user_words.txt` (one per line, auto-created next to the `.exe`). Restart the app after editing.
+
+### Expand the misspellings database
+
+Edit `data/misspellings.txt`. Format: `misspelling=correction`, one per line. Lines starting with `#` are comments. The file is embedded at compile time.
+
+## Project Structure
+
+```text
+autocorrect-type/
+├── Cargo.toml
+├── Cargo.lock
+├── LICENSE
+├── README.md
+├── .gitignore
+├── src/
+|   ├── main.rs
+|   ├── hook.rs
+|   ├── spellcheck.rs
+|   ├── replacer.rs
+|   └── tray.rs
+└── data/
+    ├── words.txt
+    └── misspellings.txt
+```
+
+## Citation
+
+```bibtex
+@software{autocorrect_type,
+  author     = {Rembrant Oyangoren Albeos},
+  title      = {Autocorrect-Type},
+  year       = {2026},
+  publisher  = {Hugging Face},
+  url        = {https://huggingface.co/algorembrant/autocorrect-type}
+}
+```
+
+

STACKS.md

@@ -0,0 +1,71 @@
+## Description
+
+Autocorrect-Type is a system-wide, offline autocorrect engine for Windows built entirely in Rust with the Windows API. It intercepts keyboard input at the OS level via a low-level keyboard hook (`WH_KEYBOARD_LL`), buffers typed characters into words, and upon encountering a trigger key (Space, Enter, Tab, or punctuation) checks the completed word against a 466k-entry English dictionary and a curated misspellings database. Corrections are applied instantly using a clipboard-based swap strategy that avoids visible cursor movement or flicker. The application runs silently in the system tray with hotkey toggling, requires no external APIs or cloud services, and ships as a single lightweight `.exe`.
+
+## System Overview
+
+```mermaid
+graph TD
+    A[Keyboard Input] -->|WH_KEYBOARD_LL| B[hook.rs]
+    B -->|Word buffer| C{Trigger key?}
+    C -->|No| B
+    C -->|Yes| D[spellcheck.rs]
+    D -->|Known misspelling| E[Misspellings DB]
+    D -->|Unknown word| F[Edit-Distance Engine]
+    F -->|Match found| G[Dictionary - 466k words]
+    E --> H[replacer.rs]
+    G --> H
+    H -->|Clipboard swap| I[Corrected Text]
+    J[tray.rs] -->|Toggle / Exit| B
+    K[main.rs] -->|Init| B
+    K -->|Init| D
+    K -->|Init| J
+```
+
+## Project Structure
+
+```text
+autocorrect-type/
+├── Cargo.toml
+├── Cargo.lock
+├── LICENSE
+├── README.md
+├── STACKS.md
+├── .gitignore
+├── src/
+|   ├── main.rs
+|   ├── hook.rs
+|   ├── spellcheck.rs
+|   ├── replacer.rs
+|   └── tray.rs
+└── data/
+    ├── words.txt
+    └── misspellings.txt
+```
+
+## Techstack
+
+Audit of project files (excluding build artifacts and legacy references):
+
+| File Type | Count | Size (KB) |
+| :--- | :--- | :--- |
+| Rust (.rs) | 5 | 26.3 |
+| Text (.txt) | 2 | 571,065.0 |
+| Markdown (.md) | 3 | 12.5 |
+| TOML (.toml) | 1 | 0.5 |
+| Lock (.lock) | 1 | 4.6 |
+| License | 1 | 1.1 |
+| Gitignore (.gitignore) | 1 | 0.2 |
+
+**Total Files**: 14
+
+## Dependencies
+
+- **Rust**:
+  - `windows` (0.58): Win32 Foundation, Graphics GDI, System LibraryLoader, UI WindowsAndMessaging, UI Input KeyboardAndMouse, UI Shell
+
+## Applications
+
+- Google Antigravity
+- Visual Studio Code
+- Windows PowerShell

src/hook.rs

@@ -0,0 +1,193 @@
+// ---------------------------------------------------------------------------
+//  hook.rs — Low-level keyboard hook (WH_KEYBOARD_LL)
+// ---------------------------------------------------------------------------
+
+use crate::{CHECKER, CORRECTING, ENABLED, PENDING, WORD_BUFFER, TriggerKind};
+use std::sync::atomic::Ordering;
+use windows::Win32::Foundation::*;
+use windows::Win32::System::LibraryLoader::GetModuleHandleW;
+use windows::Win32::UI::Input::KeyboardAndMouse::*;
+use windows::Win32::UI::WindowsAndMessaging::*;
+
+/// Custom message posted when a correction is ready
+pub const WM_DO_CORRECTION: u32 = WM_APP + 1;
+
+static mut HOOK: HHOOK = HHOOK(std::ptr::null_mut());
+
+// ---- public API -----------------------------------------------------------
+
+/// Install the global keyboard hook on the current thread.
+pub fn install() {
+    unsafe {
+        let hmod = GetModuleHandleW(None).unwrap_or_default();
+        HOOK = SetWindowsHookExW(WH_KEYBOARD_LL, Some(ll_keyboard_proc), hmod, 0)
+            .expect("SetWindowsHookExW failed");
+    }
+}
+
+/// Pump the Windows message loop (blocks until WM_QUIT).
+pub fn message_loop(_hwnd: HWND) {
+    let mut msg = MSG::default();
+    unsafe {
+        while GetMessageW(&mut msg, HWND::default(), 0, 0).as_bool() {
+            let _ = TranslateMessage(&msg);
+            DispatchMessageW(&msg);
+        }
+    }
+}
+
+// ---- hook callback --------------------------------------------------------
+
+unsafe extern "system" fn ll_keyboard_proc(
+    code: i32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    if code < 0 {
+        return CallNextHookEx(HOOK, code, wparam, lparam);
+    }
+
+    // Only key-down
+    let msg = wparam.0 as u32;
+    if msg != WM_KEYDOWN && msg != WM_SYSKEYDOWN {
+        return CallNextHookEx(HOOK, code, wparam, lparam);
+    }
+
+    // Skip while we are injecting a correction
+    if CORRECTING.load(Ordering::SeqCst) {
+        return CallNextHookEx(HOOK, code, wparam, lparam);
+    }
+
+    // Skip if autocorrect is paused
+    if !ENABLED.load(Ordering::SeqCst) {
+        return CallNextHookEx(HOOK, code, wparam, lparam);
+    }
+
+    let kb = *(lparam.0 as *const KBDLLHOOKSTRUCT);
+
+    // Ignore injected input (our own SendInput calls)
+    if kb.flags.0 & LLKHF_INJECTED.0 != 0 {
+        return CallNextHookEx(HOOK, code, wparam, lparam);
+    }
+
+    let vk = kb.vkCode;
+
+    // --- Letters A-Z → append to buffer ---
+    if (0x41..=0x5A).contains(&vk) {
+        let ch = vk_to_char(vk);
+        if let Ok(mut buf) = WORD_BUFFER.lock() {
+            buf.push(ch);
+        }
+        return CallNextHookEx(HOOK, code, wparam, lparam);
+    }
+
+    // --- Apostrophe (unshifted OEM_7 on US layout) ---
+    if vk == VK_OEM_7.0 as u32 {
+        let shift = GetAsyncKeyState(VK_SHIFT.0 as i32) as u16 & 0x8000 != 0;
+        if !shift {
+            if let Ok(mut buf) = WORD_BUFFER.lock() {
+                buf.push('\'');
+            }
+            return CallNextHookEx(HOOK, code, wparam, lparam);
+        }
+    }
+
+    // --- Word boundary keys → trigger correction check ---
+    let trigger = match vk {
+        v if v == VK_SPACE.0 as u32  => Some(TriggerKind::Space),
+        v if v == VK_RETURN.0 as u32 => Some(TriggerKind::Enter),
+        v if v == VK_TAB.0 as u32    => Some(TriggerKind::Tab),
+        v if v == VK_OEM_PERIOD.0 as u32 => Some(TriggerKind::Char('.')),
+        v if v == VK_OEM_COMMA.0  as u32 => Some(TriggerKind::Char(',')),
+        v if v == VK_OEM_1.0 as u32      => Some(TriggerKind::Char(';')),
+        v if v == VK_OEM_2.0 as u32      => Some(TriggerKind::Char('/')),
+        _ => None,
+    };
+
+    if let Some(trig) = trigger {
+        check_and_schedule(trig);
+        return CallNextHookEx(HOOK, code, wparam, lparam);
+    }
+
+    // --- Backspace → trim buffer ---
+    if vk == VK_BACK.0 as u32 {
+        if let Ok(mut buf) = WORD_BUFFER.lock() {
+            buf.pop();
+        }
+        return CallNextHookEx(HOOK, code, wparam, lparam);
+    }
+
+    // --- Navigation / Delete / Escape → clear buffer ---
+    const NAV: &[VIRTUAL_KEY] = &[
+        VK_LEFT, VK_RIGHT, VK_UP, VK_DOWN,
+        VK_HOME, VK_END, VK_PRIOR, VK_NEXT,
+        VK_DELETE, VK_ESCAPE,
+    ];
+    if NAV.iter().any(|k| k.0 as u32 == vk) {
+        if let Ok(mut buf) = WORD_BUFFER.lock() {
+            buf.clear();
+        }
+    }
+
+    CallNextHookEx(HOOK, code, wparam, lparam)
+}
+
+// ---- helpers --------------------------------------------------------------
+
+/// Convert a VK code (A-Z range) to the character the user actually typed.
+fn vk_to_char(vk: u32) -> char {
+    let shift = unsafe { GetAsyncKeyState(VK_SHIFT.0 as i32) } as u16 & 0x8000 != 0;
+    let caps  = unsafe { GetKeyState(VK_CAPITAL.0 as i32) } & 1 != 0;
+    let upper = shift ^ caps;
+    let base  = (vk - 0x41) as u8;
+    if upper { (b'A' + base) as char } else { (b'a' + base) as char }
+}
+
+/// Take the current word buffer, check it, and post a correction message.
+fn check_and_schedule(trigger: TriggerKind) {
+    let word = {
+        let mut buf = WORD_BUFFER.lock().unwrap();
+        let w = buf.clone();
+        buf.clear();
+        w
+    };
+
+    if word.len() < 2 {
+        return;
+    }
+
+    let checker = CHECKER.get().expect("checker not initialised");
+    if let Some(correction) = checker.get_correction(&word) {
+        if correction.eq_ignore_ascii_case(&word) {
+            return;
+        }
+
+        let corrected = preserve_case(&word, &correction);
+
+        // Store pending correction
+        if let Ok(mut p) = PENDING.lock() {
+            *p = Some((word, corrected, trigger));
+        }
+
+        // Ask the tray window to perform the replacement
+        unsafe {
+            let hwnd = crate::tray::hwnd();
+            let _ = PostMessageW(hwnd, WM_DO_CORRECTION, WPARAM(0), LPARAM(0));
+        }
+    }
+}
+
+/// Mirror the original word's capitalisation onto the correction.
+fn preserve_case(original: &str, correction: &str) -> String {
+    if original.chars().all(|c| c.is_uppercase() || !c.is_alphabetic()) {
+        return correction.to_uppercase();
+    }
+    if original.chars().next().map_or(false, |c| c.is_uppercase()) {
+        let mut it = correction.chars();
+        return match it.next() {
+            Some(f) => f.to_uppercase().to_string() + it.as_str(),
+            None => String::new(),
+        };
+    }
+    correction.to_lowercase()
+}

src/main.rs

@@ -0,0 +1,59 @@
+#![windows_subsystem = "windows"]
+
+mod hook;
+mod replacer;
+mod spellcheck;
+mod tray;
+
+use std::sync::atomic::AtomicBool;
+use std::sync::{Mutex, OnceLock};
+
+// ---------------------------------------------------------------------------
+//  Global application state (all accessed from the main thread only)
+// ---------------------------------------------------------------------------
+
+/// Whether autocorrect is active
+pub static ENABLED: AtomicBool = AtomicBool::new(true);
+
+/// Whether we are currently performing a correction (ignore our own keys)
+pub static CORRECTING: AtomicBool = AtomicBool::new(false);
+
+/// Accumulated word buffer
+pub static WORD_BUFFER: Mutex<String> = Mutex::new(String::new());
+
+/// Pending correction: (original_word, corrected_word, trigger)
+pub static PENDING: Mutex<Option<(String, String, TriggerKind)>> = Mutex::new(None);
+
+/// Spellcheck engine (initialized once at startup)
+pub static CHECKER: OnceLock<spellcheck::SpellChecker> = OnceLock::new();
+
+/// How the user terminated the word
+#[derive(Clone, Debug)]
+pub enum TriggerKind {
+    Space,
+    Enter,
+    Tab,
+    Char(char),
+}
+
+// ---------------------------------------------------------------------------
+//  Entry point
+// ---------------------------------------------------------------------------
+
+fn main() {
+    // 1. Initialize the spellcheck engine
+    let checker = spellcheck::SpellChecker::new();
+    CHECKER.set(checker).expect("spellchecker already initialized");
+
+    // 2. Create the hidden tray window (also registers the hotkey)
+    let hwnd = tray::setup();
+
+    // 3. Install the global keyboard hook
+    hook::install();
+
+    // 4. Show startup balloon
+    tray::notify("Autocorrect-Type", "Running. Press Ctrl+Alt+A to toggle.");
+
+    // 5. Run the Windows message loop (blocks forever)
+    hook::message_loop(hwnd);
+}

src/replacer.rs

@@ -0,0 +1,111 @@
+// ---------------------------------------------------------------------------
+//  replacer.rs — Direct-typing text replacement (no clipboard interaction)
+// ---------------------------------------------------------------------------
+
+use crate::TriggerKind;
+use std::thread;
+use std::time::Duration;
+use windows::Win32::UI::Input::KeyboardAndMouse::*;
+
+/// Replace `original` with `corrected` in the currently focused application.
+///
+/// Strategy:
+/// 1. Delete the misspelled word + trigger character with backspaces
+/// 2. Type the corrected word character-by-character
+/// 3. Re-type the trigger character
+///
+/// This approach never touches the clipboard, so Ctrl+C contents are
+/// always preserved and never interfere with corrections.
+pub fn replace(original: &str, corrected: &str, trigger: &TriggerKind) {
+    // Small delay to let the trigger key be processed first
+    thread::sleep(Duration::from_millis(40));
+
+    // 1. Backspace to delete the word + the trigger character
+    let bs_count = original.len() + 1;
+    for _ in 0..bs_count {
+        send_key(VK_BACK);
+    }
+    thread::sleep(Duration::from_millis(30));
+
+    // 2. Type the corrected word directly (no clipboard)
+    for ch in corrected.chars() {
+        send_char(ch);
+    }
+
+    // 3. Re-type the trigger character
+    match trigger {
+        TriggerKind::Space => send_key(VK_SPACE),
+        TriggerKind::Enter => send_key(VK_RETURN),
+        TriggerKind::Tab   => send_key(VK_TAB),
+        TriggerKind::Char(ch) => send_char(*ch),
+    }
+}
+
+// ---------------------------------------------------------------------------
+//  Input simulation helpers
+// ---------------------------------------------------------------------------
+
+fn send_key(vk: VIRTUAL_KEY) {
+    let inputs = [
+        INPUT {
+            r#type: INPUT_KEYBOARD,
+            Anonymous: INPUT_0 {
+                ki: KEYBDINPUT {
+                    wVk: vk,
+                    wScan: 0,
+                    dwFlags: KEYBD_EVENT_FLAGS(0),
+                    time: 0,
+                    dwExtraInfo: 0,
+                },
+            },
+        },
+        INPUT {
+            r#type: INPUT_KEYBOARD,
+            Anonymous: INPUT_0 {
+                ki: KEYBDINPUT {
+                    wVk: vk,
+                    wScan: 0,
+                    dwFlags: KEYEVENTF_KEYUP,
+                    time: 0,
+                    dwExtraInfo: 0,
+                },
+            },
+        },
+    ];
+    unsafe {
+        SendInput(&inputs, std::mem::size_of::<INPUT>() as i32);
+    }
+}
+
+fn send_char(ch: char) {
+    let code = ch as u16;
+    let inputs = [
+        INPUT {
+            r#type: INPUT_KEYBOARD,
+            Anonymous: INPUT_0 {
+                ki: KEYBDINPUT {
+                    wVk: VIRTUAL_KEY(0),
+                    wScan: code,
+                    dwFlags: KEYEVENTF_UNICODE,
+                    time: 0,
+                    dwExtraInfo: 0,
+                },
+            },
+        },
+        INPUT {
+            r#type: INPUT_KEYBOARD,
+            Anonymous: INPUT_0 {
+                ki: KEYBDINPUT {
+                    wVk: VIRTUAL_KEY(0),
+                    wScan: code,
+                    dwFlags: KEYEVENTF_UNICODE | KEYEVENTF_KEYUP,
+                    time: 0,
+                    dwExtraInfo: 0,
+                },
+            },
+        },
+    ];
+    unsafe {
+        SendInput(&inputs, std::mem::size_of::<INPUT>() as i32);
+    }
+}

src/spellcheck.rs

@@ -0,0 +1,272 @@
+// ---------------------------------------------------------------------------
+//  spellcheck.rs — Dictionary lookup + edit-distance spell checking
+// ---------------------------------------------------------------------------
+
+use std::collections::HashSet;
+use std::fs::File;
+use std::io::{BufRead, BufReader, Seek, SeekFrom};
+use std::path::PathBuf;
+
+#[derive(Debug)]
+pub struct SpellChecker {
+    /// Valid English words (lowercased)
+    words: HashSet<String>,
+    /// User-added words (lowercased)
+    user_words: HashSet<String>,
+    /// Path to misspellings file for on-disk binary search
+    misspellings_path: PathBuf,
+}
+
+impl SpellChecker {
+    pub fn new() -> Self {
+        let mut sc = Self {
+            words: HashSet::with_capacity(500_000),
+            user_words: HashSet::new(),
+            misspellings_path: data_path("misspellings.txt"),
+        };
+        sc.load_dictionary();
+        sc.load_user_words();
+        sc
+    }
+
+    // --- loading -----------------------------------------------------------
+
+    fn load_dictionary(&mut self) {
+        let path = data_path("words.txt");
+        if let Ok(file) = File::open(&path) {
+            let reader = BufReader::new(file);
+            for line in reader.lines() {
+                if let Ok(w) = line {
+                    let w = w.trim();
+                    if !w.is_empty() {
+                        self.words.insert(w.to_lowercase());
+                    }
+                }
+            }
+        }
+    }
+
+    fn load_user_words(&mut self) {
+        let path = user_words_path();
+        if let Ok(data) = std::fs::read_to_string(&path) {
+            for line in data.lines() {
+                let w = line.trim();
+                if !w.is_empty() {
+                    self.user_words.insert(w.to_lowercase());
+                }
+            }
+        }
+    }
+
+    // --- public API --------------------------------------------------------
+
+    /// Returns `Some(correction)` if the word is misspelled, else `None`.
+    pub fn get_correction(&self, word: &str) -> Option<String> {
+        if word.len() <= 1 {
+            return None;
+        }
+
+        let lower = word.to_lowercase();
+
+        // 1) Already a valid word → no correction (Fast check)
+        if self.is_word(&lower) {
+            return None;
+        }
+
+        // 2) Known misspelling → Binary search on disk (O(log N))
+        // This avoids keeping 590MB of strings in RAM.
+        if let Some(fix) = self.find_misspelling_on_disk(&lower) {
+            return Some(fix);
+        }
+
+        // 3) Skip very short words for dynamic checking (too many false positives)
+        if lower.len() <= 2 {
+            return None;
+        }
+
+        // 4) Edit-distance-1 candidates
+        for candidate in edits1(&lower) {
+            if self.is_word(&candidate) {
+                return Some(candidate);
+            }
+        }
+
+        // 5) Edit-distance-2 for longer words (≥5 chars)
+        if lower.len() >= 5 {
+            let mut found = 0;
+            for e1 in edits1(&lower) {
+                for e2 in edits1(&e1) {
+                    if self.is_word(&e2) {
+                        return Some(e2);
+                    }
+                    found += 1;
+                    if found >= 50 {
+                        // Bail early to keep latency low
+                        return None;
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
+    /// Binary search for `target` in the misspellings file.
+    /// Format: `misspelling=correction` sorted by misspelling.
+    fn find_misspelling_on_disk(&self, target: &str) -> Option<String> {
+        let mut file = File::open(&self.misspellings_path).ok()?;
+        let size = file.metadata().ok()?.len();
+        if size == 0 { return None; }
+
+        let mut low = 0;
+        let mut high = size;
+
+        while low < high {
+            let mid = low + (high - low) / 2;
+            file.seek(SeekFrom::Start(mid)).ok()?;
+
+            // Find the start of the next full line
+            let mut line = String::new();
+            let mut br = BufReader::new(&file);
+            if mid != 0 {
+                let _ = br.read_line(&mut line); // skip partial line
+                line.clear();
+                let _ = br.read_line(&mut line); // read full line
+            } else {
+                let _ = br.read_line(&mut line);
+            }
+
+            if line.is_empty() {
+                high = mid;
+                continue;
+            }
+
+            let trimmed = line.trim();
+            if trimmed.is_empty() || trimmed.starts_with('#') {
+                low = mid + 1;
+                continue;
+            }
+
+            if let Some((bad, good)) = trimmed.split_once('=') {
+                let bad = bad.trim();
+                let cmp = bad.cmp(target);
+                if cmp == std::cmp::Ordering::Equal {
+                    return Some(good.trim().to_string());
+                } else if cmp == std::cmp::Ordering::Less {
+                    low = mid + 1;
+                } else {
+                    high = mid;
+                }
+            } else {
+                low = mid + 1;
+            }
+        }
+        None
+    }
+
+    /// Add a word to the user dictionary and persist it.
+    pub fn add_user_word(&mut self, word: &str) {
+        let lower = word.to_lowercase();
+        self.user_words.insert(lower.clone());
+        let path = user_words_path();
+        if let Some(parent) = path.parent() {
+            let _ = std::fs::create_dir_all(parent);
+        }
+        let _ = std::fs::OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&path)
+            .and_then(|mut f| {
+                use std::io::Write;
+                writeln!(f, "{}", lower)
+            });
+    }
+
+    fn is_word(&self, w: &str) -> bool {
+        self.words.contains(w) || self.user_words.contains(w)
+    }
+}
+
+// ---------------------------------------------------------------------------
+//  Helpers
+// ---------------------------------------------------------------------------
+
+fn data_path(filename: &str) -> PathBuf {
+    let mut p = std::env::current_exe().unwrap_or_else(|_| PathBuf::from("."));
+    p.pop(); // remove exe name
+    p.push("data");
+    p.push(filename);
+
+    // If data folder doesn't exist next to exe, try root (for dev)
+    if !p.exists() {
+        let mut p2 = PathBuf::from(".");
+        p2.push("data");
+        p2.push(filename);
+        if p2.exists() { return p2; }
+    }
+    p
+}
+
+/// Path to the user-words file next to the executable.
+fn user_words_path() -> PathBuf {
+    data_path("user_words.txt")
+}
+
+// ---------------------------------------------------------------------------
+//  Edit-distance generator
+// ---------------------------------------------------------------------------
+
+/// Generate all strings within edit-distance 1 of `word`.
+fn edits1(word: &str) -> Vec<String> {
+    let chars: Vec<char> = word.chars().collect();
+    let n = chars.len();
+    let mut results = Vec::with_capacity(n * 54 + 26);
+
+    // Deletions
+    for i in 0..n {
+        let mut s = String::with_capacity(n - 1);
+        for (j, &c) in chars.iter().enumerate() {
+            if j != i {
+                s.push(c);
+            }
+        }
+        results.push(s);
+    }
+
+    // Transpositions
+    for i in 0..n.saturating_sub(1) {
+        let mut v = chars.clone();
+        v.swap(i, i + 1);
+        results.push(v.into_iter().collect());
+    }
+
+    // Replacements
+    for i in 0..n {
+        for c in 'a'..='z' {
+            if c != chars[i] {
+                let mut v = chars.clone();
+                v[i] = c;
+                results.push(v.into_iter().collect());
+            }
+        }
+    }
+
+    // Insertions
+    for i in 0..=n {
+        for c in 'a'..='z' {
+            let mut s = String::with_capacity(n + 1);
+            for (j, &ch) in chars.iter().enumerate() {
+                if j == i {
+                    s.push(c);
+                }
+                s.push(ch);
+            }
+            if i == n {
+                s.push(c);
+            }
+            results.push(s);
+        }
+    }
+
+    results
+}

src/tray.rs

@@ -0,0 +1,221 @@
+// ---------------------------------------------------------------------------
+//  tray.rs — System tray icon, context menu, hotkey, and correction handler
+// ---------------------------------------------------------------------------
+
+use crate::hook::WM_DO_CORRECTION;
+use crate::{CORRECTING, ENABLED, PENDING};
+use std::sync::atomic::Ordering;
+use windows::core::*;
+use windows::Win32::Foundation::*;
+use windows::Win32::UI::Input::KeyboardAndMouse::*;
+use windows::Win32::UI::Shell::*;
+use windows::Win32::UI::WindowsAndMessaging::*;
+
+const WM_TRAYICON: u32 = WM_APP + 100;
+const IDM_TOGGLE: u32 = 2001;
+const IDM_EXIT: u32 = 2002;
+const HOTKEY_ID: i32 = 1;
+
+static mut HWND_TRAY: HWND = HWND(std::ptr::null_mut());
+
+/// Get the tray window handle.
+pub fn hwnd() -> HWND {
+    unsafe { HWND_TRAY }
+}
+
+/// Create the hidden message window, tray icon, and hotkey.
+pub fn setup() -> HWND {
+    unsafe {
+        let class = w!("AutocorrectTypeTray");
+        let wc = WNDCLASSEXW {
+            cbSize: std::mem::size_of::<WNDCLASSEXW>() as u32,
+            lpfnWndProc: Some(wnd_proc),
+            lpszClassName: class,
+            ..Default::default()
+        };
+        RegisterClassExW(&wc);
+
+        let h = CreateWindowExW(
+            WINDOW_EX_STYLE::default(),
+            class,
+            w!("Autocorrect-Type"),
+            WINDOW_STYLE::default(),
+            0, 0, 0, 0,
+            HWND_MESSAGE,
+            None,
+            None,
+            None,
+        )
+        .expect("CreateWindowExW failed");
+
+        HWND_TRAY = h;
+
+        // Tray icon
+        add_tray_icon(h);
+
+        // Ctrl+Alt+A hotkey
+        let _ = RegisterHotKey(h, HOTKEY_ID, MOD_CONTROL | MOD_ALT, 0x41); // 'A'
+
+        h
+    }
+}
+
+/// Show a balloon notification from the tray icon.
+pub fn notify(title: &str, msg: &str) {
+    unsafe {
+        let mut nid = base_nid();
+        nid.uFlags = NIF_INFO;
+        copy_wide(title, &mut nid.szInfoTitle);
+        copy_wide(msg, &mut nid.szInfo);
+        nid.Anonymous.uTimeout = 2000;
+        let _ = Shell_NotifyIconW(NIM_MODIFY, &nid);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// internals
+// ---------------------------------------------------------------------------
+
+unsafe fn add_tray_icon(_hwnd: HWND) {
+    let mut nid = base_nid();
+    nid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
+    nid.uCallbackMessage = WM_TRAYICON;
+    nid.hIcon = LoadIconW(None, IDI_APPLICATION).unwrap_or_default();
+    copy_wide("Autocorrect-Type (Active)", &mut nid.szTip);
+    let _ = Shell_NotifyIconW(NIM_ADD, &nid);
+}
+
+unsafe fn remove_tray_icon() {
+    let nid = base_nid();
+    let _ = Shell_NotifyIconW(NIM_DELETE, &nid);
+}
+
+unsafe fn update_tip(text: &str) {
+    let mut nid = base_nid();
+    nid.uFlags = NIF_TIP;
+    copy_wide(text, &mut nid.szTip);
+    let _ = Shell_NotifyIconW(NIM_MODIFY, &nid);
+}
+
+unsafe fn base_nid() -> NOTIFYICONDATAW {
+    let mut nid = NOTIFYICONDATAW::default();
+    nid.cbSize = std::mem::size_of::<NOTIFYICONDATAW>() as u32;
+    nid.hWnd = HWND_TRAY;
+    nid.uID = 1;
+    nid
+}
+
+fn copy_wide(src: &str, dst: &mut [u16]) {
+    for (i, ch) in src.encode_utf16().enumerate() {
+        if i >= dst.len() - 1 {
+            break;
+        }
+        dst[i] = ch;
+    }
+}
+
+unsafe fn show_context_menu(hwnd: HWND) {
+    let menu = CreatePopupMenu().unwrap();
+    let enabled = ENABLED.load(Ordering::SeqCst);
+    let label = if enabled {
+        w!("Pause Autocorrect")
+    } else {
+        w!("Resume Autocorrect")
+    };
+    let _ = AppendMenuW(menu, MF_STRING, IDM_TOGGLE as usize, label);
+    let _ = AppendMenuW(menu, MF_SEPARATOR, 0, None);
+    let _ = AppendMenuW(menu, MF_STRING, IDM_EXIT as usize, w!("Exit"));
+
+    let mut pt = Default::default();
+    let _ = GetCursorPos(&mut pt);
+    let _ = SetForegroundWindow(hwnd);
+    let _ = TrackPopupMenu(menu, TPM_BOTTOMALIGN | TPM_LEFTALIGN, pt.x, pt.y, 0, hwnd, None);
+    let _ = PostMessageW(hwnd, WM_NULL, WPARAM(0), LPARAM(0));
+    let _ = DestroyMenu(menu);
+}
+
+// ---------------------------------------------------------------------------
+//  Window procedure
+// ---------------------------------------------------------------------------
+
+unsafe extern "system" fn wnd_proc(
+    hwnd: HWND,
+    msg: u32,
+    wparam: WPARAM,
+    lparam: LPARAM,
+) -> LRESULT {
+    match msg {
+        // --- Tray icon interaction ---
+        WM_TRAYICON => {
+            let event = (lparam.0 & 0xFFFF) as u32;
+            if event == WM_RBUTTONUP || event == WM_CONTEXTMENU {
+                show_context_menu(hwnd);
+            }
+            LRESULT(0)
+        }
+
+        // --- Menu commands ---
+        WM_COMMAND => {
+            let id = (wparam.0 & 0xFFFF) as u32;
+            match id {
+                IDM_TOGGLE => toggle(),
+                IDM_EXIT => {
+                    remove_tray_icon();
+                    PostQuitMessage(0);
+                }
+                _ => {}
+            }
+            LRESULT(0)
+        }
+
+        // --- Hotkey (Ctrl+Alt+A) ---
+        WM_HOTKEY => {
+            if wparam.0 as i32 == HOTKEY_ID {
+                toggle();
+            }
+            LRESULT(0)
+        }
+
+        // --- Perform a scheduled correction ---
+        m if m == WM_DO_CORRECTION => {
+            do_correction();
+            LRESULT(0)
+        }
+
+        // --- Cleanup ---
+        WM_DESTROY => {
+            remove_tray_icon();
+            PostQuitMessage(0);
+            LRESULT(0)
+        }
+
+        _ => DefWindowProcW(hwnd, msg, wparam, lparam),
+    }
+}
+
+fn toggle() {
+    let was = ENABLED.load(Ordering::SeqCst);
+    ENABLED.store(!was, Ordering::SeqCst);
+    let (tip, msg) = if was {
+        ("Autocorrect-Type (Paused)", "Autocorrect paused")
+    } else {
+        ("Autocorrect-Type (Active)", "Autocorrect enabled")
+    };
+    unsafe { update_tip(tip) };
+    notify("Autocorrect-Type", msg);
+}
+
+fn do_correction() {
+    let data = {
+        let mut p = PENDING.lock().unwrap();
+        p.take()
+    };
+    if let Some((original, corrected, trigger)) = data {
+        CORRECTING.store(true, Ordering::SeqCst);
+        crate::replacer::replace(&original, &corrected, &trigger);
+        CORRECTING.store(false, Ordering::SeqCst);
+
+        // Show a tooltip-like notification
+        notify("Autocorrect-Type", &format!("{original} → {corrected}"));
+    }
+}