Optimize your PC without fear. Every change is tracked. Every change can be undone.
Optix is a Windows gaming-performance and system-recovery utility. It fixes the Windows defaults that slow games down, cleans up what's safe to remove, helps you measure the difference — and lets you undo any of it.
Every modification follows the same pipeline:
Detect → Snapshot → Apply → Verify → Record → Rollback.
| Module | What it does |
|---|---|
| Dashboard | Live CPU, memory, and network telemetry with trend charts. |
| System Scanner | Full hardware + software inventory: CPU, GPU, RAM, disks (type + health), displays, OS build, running processes, and startup apps. |
| Snapshots | Capture the state of every area Optix touches before you change anything — plus optional Windows System Restore points for an extra safety net. |
| Rollback Center | Inspect every tracked change, restore snapshots in reverse order, and diff two snapshots. |
| Cleanup | Reclaim space from temp files, browser caches, GPU shader caches, crash dumps, old logs, Windows Update leftovers, and the Recycle Bin — with a hard deny-list so protected system paths are never touched. Includes Microsoft-sanctioned DISM WinSxS component cleanup. |
| Bloatware | Review preinstalled Store apps with a protected allowlist (never flags core system or Xbox packages), and remove provisioned copies so they don't reinstall. |
| Processes & RAM | See every running process with a REQUIRED / SAFE / UNKNOWN classification, per-process GPU usage, priority control (never REALTIME), and a gaming mode that boosts your game and lowers background apps. |
| Power | Apply Optix power profiles (Balanced / Competitive / Maximum) cloned from the built-in schemes, and disable network-adapter power saving — all reversible. |
| Startup & Services | Review what runs at boot and in the background, with a hard never-flag list, a dedicated Windows Search toggle, and scheduled-task enumeration with signature verification. On Linux the same tab manages systemd services (system + user), XDG autostart apps, and systemd timers + cron jobs. |
| Network | Benchmark DNS resolvers (latency + packet loss) and apply the fastest one; ICMP ping test (RTT + jitter); experimental TCP/IP tweaks with one-click apply and revert. |
| GPU | Risk-tiered gaming toggles (HAGS, Game DVR, Memory Integrity/VBS, Game Mode, MPO), shader-cache management, AMD shader-cache mode, and NVIDIA per-game driver profiles (DRS). |
| Game Profiles | Auto-detect installed games (Steam, Epic, Riot, Battle.net) or add them manually, and set per-game CPU priority, affinity, power profile, and an optional NVIDIA profile — applied automatically on launch. |
| Benchmarks | Capture FPS with the bundled PresentMon (avg FPS, 1% / 0.1% lows, frame-time chart) or run a system-stress benchmark, and compare runs before/after an optimization. |
| Crash Reports | Scan the Windows Event Log, WER reports, and minidumps; classify crashes, watch for new crashes live, and export a CrashReport.zip for support. |
| Diagnostics | Rule-based analysis with confidence scores and evidence — advisory only, never changes anything. |
Optix is not a "free FPS" booster. Not every tweak helps every game. Roughly, by measured impact:
- Disable Memory Integrity / VBS — the single biggest lever on Windows 11 (up to 5–15% in some titles), but a real security trade-off. Opt-in only.
- Disable Game DVR / Game Bar background recording — frees RAM and cuts input latency.
- Power plan — High/Ultimate Performance or an Optix profile.
- GPU driver settings + shader cache — reduces stutter, not raw FPS.
- Process priority/affinity during gaming — a modest, real gain.
- DNS selection — helps launchers, logins, and matchmaking, but not in-game ping once a connection is established.
- TCP/IP tweaks — mostly placebo on modern Windows; clearly marked experimental.
Use the Benchmarks page to measure before/after on the same scene rather than trusting the label.
- Nothing is permanent. Every change is snapshot-first and reversible from the Rollback Center.
- Nothing is deleted automatically. Cleanup and bloatware removal always require your explicit confirmation.
- Security stays on unless you choose otherwise. Memory Integrity / VBS and similar toggles are opt-in, clearly labeled, and reversible.
- Problems are visible. Every error is written to
logs.txtnext to the installed Optix executable (find the exact path in Settings) and to the console, so nothing fails silently.
- Windows 11 (primary) or Windows 10 (secondary).
- Administrator privileges. Optix relaunches itself through UAC when it isn't already elevated, because registry, services, power schemes, and process controls all require admin.
- Download the latest installer from the Releases page.
- Run the NSIS installer (
Optix_<version>_x64-setup.exe). - Launch Optix. On first run it asks for elevation — approve it.
- Before changing anything, create a snapshot from the Snapshots page.
Tip: Optix stores its database, snapshots, and logs under
C:\ProgramData\Optix. To start fresh, remove that directory while Optix is closed.
Optix is a Tauri app: a Rust backend with a React + TypeScript frontend.
- Frontend: React 19 + TypeScript, Tailwind CSS v4, Vite, Recharts
- Backend: Rust, Tauri v2,
sysinfo(cross-platform scanner),rusqlite(bundled SQLite),windows-sys+winreg(Windows integration),zip(crash-report bundles) - Database: SQLite at
C:\ProgramData\Optix\optix.db
- Node.js 20+ and npm
- Rust stable (MSRV 1.87)
- On Linux:
webkit2gtkand the system dependencies Tauri requires (see the Tauri prerequisites)
git clone <this-repo>
cd Optix
npm install
npm run tauri devOn a Windows host, npm run tauri dev runs the full app (Windows integration
included). On Linux it runs the UI with Windows-only modules stubbed — useful
for frontend and engine work. Linux builds are packaged as .deb and AppImage
from CI.
src/ React frontend (Vite + Tailwind)
components/ one component per page (Dashboard, Cleanup, …)
lib/ api.ts (typed invoke wrappers), types.ts, format helpers
src-tauri/
src/
main.rs elevation bootstrap + entry point
lib.rs module tree + command registration + startup services
logging.rs console + logs.txt logging (errors are never swallowed)
error.rs OptixError (thiserror, serialized to the frontend)
commands/ Tauri commands — one file per feature area
engine/ platform-independent logic (cleanup, rollback, …)
models/ serde structs shared between commands and the frontend
db/ SQLite schema + migrations (sqlite.rs)
win/ #[cfg(windows)]-only integrations (registry, services,
PDH, NVAPI, ping, restore points, …)
- The frontend calls typed wrappers in
src/lib/api.ts, whichinvokeTauri commands registered insrc-tauri/src/lib.rs. - Commands live in
src-tauri/src/commands/, orchestrate work insrc-tauri/src/engine/, and persist viasrc-tauri/src/db/. - Every struct returned to the frontend is in
src-tauri/src/models/and uses#[serde(rename_all = "camelCase")]; mirror it insrc/lib/types.ts. - Windows-only code is gated behind
#[cfg(windows)]with a non-Windows stub so the crate still compiles on Linux. - Errors are logged through
src-tauri/src/logging.rs(console +logs.txt) — never silently dropped.
# Backend (engine + db logic, runs on Linux)
cd src-tauri && cargo test
# Windows-target compile check (validates winreg/windows-sys FFI)
cd src-tauri && cargo check --target x86_64-pc-windows-gnu
# Frontend type-check + production build
npm run buildFrom a Windows host (NSIS + MSI):
npm run tauri buildFrom Linux (NSIS only — WiX/MSI runs only on Windows):
rustup target add x86_64-pc-windows-msvc
cargo install --locked cargo-xwin
sudo apt install lld llvm clang nsis # clang is needed for rusqlite's C build
npm run tauri build -- --runner cargo-xwin --target x86_64-pc-windows-msvc --bundles nsisThe PresentMon benchmark binary is fetched into src-tauri/resources/ by
scripts/fetch-presentmon.ps1 and bundled automatically; CI runs the fetch
before packaging.
GitHub Actions runs backend tests on Linux, builds .deb + AppImage installers
on ubuntu-latest, and builds NSIS + MSI installers on windows-latest.
- Use conventional commits:
feat:,fix:,refactor:,chore:,docs:, etc. - Keep changes focused and atomic; preserve existing behavior unless the change is intentional.
- Match existing patterns — new features follow
models/ → engine/ → commands/ → registration → frontend types + api + page. - Add unit tests for new pure logic (classifiers, parsers, math) and run the checks above before opening a PR.
- Never introduce irreversible changes, auto-delete, REALTIME priority, or unprotected security-feature changes — the safety model is the point.
See the LICENSE file.
