Mark Shot

中文说明

Tags: C++ / Qt 6 / Screenshot / Annotation / Pin Sticker / OCR / Scroll Screenshot / Wayland / Windows

mark-shot is a high-performance screenshot and annotation tool built with Qt 6. Originally designed for Wayland compositors such as niri, it now supports standard screenshot and annotation workflows on Linux (X11, GNOME, and wlroots/Wayland desktops) as well as Windows environments.

It captures screen frames instantly and opens an interactive fullscreen overlay, providing region cropping, rich annotation, clipboard copying, saving, and desktop pinning features.

• Pen & Highlighter: Smooth freehand drawing and semi-transparent overlay highlighting.
• Geometric Shapes: High-precision Line, Rectangle, and Ellipse paths. Rectangle additionally supports a style selector with three modes:
  • Stroke: outlined or filled rectangle with optional rounded corners.
  • Highlight: marker-pen overlay rendered with CompositionMode_Multiply and a semi-transparent fill.
  • Invert: inverts the RGB pixels covered by the rectangle while keeping the outline as a visual cue.
• Refined Arrow: Sharp 6-vertex acute arrow path rendering with anti-aliasing.
• Dual-Gesture Text:
  • Supports dynamic, ultra-large font sizing with fluid adjustment via scroll wheel or property sliders.
  • Implements a physical width buffer to prevent unexpected wrapping across extreme scales.
  • Diagonal handles scale font size and boundary box proportionally; side borders only adjust wrap width.
• Laser Pointer: Dedicated presentation tool with pen traces that dissolve smoothly over time.
• Auto-Increment Marker: Click to stamp sequential numbered markers.
• Mosaic: Applies high-fidelity acrylic frost blur to obscure sensitive information.
• Magnifier with Independent Frames: The magnifier loupe exposes resize handles on both the inner source viewfinder and the outer lens. Rectangle lenses get 8 corner/edge handles per frame, circular lenses get 4. Resizing either frame keeps the magnification ratio constant by scaling the other frame proportionally; translating one frame leaves the other untouched.
• Startup Code Scan: Press Q before selecting a region, drag around a QR code or barcode, and open the decoded result in a copyable window.
• Quick Display Capture: Press D before selecting a region to instantly capture all outputs, crop them by display, and hover a thumbnail to copy, edit, or save that display image.
• Image Host Upload: Press Ctrl+U or click the toolbar upload button after selecting a region to upload the screenshot to a custom image host (ImgURL, sm.ms, imgbb, litterbox, etc.). The returned URL is automatically copied to the clipboard. Configure the host via upload.env, or plug in any custom uploader via upload.command.

• Pins any cropped region or annotated screenshot as an independent, frameless, and top-level floating window.
• Supports direct selection of OCR-recognized text in the pinned window, with Ctrl + C and context-menu copying.
• Supports OpenAI-compatible LLM translation for OCR text, rendering translated text back onto the image at the original layout positions.
• Interactive Gestures:
  • Drag with left click to reposition.
  • Scroll mouse wheel to scale.
  • Double left-click or press Esc to close.
  • Right-click to open a context menu with options to rotate, copy image text, translate, save, copy, or close.

• Captures a long scrolling region by combining PipeWire screencast frames with an interactive scrolling overlay and stitcher.
• Designed primarily for niri and similar Wayland environments where output geometry and capture timing can be controlled predictably.
• Floating Drag Handle for Large Regions: When the selected capture region is too large to fit the preview panel on the screen, the preview panel is hidden, and a floating drag handle (a small floating button with direction arrows) is shown near the selection edge instead.
  • Drag to reposition selection: Press and drag the floating handle to slide the capture region along the active scroll axis. This allows adjusting the target area and reaching off-screen content.
  • Click to toggle axis: Click the handle directly before capture starts to switch between vertical and horizontal scroll directions.
• GNOME Wayland: scrolling capture requires the bundled mark-shot-scroll-helper@snemc.org GNOME Shell extension. GNOME does not expose the capture and preview hooks Mark Shot needs to normal desktop applications, so the extension provides a private D-Bus helper for area screenshots and the scroll preview panel.
• Compatibility notice: scrolling capture on KDE, X11, and other non-niri environments is a test feature and is not complete yet. Portal backends, shell policies, window geometry behavior, frame timing, and scroll event handling differ substantially across these desktop stacks.
• If scrolling capture fails, use normal screenshots or configure an external long-screenshot command through Mark Shot extension commands.
• To report a scrolling capture issue, run mark-shot --debug --debug-log /path/to/mark-shot.log, reproduce the failure, then attach the log to a GitHub issue. The same logging can be enabled through debug.enabled and debug.logPath in config.json; DEBUG=1 and MARK_SHOT_DEBUG_LOG=/path/to/log remain supported.

• Wayland: Uses PipeWire portal screencast for experimental scrolling capture, grim for wlroots screenshot capture, layer-shell-qt for native overlay, and wl-copy for clipboard persistence.
• GNOME Wayland: Uses the Mark Shot Scroll Helper GNOME Shell extension for scrolling capture. Without the extension, Mark Shot disables the scrolling capture action on GNOME Wayland.
• X11: Uses QScreen::grabWindow for screen capture, fullscreen top-level window for overlay, and xclip for clipboard persistence.
• Windows: Uses Qt's native screen capture and clipboard APIs for the core screenshot, annotation, copy, save, and pin workflows. Linux-specific backends such as PipeWire, xdg-desktop-portal, grim, XCB window detection, LayerShellQt, and GNOME Shell helpers are disabled at build time.
• Linux display server backends are detected at runtime via $XDG_SESSION_TYPE; Windows uses Qt's native platform backend.

• Desktop Entries:
  • mark-shot.desktop: Configures the utility system-wide, triggerable by custom shortcuts.
  • mark-shot-edit.desktop: Registers as an image editor, enabling users to right-click local files in file managers (Dolphin, Nautilus, etc.) and open them directly in annotation mode.
• Ships with scalable vector icons (mark-shot.svg and mark-shot-edit.svg).

On KDE Wayland, Mark Shot can use KWin's org.kde.KWin.ScreenShot2 interface for exact area capture. KWin treats this as a restricted D-Bus interface, so the application must have a desktop entry that declares the permission.

X-KDE-DBUS-Restricted-Interfaces=org.kde.KWin.ScreenShot2

[Desktop Entry]
Type=Application
Name=Mark Shot
Comment=Wayland screenshot selection and annotation tool
Exec=/absolute/path/to/mark-shot
Icon=mark-shot
Terminal=false
Categories=Graphics;Utility;
X-KDE-DBUS-Restricted-Interfaces=org.kde.KWin.ScreenShot2

[Desktop Entry]
Type=Application
Name=Mark Shot Shortcut Service
Exec=/absolute/path/to/mark-shot
Icon=mark-shot
Terminal=false
NoDisplay=true
StartupNotify=false
Categories=Utility;
X-KDE-GlobalAccel-CommandShortcut=true
X-KDE-DBUS-Restricted-Interfaces=org.kde.KWin.ScreenShot2

# Capture screen with interactive region selection
mark-shot

# Capture all outputs on a multi-monitor setup
mark-shot --all-outputs

# Annotate full captured screen directly (skipping selection)
mark-shot --fullscreen

# Start with Move after region selection, Laser in fullscreen, and a red default color
mark-shot --default-tool move --fullscreen-default-tool laser --default-color '#FF4D4D'

# Open and annotate an existing local image file
mark-shot path/to/image.png

# Open an existing image directly as a pinned sticker window
mark-shot --pin-image path/to/image.png

# Force standard XDG window instead of Wayland layer-shell
mark-shot --xdg-window

To bind mark-shot to a system screenshot shortcut, configure your compositor or desktop environment.

Tray mode:

mark-shot --tray

Tray mode registers these global hotkeys by default:

• Ctrl+Alt+S: start region capture.

The tray menu also provides Capture, Fullscreen Capture, and Quit actions.

niri (~/.config/niri/config.kdl):

binds {
    Mod+Shift+S { spawn "mark-shot"; }
}

Hyprland (~/.config/hypr/hyprland.conf):

# Bind Super+Shift+S to start mark-shot selection
bind = SUPER SHIFT, S, exec, mark-shot
# Bind Print key to start mark-shot selection
bind = , Print, exec, mark-shot

Sway / i3 (~/.config/sway/config or ~/.config/i3/config):

# Bind Super+Shift+S to start mark-shot selection
bindsym Mod4+Shift+S exec mark-shot
# Bind Print key to start mark-shot selection
bindsym Print exec mark-shot

GNOME (via custom keyboard shortcut in Settings → Keyboard → Keyboard Shortcuts → Custom Shortcuts).

The right-side action toolbar includes an Extensions button. It reads user-defined commands from ~/.config/mark-shot/extensions.json. The file can be either a JSON array or an object with a commands array.

{
  "commands": [
    {
      "name": "Long screenshot",
      "command": "./target/release/wayscrollshot {slurp}",
      "workingDirectory": "~/Desktop/projects/wayscrollshot",
      "closeOnStart": true
    },
    {
      "name": "OCR selection",
      "command": "ocr-tool {image}",
      "saveImage": true
    }
  ]
}

command is executed through $SHELL -c on Unix-like systems and %COMSPEC% /C on Windows, so shell features work. Use {slurp} to pass the current selection as x,y widthxheight geometry. Use {image} or {imagePath} to pass the current rendered selection as a temporary PNG path, or {imageUrl} for a file:// URL. These placeholders are shell-quoted automatically. Set saveImage or needsImage to true to append the temporary PNG path when no image placeholder is present. workingDirectory and cwd are aliases. closeOnStart defaults to true, hiding and closing Mark Shot before the command starts.

Mark Shot reads application settings from ~/.config/mark-shot/config.json on Linux and the Qt application config directory on other platforms. If the file does not exist, Mark Shot creates a default config.json on first startup. Pinned windows use the OCR and translation settings in the same file. The default OCR helper prefers rapidocr and can fall back to tesseract; the translation helper calls an OpenAI-compatible /chat/completions endpoint.

{
  "env": {
    "QT_FONT_DPI": 96
  },
  "debug": {
    "enabled": false,
    "logPath": ""
  },
  "annotation": {
    "defaultTool": "move",
    "fullscreenDefaultTool": "laser",
    "defaultColor": "#FF4D4D"
  },
  "save": {
    "pathTemplate": "{pictures}/mark-shot/mark-shot-{datetime}.png"
  },
  "capture": {
    "wayland": {
      "kde": {
        "kwinScreenshot": {
          "enabled": true
        }
      }
    }
  },
  "shortcuts": {
    "tools": {
      "pen": "P",
      "rectangle": "R"
    },
    "actions": {
      "copy": "Ctrl+C",
      "save": "Ctrl+S",
      "pin": "Ctrl+P",
      "upload": "Ctrl+U"
    },
    "startup": {
      "colorPicker": "C",
      "ruler": "R",
      "codeScanner": "Q",
      "displayCapture": "D"
    }
  },
  "windows": {
    "tray": {
      "enabled": true
    },
    "hotkeys": {
      "capture": "Ctrl+Alt+S"
    }
  },
  "codeScan": {
    "command": "",
    "timeoutMs": 15000
  },
  "upload": {
    "command": "",
    "timeoutMs": 60000,
    "env": {
      "MARK_SHOT_UPLOAD_URL": "",
      "MARK_SHOT_UPLOAD_FIELD": "image",
      "MARK_SHOT_UPLOAD_API_KEY": "",
      "MARK_SHOT_UPLOAD_AUTH_SCHEME": "Bearer",
      "MARK_SHOT_UPLOAD_URL_PATH": "",
      "MARK_SHOT_UPLOAD_DELETE_URL_PATH": ""
    }
  },
  "pinnedWindow": {
    "autoOcr": false,
    "alwaysOnTop": true,
    "border": true,
    "borderColor": "#5EEAD4",
    "borderWidth": 2
  },
  "scrollCapture": {
    "frame": 5,
    "previewGap": 5,
    "hidePreviewDuringCapture": false
  },
  "windowDetection": {
    "enabled": true,
    "command": "mark-shot-window-detection-niri",
    "env": {
      "MARK_SHOT_NIRI_PANEL_EDGE": "top",
      "MARK_SHOT_NIRI_OFFSET_Y": 0
    },
    "timeoutMs": 1000
  },
  "ocr": {
    "enabled": true,
    "backend": "rapidocr",
    "command": "",
    "timeoutMs": 30000
  },
  "translation": {
    "autoAfterOcr": false,
    "targetLanguage": "Simplified Chinese",
    "apiBase": "https://api.openai.com/v1",
    "apiKeyEnv": "OPENAI_API_KEY",
    "apiKey": "",
    "model": "gpt-4o-mini",
    "temperature": 0.2,
    "timeoutMs": 60000,
    "timeoutSeconds": 60,
    "systemPrompt": "",
    "command": ""
  }
}

Mark Shot remembers the most recently used annotation tool defaults and restores them on the next launch, so the toolbar reflects the saved styles from the very first paint.

State is written to a dedicated file at ~/.config/mark-shot/annotation-state.json (Linux) or the Qt application config directory on other platforms. The file is independent from config.json: it only stores transient tool defaults and can be deleted at any time to reset the editor to its built-in defaults.

The persisted snapshot covers:

• Active drawing color and opacity, plus text background color.
• Per-tool widths: pen, shape, number, mosaic block size, laser.
• Rectangle fill, corner radius, and style (Stroke / Highlight / Invert).
• Magnifier scale and lens shape (Circle / Rectangle).
• Arrow style, highlighter style, and number badge style.
• Text font family.

Writes go through QSaveFile for atomic commits and are triggered immediately after every default-changing entry point (slider release, picker confirm, style toggle, font selection, color palette pick, etc.), so a crash never leaves the file half-written. Application-wide settings such as shortcuts, save path templates, OCR, translation, and upload remain in config.json.

The upload section configures the sidebar upload action. When upload.command is empty, Mark Shot uses the bundled mark-shot-upload helper, which reads its behavior entirely from environment variables in upload.env. This keeps the config clean—no long shell commands needed.

{
  "upload": {
    "timeoutMs": 60000,
    "env": {
      "MARK_SHOT_UPLOAD_URL": "https://www.imgurl.org/api/v3/upload",
      "MARK_SHOT_UPLOAD_FIELD": "file",
      "MARK_SHOT_UPLOAD_API_KEY": "sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
      "MARK_SHOT_UPLOAD_URL_PATH": "data.url"
    }
  }
}

{
  "upload": {
    "env": {
      "MARK_SHOT_UPLOAD_URL": "https://sm.ms/api/v2/upload",
      "MARK_SHOT_UPLOAD_FIELD": "smfile",
      "MARK_SHOT_UPLOAD_API_KEY": "your-token",
      "MARK_SHOT_UPLOAD_AUTH_SCHEME": "",
      "MARK_SHOT_UPLOAD_URL_PATH": "data.url"
    }
  }
}

{
  "upload": {
    "env": {
      "MARK_SHOT_UPLOAD_URL": "https://api.imgbb.com/1/upload?key=YOUR_API_KEY",
      "MARK_SHOT_UPLOAD_FIELD": "image",
      "MARK_SHOT_UPLOAD_URL_PATH": "data.url",
      "MARK_SHOT_UPLOAD_DELETE_URL_PATH": "data.delete_url"
    }
  }
}

{
  "upload": {
    "command": "curl -sf --max-time 30 -A 'Mozilla/5.0' -F reqtype=fileupload -F time=72h -F fileToUpload=@{image} https://litterbox.catbox.moe/resources/internals/api.php",
    "timeoutMs": 35000
  }
}

Custom command output format: If you set upload.command to a custom script, it must print the URL to stdout. Both JSON ({"url": "https://..."}) and plain text (a line starting with http:// or https://) are accepted.

To ensure precise window boundary detection across different Wayland compositors, Mark Shot uses a flexible external script invocation mechanism. Users can configure a detection script via windowDetection.command. The script is responsible for querying window geometries from the compositor and outputting the data in a unified format for Mark Shot to consume.

Mark Shot also auto-selects the matching detection script at runtime by probing the current desktop environment (XDG_SESSION_TYPE, XDG_CURRENT_DESKTOP, etc.). Supported environments are GNOME, KDE Plasma, Hyprland, and Niri; other Wayland sessions fall back to the niri script, and X11 sessions use the built-in native X11 detector (empty command). If the configured windowDetection.command does not match the current environment, Mark Shot corrects it in memory without modifying your config.json, so manual configuration is optional.

The project bundles default window detection scripts for the following window managers:

• Niri: mark-shot-window-detection-niri
• Hyprland: mark-shot-window-detection-hyprland
• GNOME Wayland: mark-shot-window-detection-gnome (requires the bundled GNOME Shell helper extension)
• KDE Plasma / KWin: mark-shot-window-detection-kde

{
  "windows": [
    {
      "x": 100,
      "y": 150,
      "width": 800,
      "height": 600
    },
    {
      "left": 950,
      "top": 150,
      "w": 400,
      "h": 300
    },
    {
      "at": [100, 800],
      "size": [800, 450]
    },
    {
      "rect": [950, 800, 400, 300]
    },
    {
      "geometry": "100,1300 800x600"
    },
    [950, 1300, 400, 300]
  ]
}

When installing manually, install mark-shot, mark-shot-ocr, mark-shot-code-scan, mark-shot-translate, and mark-shot-upload together. Otherwise OCR, code scanning, translation, or image upload cannot call the backend helpers.

Arch Linux users can install directly from the AUR using helpers like paru or yay:

# Build from source
paru -S mark-shot
# or
yay -S mark-shot

# Install the prebuilt binary package instead
paru -S mark-shot-bin
# or
yay -S mark-shot-bin

mark-shot compiles from source; mark-shot-bin downloads the prebuilt pacman package from GitHub Releases.

For other distributions (such as Debian, Ubuntu, or Fedora), download the compiled package from the Releases page and install it via:

• Debian / Ubuntu:

  sudo apt install ./mark-shot_<version>_amd64.deb

• Fedora:

  sudo dnf install ./mark-shot-<version>-1.x86_64.rpm

The official .deb package is built on a Debian 12 compatibility baseline. It intentionally avoids linking the optional LayerShellQt plugin so that Deepin and other Debian-derived systems with Qt 6.8-era packages can install it without Ubuntu t64 or newer GCC runtime dependencies.

sudo pacman -S --needed base-devel cmake ninja pkgconf qt6-base qt6-wayland layer-shell-qt pipewire grim wl-clipboard

# Build essentials
sudo apt install build-essential cmake ninja-build pkg-config libpipewire-0.3-dev

# Portal and clipboard tools
sudo apt install xdg-desktop-portal pipewire xclip

# Qt 6 (if not available in system repos, install via aqtinstall)
pip install aqtinstall
aqt install-qt linux desktop 6.7.3 gcc_64 --outputdir ~/Qt

Note: On Ubuntu 22.04 where the system ships Qt 5, installing Qt 6 to ~/Qt keeps the system untouched. Pass -DCMAKE_PREFIX_PATH=$HOME/Qt/6.7.3/gcc_64 when configuring.

Qt 6 does not ship a fcitx5 input context plugin. To enable Chinese input, build the plugin from source:

sudo apt install libfcitx5utils-dev libfcitx5config-dev libfcitx5core-dev libfcitx5-qt-dev extra-cmake-modules

git clone --depth 1 --branch 5.0.10 https://github.com/fcitx/fcitx5-qt.git /tmp/fcitx5-qt
cmake -B /tmp/fcitx5-qt/build -S /tmp/fcitx5-qt \
  -DCMAKE_PREFIX_PATH=$HOME/Qt/6.7.3/gcc_64 \
  -DENABLE_QT4=OFF -DENABLE_QT5=OFF -DENABLE_QT6=ON
cmake --build /tmp/fcitx5-qt/build

cp /tmp/fcitx5-qt/build/qt6/platforminputcontext/libfcitx5platforminputcontextplugin.so \
   ~/Qt/6.7.3/gcc_64/plugins/platforminputcontexts/
cp /tmp/fcitx5-qt/build/qt6/dbusaddons/libFcitx5Qt6DBusAddons.so* \
   ~/Qt/6.7.3/gcc_64/lib/

python3 -m venv ~/.local/share/mark-shot/ocr-venv
~/.local/share/mark-shot/ocr-venv/bin/pip install -U pip rapidocr onnxruntime

python3 -m venv ~/.local/share/mark-shot/code-scan-venv
~/.local/share/mark-shot/code-scan-venv/bin/pip install -U pip zxing-cpp pillow

The code scanner helper prefers zxing-cpp for QR Code, Data Matrix, Aztec, PDF417, EAN, UPC, Code 39, Code 93, Code 128, and other common formats. It can also fall back to pyzbar or OpenCV QR detection when those packages are available.

The image upload feature uses the bundled mark-shot-upload Python script by default. It has no third-party dependencies (Python 3 standard library only) and is configured entirely through environment variables in upload.env. See the Image Upload Configuration section above for supported keys and provider examples.

For providers that return a plain-text URL instead of JSON (e.g. litterbox), set upload.command to a custom curl invocation—Mark Shot auto-detects any stdout line starting with http:// or https:// as the upload result.

Install Qt 6 for your compiler toolchain, CMake, Ninja, and a C++17 compiler such as MSVC or MinGW. The Windows build does not require Qt DBus, PipeWire, X11/XCB, LayerShellQt, grim, wl-copy, or xclip.

cmake -S . -B build-windows -G Ninja -DCMAKE_BUILD_TYPE=Release `
  -DCMAKE_PREFIX_PATH=C:\Qt\6.7.3\msvc2019_64
cmake --build build-windows

Windows support currently targets normal screenshots and image annotation. Scrolling capture, compositor-specific window detection, Linux desktop entries, and bundled Linux helper scripts are not installed on Windows.

# With system Qt 6
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release

# If Qt 6 is installed under the user directory, add CMAKE_PREFIX_PATH
cmake -S . -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \
  -DCMAKE_PREFIX_PATH=$HOME/Qt/6.7.3/gcc_64

# Build
cmake --build build

LayerShellQt is detected automatically. When found, full Wayland layer-shell support is enabled. When absent, the build succeeds and falls back to standard fullscreen windows at runtime.

cmake --install build --prefix "$HOME/.local"

This installs the binary, helper scripts (mark-shot-ocr, mark-shot-code-scan, mark-shot-translate, mark-shot-upload), desktop entries, and icons.

GNOME Wayland scrolling capture requires the Mark Shot Scroll Helper extension. Without it, Mark Shot cannot perform silent repeated area screenshots or display the GNOME-native scroll preview panel, causing the scrolling capture action to be disabled on GNOME Wayland.

The extension files are bundled in the project repository at packaging/gnome-extension/mark-shot-scroll-helper@snemc.org.

gnome-extensions enable mark-shot-scroll-helper@snemc.org

# Define the extension UUID
UUID=mark-shot-scroll-helper@snemc.org

# Create the user GNOME extensions directory
mkdir -p "$HOME/.local/share/gnome-shell/extensions"

# Copy the extension files from the repository
cp -r "packaging/gnome-extension/$UUID" "$HOME/.local/share/gnome-shell/extensions/"

# Enable the extension (you may need to restart GNOME Shell or log out and back in)
gnome-extensions enable "$UUID"

gdbus call --session \
  --dest org.gnome.Shell \
  --object-path /org/gnome/Shell/Extensions/MarkShotScrollHelper \
  --method org.gnome.Shell.Extensions.MarkShotScrollHelper.Version

• Constrain Drawing: Hold Ctrl while drawing Rectangles or Ellipses to constrain them to perfect squares or circles.
• Quick Select Tool: Right-click once on the canvas to switch to the Select tool instantly.
• Quick Color Switch: Double right-click on the canvas to open the radial color palette and quickly switch the active annotation color.
• Scroll Wheel Regulation: While a drawing tool is active, scroll the mouse wheel to dynamically adjust stroke width, text size, auto-increment number scale, or mosaic block size.
• Canvas Zoom & Pan: Under Select tool (or in local image mode), scroll the mouse wheel to zoom the canvas, and hold the middle mouse button to pan. Double-tap Ctrl to reset zoom and pan.

• Startup Shortcut Hint Panel: Replaced the centered startup hint pill with a PixPin-style vertical shortcut panel that defaults to the left-bottom corner and moves to the left-top corner when the pointer approaches it.
• Input Device Hints: Added keyboard, mouse, and mouse-wheel glyphs to the startup shortcut panel so shortcut rows communicate the expected input method more clearly.
• Window Z-Order Selection: Improved window ordering across GNOME, KDE Plasma, Hyprland, X11, and Windows so region selection prefers the visually topmost matching window.
• Wayland Fcitx5 Candidate Support: Adjusted layer-shell cursor-rectangle handling so fcitx5 candidate windows appear correctly under Wayland capture overlays.
• Settings Gear Icons: Redrew the settings toolbar and General settings navigation icons as clearer gear glyphs instead of sun-like radial icons.
• Tray Mode Compatibility: Fixed startup behavior when Mark Shot is launched directly into tray mode on environments without an immediately available system tray.
• Wayland Text Editor Width: Prevented the annotation text editor from shrinking unexpectedly on fractional-scale Wayland displays.

If you encounter bugs or want to suggest new features, we recommend using GitHub CLI (gh) tool to submit an Issue. We provide templates and a script to automatically collect system information. For details, please refer to the Issue Submission Guide.

This project is licensed under the MIT License. For details, please refer to the LICENSE file.

linux.do Thanks to the promotion from the linux.do community

Thanks to serendipitywgy for contributions from serendipitywgy/mark-shot, including cross-desktop compatibility improvements, the OCR copy toolbar action, and smart rectangle preselection.