QuickShot

A tray-resident screenshot tool for Windows: press a global hotkey, drag a rectangle, and the capture instantly floats on top of your desktop — movable, always-on-top if you want, with four tiny buttons (pin / save / collapse / close) that appear only while the pointer is over the snapshot.

English · 繁體中文

Five regions captured from a documentation page, each one still floating where it was taken from. This is what QuickShot is for: collect the pieces you need, keep them in view, save or close them when you are done.

The desktop is frozen the instant the hotkey fires and dimmed, so the selection shows through at full brightness. Full-screen guide lines and a two-tone crosshair show the exact pixel, the small badge is the pointer position in physical pixels, and the magnifier reads out 978, 667 — 472 × 399 while you drag. Esc or a right click cancels.

Each snapshot floats exactly over the region it came from, with the four 18 × 18 px controls (📌 always-on-top, 💾 save, ⌃ collapse, ✕ close) appearing only while the pointer is over the card and vanishing the instant it leaves, so they never sit on top of the screenshot. The pin is colour-coded: blue means the snapshot is kept on top, white means it is an ordinary window. Drag the body to move it, double-click to toggle 1:1 / fit.

Being resident means space matters, so every snapshot rolls up into a thumbnail of at most 180 × 135 px — still floating, still in place, and restored to exactly the previous size on demand. The tray menu does all of them at once.

Twenty floating snapshots are the default budget. When the limit is reached you are asked which one the new capture should replace (the oldest is preselected), or you can cancel and discard the new capture.

Language, hotkey, start with Windows, save folder, snapshot limit, opacity and notifications. Switching the language re-translates the whole UI immediately — no restart.

The desktop behind these screenshots is a generated sample scene (tools/screenshot-backdrop.py), so nothing but the app itself is on display. The first screenshot is a real session.

Requirements: Windows 10 1809+ or Windows 11, x64, nothing else.

Snapshots are written to %USERPROFILE%\Pictures\QuickShot\QuickShot_<yyyyMMdd_HHmmss>.png; collisions get _2, _3, … appended.

Because a second launch forwards the request to the running instance, these flags double as a scriptable trigger — bind QuickShot.exe --collapse to a keyboard shortcut or an AutoHotkey script and you have "get all these snapshots out of my way" on one key.

• C# 12 / .NET 8 (LTS), WPF for the UI, WinForms only for the tray NotifyIcon
• Zero NuGet dependencies — the hotkey, capture and DPI work is P/Invoke on user32/shcore
• RegisterHotKey + a message-only HwndSource for the global hotkey (WM_HOTKEY)
• GDI BitBlt (CopyFromScreen) for capture, PngBitmapEncoder for lossless snapshots
• PerMonitorV2 DPI awareness (app.manifest) so region coordinates are pixel-exact on mixed-DPI multi-monitor setups
• Inno Setup 6 installer, per-user, no elevation; self-contained single exe publish
• English (default) + Traditional Chinese, switched at runtime through a XAML resource dictionary and a {res:Loc Key} markup extension

Stored in %AppData%\QuickShot\settings.json; a log lands next to it as quickshot.log.

# debug build + run
dotnet build src\QuickShot\QuickShot.csproj -c Debug
src\QuickShot\bin\Debug\net8.0-windows\QuickShot.exe

# self-contained single exe  ->  build\publish\QuickShot.exe            (62.9 MB)
.\build\publish.ps1 -SkipInstaller

# single exe + installer      ->  build\installer\QuickShot-Setup-1.0.2.exe  (58 MB)
.\build\publish.ps1

# tiny framework-dependent build -> build\publish-framework\            (0.35 MB)
.\build\publish.ps1 -Framework -SkipInstaller

Requires the .NET 8 SDK and (for the installer step) Inno Setup 6.

Inno Setup bundled the unofficial translations up to 6.4; 6.5 and later do not. So on a newer Inno Setup the installer is English-only unless Languages\ChineseTrad.isl is present — build\publish.ps1 looks for it and offers the Traditional Chinese installer UI when it can (the app itself is bilingual either way).

src/QuickShot
├─ App.xaml(.cs)              single instance (mutex + named events), capture flow, settings
├─ Interop/                   RegisterHotKey / GDI / DPI / SetWindowPos P/Invoke
├─ Models/                    AppSettings, Snapshot, HotkeyGesture (parse + display)
├─ Services/                  HotkeyService, TrayService, ScreenCaptureService,
│                             SnapshotManager, SettingsService, LocalizationService, Log
├─ Views/                     OverlayWindow + SelectionSession, SnapshotWindow,
│                             ReplaceSnapshotDialog, SettingsWindow
├─ Resources/                 Strings_en.xaml, Strings_zh-TW.xaml, Loc markup extension
└─ Themes/Styles.xaml         brushes + tiny button styles
installer/QuickShot.iss       Inno Setup script
build/publish.ps1             publish + package
tools/                        icon generator, screenshot backdrop, e2e test scripts

1. Capture first, then overlay. The whole virtual desktop is grabbed the instant the hotkey fires; the dimmed selection overlay then draws that frozen frame. This removes the "hide the overlay → wait → capture → restore" race, which is why the overlay can never end up in the snapshot, why the magnifier works, and why there is no flicker.
2. One overlay window per monitor. A single window spanning monitors with different DPI scales is laid out in one DPI space, which makes region coordinates drift. Per-monitor windows plus a physical-pixel conversion measured from GetWindowRect are exact.
3. Snapshots are stored as PNG bytes, not bitmaps. 20 full-screen 4K bitmaps would be ~660 MB. Each snapshot keeps its lossless PNG plus a preview of at most 1600 px instead, so 20 snapshots stay around 150 MB in total. Saving writes the original PNG bytes directly (no re-encode, no quality loss); 1:1 zoom decodes the full image on demand and releases it again.

Automated end-to-end runs drive the real window with synthetic keyboard and mouse input, and check the results pixel-wise (tools/e2e/):

• Exclusive-fullscreen games: nothing can float on top of them; borderless windowed mode works.
• DRM content (Netflix, Disney+, …) captures as a black frame — an OS restriction.
• Hotkeys are exclusive: while QuickShot runs, the registered combination is taken from every other app. Win+Shift+Q is verified free on Windows 10; a combination another program already owns cannot be registered, and QuickShot reports the conflict instead of failing silently. Win+Shift+↓ cannot be used — Windows reserves it (verified: RegisterHotKey returns ERROR_HOTKEY_ALREADY_REGISTERED), nor can Win+↓, Win+Shift+S or Win+L.
• Snapshot windows stay out of Alt+Tab on purpose (WS_EX_TOOLWINDOW).
• One region per drag: a selection cannot span two monitors with different DPI scales.

Everything used to build, package and verify the app lives in the repo:

MIT © Caron Yang

QuickShot is not affiliated with any other screenshot tool. "Windows" is a trademark of Microsoft Corporation.