SCOPY

Copy anything from your screen.

Lightweight, privacy-first screen text extraction for Windows — press a hotkey, select text, and it's in your clipboard.

100% local. No cloud. No telemetry. No accounts.

---

Overview

SCOPY is a native Windows desktop application that lets you extract text from anywhere on your screen with a single keyboard shortcut. No more typing out text from screenshots, PDFs, images, or locked content.

Press Ctrl + Shift + C → drag to select → text is copied to your clipboard. That's it.

Why SCOPY?

	SCOPY	Cloud OCR tools
Privacy	100% local, nothing leaves your device	Screenshots uploaded to servers
Speed	Instant — no network round-trip	Network latency dependent
Offline	Works with no internet	Requires connection
Cost	Free & open source	Often subscription-based
Telemetry	None — zero data collection	Often tracked

Features

• Global Hotkey — Ctrl + Shift + C works from any application
• Region Selection — Draw a precise rectangle around any text on screen
• Local OCR — Powered by Windows.Media.Ocr — runs entirely on-device
• Auto Copy to Clipboard — Extracted text is ready to paste instantly
• Multi-Monitor Support — Handles multiple displays with different DPI scaling
• Per-Monitor DPI Awareness — Crisp rendering on high-DPI displays (PerMonitorV2)
• System Tray — Lives quietly in the notification area
• Capture History — Searchable log of past extractions with configurable retention
• Text Cleaning — Post-processing to normalize whitespace, line breaks, and artifacts
• Toast Notifications — Non-intrusive feedback after each capture
• Dark Theme — Modern dark UI with purple accent
• Configurable — Customizable hotkey, capture behavior, and retention policies
• Single Instance — Named mutex prevents duplicate launches
• Portable Settings — JSON-based configuration stored locally

Screenshots

Dashboard	Capture Overlay
Dark dashboard with capture button, shortcut, and status	Fullscreen overlay for region selection

History	Settings
Searchable capture history	Configurable preferences

Tech Stack

Layer	Technology
UI Framework	WPF (Windows Presentation Foundation)
Language	C# 12
Runtime	.NET 8.0 (net8.0-windows10.0.19041.0)
MVVM	CommunityToolkit.Mvvm 8.2
Dependency Injection	Microsoft.Extensions.DependencyInjection
Hosting / Logging	Microsoft.Extensions.Hosting + Logging
OCR	Windows.Media.Ocr (WinRT)
Screen Capture	GDI+ / Win32 BitBlt
Hotkeys	Win32 RegisterHotKey API
System Tray	Win32 Shell_NotifyIcon
Storage	JSON files in %LocalAppData%\SCOPY\
Icon	Generated via PowerShell (GDI+)

Architecture

SCOPY/
├── App.xaml / App.xaml.cs          # Entry point, DI container, global wiring
├── app.manifest                    # PerMonitorV2 DPI awareness
├── Models/
│   ├── AppSettings.cs              # Settings model + enums (CaptureAction, HistoryRetention...)
│   ├── CaptureHistoryItem.cs       # History entry model
│   └── OcrResult.cs                # OCR result model (text, confidence, word bounds)
├── Services/
│   ├── SettingsService.cs          # JSON settings load/save (%LocalAppData%\SCOPY\settings.json)
│   ├── NotificationService.cs      # In-app toast notifications
│   ├── TextCleaningService.cs      # Regex-based OCR text post-processing
│   └── SystemTrayManager.cs        # Win32 Shell_NotifyIcon + context menu
├── OCR/
│   └── WindowsOcrService.cs        # Windows.Media.Ocr engine wrapper
├── Capture/
│   └── ScreenCaptureService.cs     # Multi-monitor region/fullscreen capture
├── Clipboard/
│   └── ClipboardService.cs         # Thread-safe clipboard operations
├── Hotkeys/
│   └── HotkeyService.cs            # Win32 global hotkey registration
├── History/
│   └── HistoryService.cs           # JSON history persistence with auto-cleanup
├── ViewModels/
│   ├── MainViewModel.cs            # Dashboard state, recent captures
│   ├── HistoryViewModel.cs         # Search, filter, delete history
│   └── SettingsViewModel.cs        # Settings state
├── Views/
│   ├── MainWindow.xaml             # Sidebar nav + content host
│   ├── CaptureOverlayWindow.xaml   # Fullscreen transparent capture overlay
│   ├── DashboardPage.xaml          # Capture button, shortcut, status
│   ├── HistoryPage.xaml            # Searchable capture list
│   ├── SettingsPage.xaml           # General/Capture/OCR/History/Shortcuts
│   ├── AboutPage.xaml              # Version, privacy, GitHub links
│   ├── OnboardingWindow.xaml       # First-run welcome
│   └── ResultWindow.xaml           # Standalone result viewer
├── Converters/Converters.cs        # WPF value converters
├── Helpers/Utils.cs                # Utility functions
└── Assets/scopy.ico                # App icon (generated via generate-icon.ps1)

Getting Started

Prerequisites

• Windows 10 (build 19041+) or Windows 11
• .NET 8 SDK (for building) or .NET 8 Desktop Runtime (for running published builds)
• Windows OCR language pack (English included by default on most systems)

Clone & Run

git clone https://github.com/aamirali65/scopy.git
cd scopy
dotnet run --project SCOPY.csproj

Build (Debug)

dotnet build SCOPY.csproj -c Debug

Publish (Release — Framework-Dependent)

dotnet publish SCOPY.csproj -c Release -r win-x64 --self-contained false

Output: bin/Release/net8.0-windows10.0.19041.0/win-x64/publish/SCOPY.exe

Publish (Release — Self-Contained Single File)

dotnet publish SCOPY.csproj -c Release -r win-x64 --self-contained true -p:PublishSingleFile=true

This produces a single SCOPY.exe (~180 MB) that includes the .NET runtime — no installation required on target machines.

Generate App Icon

powershell -ExecutionPolicy Bypass -File generate-icon.ps1

Usage

1. Launch SCOPY — the app appears in your system tray
2. Press Ctrl + Shift + C — from anywhere in Windows
3. Drag to select the text region on your screen
4. Release — text is extracted and copied to your clipboard
5. Paste anywhere with Ctrl + V

Right-click the tray icon to show the window or quit.

Configuration

Settings are stored at %LocalAppData%\SCOPY\settings.json:

{
  "startWithWindows": false,
  "minimizeToTray": true,
  "defaultCaptureAction": "AutoCopy",
  "ocrLanguage": "en-US",
  "autoCopyText": true,
  "preserveLineBreaks": true,
  "saveHistory": true,
  "historyRetention": "ThirtyDays",
  "captureHotkey": {
    "ctrl": true,
    "shift": true,
    "alt": false,
    "win": false,
    "key": "C"
  }
}

History is stored at %LocalAppData%\SCOPY\history.json.

How It Works

┌──────────────┐     ┌──────────────────┐     ┌──────────────┐     ┌───────────────┐
│  Ctrl+Shift+C│────▶│ Capture Overlay  │────▶│ Windows OCR  │────▶│   Clipboard   │
│  (global     │     │ (drag rectangle, │     │ (local WinRT │     │ (auto-copy +  │
│   hotkey)    │     │  BitBlt capture) │     │  engine)     │     │   history)    │
└──────────────┘     └──────────────────┘     └──────────────┘     └───────────────┘

1. HotkeyService registers a global Win32 hotkey via RegisterHotKey
2. CaptureOverlayWindow shows a fullscreen transparent overlay for region selection
3. BitBlt captures the selected pixel region from the screen
4. WindowsOcrService runs OCR locally using Windows.Media.Ocr
5. TextCleaningService normalizes whitespace and removes artifacts
6. ClipboardService copies the result to the system clipboard
7. HistoryService optionally persists the extraction to local JSON

Privacy

SCOPY is built with privacy as a core architectural principle, not an afterthought:

• All OCR processing happens locally on your device using Windows built-in APIs
• Screenshots are never uploaded anywhere — they exist only in memory during extraction
• Zero analytics, telemetry, or tracking — no data is collected or transmitted
• No user accounts or cloud services required
• No internet connection needed for any core functionality
• Settings and history are stored as local JSON files you can inspect and delete
• No third-party dependencies beyond Microsoft's own .NET/WPF libraries

You can verify this by inspecting the source code — there are no HTTP clients, no API calls, and no network requests anywhere in the codebase.

Contributing

Contributions are welcome! Please follow these guidelines:

1. Code style — Match existing patterns (file-scoped namespaces, 4-space indent)
2. Error handling — All services must have proper try/catch with logging
3. No hardcoded values — Use settings where appropriate
4. Privacy first — No external API calls, no network requests, no telemetry
5. Build check — Ensure dotnet build -c Release passes with 0 errors

# Fork, then:
git clone https://github.com/your-username/scopy.git
cd scopy
dotnet build SCOPY.csproj -c Release

Project Structure & Design Decisions

• MVVM Pattern — ViewModels use CommunityToolkit.Mvvm source generators ([ObservableProperty], [RelayCommand])
• DI Container — All services registered in App.xaml.cs via Generic Host
• Service Interfaces — Every service has an interface (IOcrService, ISettingsService, etc.) for testability
• JSON Storage — Lightweight, human-readable, no database dependency
• Win32 Interop — Direct P/Invoke for hotkeys, tray, screen capture, and DPI awareness
• Single Instance — Named mutex prevents duplicate app instances

Roadmap

• Configurable multi-language OCR support
• Import image file → OCR (drag & drop or file picker)
• Pin result window (always on top)
• Text translation (local via offline models)
• Custom accent color picker
• MSI/MSIX installer packages
• Unit and integration tests

License

This project is licensed under the MIT License — see LICENSE for details.

Acknowledgments

• Windows.Media.Ocr — built-in Windows OCR engine
• CommunityToolkit.Mvvm — lightweight MVVM framework
• Microsoft.Extensions.Hosting — DI and logging infrastructure

---

Report a Bug · Request a Feature

Built with ❤️ for privacy-conscious Windows users