Skip to main content
Glama

Redline ✎

Mark up your screen, and let your AI agent make the UI changes.

Release Downloads Website License: MIT

A real-time visual feedback tool for AI-driven frontend development. Triggered by a hotkey, it lets you draw and annotate UI/UX changes directly on your screen—from layout fixes to styling tweaks. The Electron menu-bar app and built-in MCP server feed annotated screenshots straight to Claude or any AI agent to apply code changes instantly.

Redline is a small desktop app plus an MCP server. Press a hotkey, draw boxes, arrows and pins on whatever is on screen, and write what should change. Then tell Claude, ChatGPT, Antigravity or any MCP-capable agent "apply my latest Redline". The agent gets the annotated screenshot, a zoomed crop of every mark and exact coordinates. It finds the matching code, makes the changes and reports back per mark, and you confirm each one in the app.

⌥⇧M / Alt+Shift+M  ──►  freeze-frame of the screen under your cursor
                        draw: Box (R) · Arrow (A) · Pen (P) · Pin (I), add a comment to each mark
                        ⌘↵ / Ctrl+Enter save   Esc cancel   ⌘Z / Ctrl+Z undo   N = overall note   H = history
                   ──►  ~/.redline/requests/<id>/
                   ──►  Redline MCP  →  agent reads the request, edits code, sets each mark to "review"
                   ──►  you click ✓ Looks good  (or ↺ Not done)

Download

v0.0.1-beta (pre-release) · all releases

Platform

Installer

macOS · Apple silicon

Redline-0.0.1-beta-mac-arm64.dmg

macOS · Intel

Redline-0.0.1-beta-mac-x64.dmg

Windows 10 / 11 · x64

Redline-0.0.1-beta-win-x64.exe

Linux · x64 (any distro)

Redline-0.0.1-beta-linux-x86_64.AppImage

Linux · Debian / Ubuntu

Redline-0.0.1-beta-linux-amd64.deb

The builds are not code-signed yet, so the first launch shows a security prompt (macOS: System Settings → Privacy & Security → Open Anyway; Windows: More info → Run anyway). The app includes the MCP server: open Connect an agent from the menu-bar / tray icon to set up Claude, Codex, Cursor and others.

Related MCP server: redpen

Contents

Why

Describing visual tweaks in words ("the button under the subtitle, make it a bit smaller") is slow and easy to get wrong. With Redline you point at the thing. The agent gets the picture, the location and the context (app, window title, browser URL), so it knows exactly what you mean.

Features

  • Global hotkey capture. Freezes the display under your cursor, so you can annotate anything: a browser tab, a native app, a design file.

  • Four mark types: box, arrow, freehand pen and pin. Each one is numbered, color-coded and has its own comment.

  • Output that vision models can read: an annotated image with comments drawn in, a downscaled preview, a zoomed crop per mark, and a structured description with pixel and normalized coordinates.

  • Per-mark status tracking: open → in_progress → review → done, plus partial and wontfix. Agents leave notes that you see in the app.

  • History view. Reopen any request, move or resize marks, edit comments, confirm or reject the agent's work, or delete requests.

  • Context capture (macOS). It records the frontmost app, window title and browser URL.

  • Local and private. Requests are plain files on your disk. The app and the MCP server share one folder, and nothing is uploaded unless you expose the server yourself.

Platform support

macOS

Windows

Linux

Capture, markup, history

✅ tested

✅ should work

✅ X11 · ⚠️ Wayland (see below)

Global hotkeys

✅

✅

✅ X11 · ⚠️ Wayland

App / window / URL context

✅

—

—

MCP server

✅

✅

✅

Redline is built on Electron and developed on macOS. Windows and Linux use the same code path for screen capture and hotkeys, but they have had less testing, so please open an issue if something breaks. On Linux Wayland, screen capture goes through the desktop portal (you may see a "share screen" prompt), and global hotkeys may not register. If they don't, bind npm run app -- --capture to a shortcut in your desktop environment's keyboard settings, or log in with an X11 session.

Install

You need Node.js 18 or newer (developed on Node 24) and git.

git clone https://github.com/sislamrafi/redline.git
cd redline/desktop-app
npm install

All commands below run from desktop-app/.

npm install also downloads Electron for your OS.

Run the desktop app

Redline runs in the background with a ✎ icon in the menu bar (macOS) or system tray (Windows and Linux). It keeps running until you choose Quit from that icon, so capture is always one hotkey away.

Action

macOS

Windows / Linux

Mark up the screen

⌥⇧M

Alt+Shift+M

Open history

⌥⇧H

Alt+Shift+H

The same commands work on every OS:

npm run app                 # start Redline in the background (tray icon + hotkeys)
npm run app -- --capture    # trigger a capture (from a launcher, script or custom shortcut)
npm run app -- --history    # open the history
npm run app -- --selftest   # render a demo request without touching the screen, then quit

If Redline is already running, --capture and --history are passed to the running copy, so you can bind them to Raycast, Alfred, AutoHotkey or your desktop's custom shortcuts.

macOS

cd ~/path/to/redline/desktop-app
npm run app
  • The first capture needs Screen Recording permission: open System Settings → Privacy & Security → Screen Recording and allow Electron, or the terminal you started Redline from. Then quit and restart Redline.

  • Reading the window title and browser URL may ask for Accessibility or Automation access. This is optional; capture works without it.

With npm run app, macOS ties the Screen Recording permission to whatever launched it (Terminal, VS Code, Claude…). To give Redline its own entry in Privacy settings, build a real app bundle:

npm run mac:install   # builds dist/mac-arm64/Redline.app, copies it to /Applications and opens it

Then allow Redline under System Settings → Privacy & Security → Screen Recording and restart it.

The bundle is only a thin launcher (build/mac-loader.cjs): it loads app/main.js from this checkout, so code edits take effect the next time you quit and reopen Redline, with no rebuild needed and the permission kept. Rebuild only after moving the repo or upgrading Electron. You can point it at another checkout with REDLINE_SRC=/path/to/redline/desktop-app.

Windows

In PowerShell or Command Prompt:

cd C:\path\to\redline\desktop-app
npm run app
  • No extra permission is needed for screen capture.

  • If Alt+Shift+M clashes with another app (some keyboard layouts use Alt+Shift to switch language), choose another hotkey:

    $env:REDLINE_HOTKEY="Control+Shift+M"; npm run app
  • The tray icon may be hidden under the ^ overflow arrow in the taskbar.

Linux

cd ~/path/to/redline/desktop-app
npm run app
  • On Ubuntu 24.04 and other distros that restrict unprivileged user namespaces, Electron may stop with a sandbox error. Run it with npm run app -- --no-sandbox, or fix the permissions on node_modules/electron/dist/chrome-sandbox as the error message describes.

  • GNOME doesn't show tray icons by default. Install the AppIndicator and KStatusNotifierItem Support extension to see the ✎ icon. The hotkeys work without it.

  • On Wayland, see Platform support.

Start automatically at login

To have Redline always ready, start it when you log in. In each example, replace /path/to/redline/desktop-app with the desktop-app folder inside the repo you cloned.

macOS: Launch Agent

Create ~/Library/LaunchAgents/com.redline.app.plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
  <key>Label</key><string>com.redline.app</string>
  <key>ProgramArguments</key>
  <array>
    <string>/path/to/redline/desktop-app/node_modules/.bin/electron</string>
    <string>/path/to/redline/desktop-app</string>
  </array>
  <key>RunAtLoad</key><true/>
  <key>KeepAlive</key><false/>
</dict>
</plist>
launchctl load ~/Library/LaunchAgents/com.redline.app.plist

To stop it starting at login: launchctl unload ~/Library/LaunchAgents/com.redline.app.plist.

Windows: Startup folder

  1. Press Win+R, type shell:startup and press Enter.

  2. In that folder, create redline.vbs with the following content. It starts Redline without leaving a console window open.

    Set sh = CreateObject("WScript.Shell")
    sh.CurrentDirectory = "C:\path\to\redline\desktop-app"
    sh.Run "cmd /c npm run app", 0, False

To stop it starting at login, delete redline.vbs.

Linux: XDG autostart

Create ~/.config/autostart/redline.desktop:

[Desktop Entry]
Type=Application
Name=Redline
Comment=Mark up your screen for AI agents
Exec=/path/to/redline/desktop-app/node_modules/.bin/electron /path/to/redline/desktop-app
X-GNOME-Autostart-enabled=true

Add --no-sandbox to the end of the Exec line if you needed it above. To stop it starting at login, delete the file.

Connect the MCP server

Easiest: the first time Redline starts, it opens a setup guide (later: tray menu → Connect an agent…, or Connect agent in History). Pick your agent (Claude Code, Cursor, Codex, Windsurf, Antigravity, Claude Desktop, VS Code, ChatGPT…), copy the command-line command or the prompt into your agent, and the guide shows ✓ as soon as the agent connects. The steps below do the same by hand.

The MCP server is desktop-app/mcp/server.js. It talks over stdio and reads the same ~/.redline folder as the app. Every client below needs the absolute path to that file:

OS

Example path

macOS

/Users/you/redline/desktop-app/mcp/server.js

Linux

/home/you/redline/desktop-app/mcp/server.js

Windows

C:/Users/you/redline/desktop-app/mcp/server.js (forward slashes, or \\ in JSON)

The desktop app doesn't need to be running for the MCP server to work. It only has to be running when you want to capture new markups.

Claude Code

Available in every project (recommended):

claude mcp add --scope user redline -- node /absolute/path/to/redline/desktop-app/mcp/server.js

Check that it connected:

claude mcp list

To add it to one project only, run the command inside that project with --scope project instead. This writes a .mcp.json file that you can commit. In the Claude desktop app's Code tab, the servers you add with claude mcp add are picked up automatically.

The /redline command (recommended)

Install a short slash command so you don't have to remember the MCP prompt names:

cd desktop-app && npm run claude:command   # copies claude/commands/redline.md to ~/.claude/commands/

Then in Claude Code:

Type

What it does

/redline

Apply your latest markup and report back per mark

/redline all

Apply every open request

/redline list

Show all requests and their status

/redline check

Summarize what's waiting for your confirmation

/redline <id>

Apply one specific request

/redline only mark 2, use Tailwind

Apply the latest with extra instructions

The server also tells the agent what Redline is, so plain phrases like "apply my latest redline" or "fix my markup" work too. The MCP prompts are available as /mcp__redline__apply, /mcp__redline__list and /mcp__redline__check.

Claude Desktop (chat)

Open Settings → Developer → Edit Config, or edit the file directly:

OS

Config file

macOS

~/Library/Application Support/Claude/claude_desktop_config.json

Windows

%APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "redline": {
      "command": "node",
      "args": ["/absolute/path/to/redline/desktop-app/mcp/server.js"]
    }
  }
}

Fully quit and reopen Claude Desktop. The Redline tools then appear in the tools menu of the chat box. Claude Desktop isn't available for Linux; use Claude Code there.

ChatGPT

ChatGPT connects only to remote MCP servers over HTTPS. It can't start a local stdio server the way Claude does, so you run a small bridge that serves Redline over HTTP and expose it with a tunnel.

⚠️ Privacy: a tunnel URL makes your screenshots readable by anyone who has the URL, and this bridge has no authentication. Only run it while you use it, keep the URL private, and stop the tunnel afterwards.

  1. Serve Redline over HTTP with supergateway:

    npx -y supergateway --stdio "node /absolute/path/to/redline/desktop-app/mcp/server.js" \
      --outputTransport streamableHttp --port 8787

    On Windows PowerShell, put it on one line and leave out the \.

  2. Give it a public HTTPS URL in a second terminal, with cloudflared (free, no account needed for quick tunnels) or ngrok:

    cloudflared tunnel --url http://localhost:8787

    It prints a URL like https://random-words.trycloudflare.com.

  3. Add it in ChatGPT: go to Settings → Apps & Connectors → Advanced, turn on Developer mode, then create a connector:

    • MCP Server URL: https://random-words.trycloudflare.com/mcp

    • Authentication: none

    Developer mode needs a paid plan, and on Business, Enterprise and Edu an admin may have to allow it. Menu names change from time to time; see OpenAI's help center if yours look different.

  4. In a new chat, turn on the Redline connector and ask: "Use Redline to show my latest edit request."

ChatGPT can read your markups this way, but it can't edit the code on your computer. To have changes applied to your code, use an agent that runs locally, such as Claude Code, Codex CLI or Antigravity.

OpenAI Codex CLI

Codex CLI runs locally and supports stdio servers directly. Add this to ~/.codex/config.toml (%USERPROFILE%\.codex\config.toml on Windows):

[mcp_servers.redline]
command = "node"
args = ["/absolute/path/to/redline/desktop-app/mcp/server.js"]

Or from the terminal:

codex mcp add redline -- node /absolute/path/to/redline/desktop-app/mcp/server.js

Google Antigravity

  1. In the Agent panel, open the ⋮ menu → MCP Servers → Manage MCP Servers → View raw config. This opens mcp_config.json. Depending on your version, it's at ~/.gemini/config/mcp_config.json or ~/.gemini/antigravity/mcp_config.json. On Windows, ~ is %USERPROFILE%.

  2. Add Redline under mcpServers:

    {
      "mcpServers": {
        "redline": {
          "command": "node",
          "args": ["/absolute/path/to/redline/desktop-app/mcp/server.js"]
        }
      }
    }
  3. Save the file and click Refresh in Manage MCP Servers. Redline's four tools should be listed.

To add Redline to one workspace only, put the same JSON in .agents/mcp_config.json in that project.

Other MCP clients

Cursor, Windsurf, VS Code (Copilot), Cline, Zed and others use the same command / args entry. Look for "MCP servers" in their settings and point it at node /absolute/path/to/redline/desktop-app/mcp/server.js.

Using it

This walkthrough follows one real request: making a heading on a web page a little bigger.

Step 1: Add the Redline MCP to Claude (one-time setup)

Your agent can only see your markups after the Redline MCP is added. Do this once, before your first request:

claude mcp add --scope user redline -- node /absolute/path/to/redline/desktop-app/mcp/server.js
claude mcp list        # should show: redline … ✓ Connected

For Claude Desktop, ChatGPT, Codex CLI or Antigravity, see Connect the MCP server. Also make sure the desktop app is running (npm run app); look for the ✎ icon in the menu bar or tray.

Step 2: Mark up the screen

Open the page or app you want to change and press ⌥⇧M (macOS) or Alt+Shift+M (Windows/Linux). The screen freezes and the Redline toolbar appears at the top.

  1. Choose a tool: Box (R), Arrow (A), Pen (P) or Pin (I).

  2. Click or drag on the thing you want changed. A numbered mark appears.

  3. Type what should change in the comment box, for example "make this text a little bigger". Set the status there too, or delete the mark.

  4. Add more marks if you need them. To give the whole request a note, type it in the Overall request field in the toolbar, or press N.

  5. Click Save, or press ⌘↵ / Ctrl+Enter. Press Esc to cancel.

Marking up a web page: a red pin on the "Meet Poshak AI Agent" heading with the comment "make this text a little bigger"

Step 3: Check it in the history

Press ⌥⇧H / Alt+Shift+H, or click History in the toolbar, to see every request. The tabs sort them by where they stand:

Tab

Meaning

To do

New requests, and requests the agent is still working on

Confirm

The agent says it's finished; waiting for you to check

Done

You confirmed the result

All

Everything

Each card shows the screenshot, your first comment, the app it came from, and how many marks are finished. Click a card to reopen the request and edit it.

The History panel with the new request "make this text a little bigger" listed under To do

Step 4: Ask Claude to apply it

Open Claude in the project that contains that UI (here, the website's code) and ask in plain words:

read the Redline comments and fix the things mentioned there

In Claude Code just type /redline (see the /redline command), or say "apply my latest Redline".

Asking Claude in the Code tab: "read the redline comments and fix the things mentioned there"

Claude then:

  1. calls get_edit_request and receives the annotated screenshot, a zoomed crop of each mark and its coordinates;

  2. finds the matching code from the visible text, the page URL and the layout, and makes the change;

  3. calls update_edit_request_status to move each mark to Waiting for confirmation, with a note naming the file it changed.

Step 5: Confirm the result

Reload the page and check the change. In the History, the request is now under Confirm. Open it, click a mark, and choose ✓ Looks good (or Confirm all). If it isn't right, choose ↺ Not done and add a comment saying what's still wrong. The mark goes back to To do, and the next time you ask, Claude picks it up again.

MCP reference

Tool

What it does

list_edit_requests

Lists requests, newest first. Filter by active (the default), open, in_progress, partial, review, done, wontfix or all.

get_edit_request

Returns the annotated preview, a crop per unfinished mark and a structured description. id defaults to latest. Optional: include_crops, include_original, mark_in_progress.

update_edit_request_status

Sets the status of individual marks and/or the whole request, with notes the user sees.

delete_edit_request

Permanently deletes a request and its images. Use it only when the user asks.

Prompt

What it does

apply

Fetches the latest request, implements each unfinished mark in the current codebase and reports per mark (apply_latest still works).

list

Lists every request with its status.

check

Summarizes what's waiting for your confirmation.

Agents set finished marks to review, not done. You confirm them in the app. If you edit or move a mark, it goes back to open, so the next agent picks it up again.

Storage layout

~/.redline/requests/<id>/
  request.json      marks (pixel + normalized coords), comments, status, app/window/URL context
  screenshot.png    untouched original
  annotated.png     numbered, color-coded marks with comment callouts (full resolution)
  preview.png       the same image, ≤1600px wide (what the MCP server sends)
  crops/mark-N.png  zoomed crop around each mark
  prompt.md         a description that ties each #N and its color to a location

On Windows, ~ is your user folder (C:\Users\you\.redline).

Configuration

Variable

Default

Purpose

REDLINE_HOTKEY

Alt+Shift+M

Capture hotkey (Electron accelerator syntax, e.g. CommandOrControl+Shift+2)

REDLINE_HISTORY_HOTKEY

Alt+Shift+H

History hotkey

REDLINE_HOME

~/.redline

Storage folder, used by both the app and the MCP server

If you change REDLINE_HOME, set it for the MCP server too: add "env": { "REDLINE_HOME": "..." } to the server entry in your MCP config.

An existing ~/.annotation-mcp folder from older versions is moved to ~/.redline automatically.

Project structure

desktop-app/           the installable Redline app + MCP server (run npm commands here)
  app/
    main.js            Electron tray app: hotkeys, screen capture, windows, IPC
    preload.cjs        bridge between the renderer and main process
    renderer/          markup editor and history UI (HTML/CSS/JS)
  mcp/server.js        MCP server (stdio)
  shared/store.js      on-disk store and status logic, shared by the app and the server
  scripts/
    mcp-smoke.js       end-to-end smoke test against the MCP server
    mcp-call.js        call one MCP tool from the CLI: node scripts/mcp-call.js <tool> '<json>' [outDir]
  build/               icons, electron-builder hooks, local macOS launcher
portfolio-website/     the redlinez.org landing page (static HTML/CSS/JS, no build step)
docs/images/           screenshots used in this README

Development

npm run mcp                   # run the MCP server on stdio
node scripts/mcp-smoke.js     # list tools, fetch the latest request and update its status

The smoke test changes the status of your latest request to done. Point REDLINE_HOME at a scratch folder if you don't want that.

Issues and pull requests are welcome.

Building installers and releases

Release builds bundle the app code (unlike the local npm run mac:install launcher) and are configured in the build section of package.json:

npm run dist:mac     # dist/Redline-<version>-mac-arm64.dmg and -mac-x64.dmg
npm run dist:win     # dist/Redline-<version>-win-x64.exe (NSIS installer); build on Windows
npm run dist:linux   # dist/Redline-<version>-linux-x86_64.AppImage and -linux-amd64.deb; build on Linux

To publish a GitHub Release, bump the version and push the tag. The Release workflow builds on macOS, Windows and Linux and attaches every installer to one draft release. Review it on GitHub, then click Publish release. Tags with a suffix such as v0.0.1-beta are marked as pre-releases.

cd desktop-app && npm version 0.2.0 --no-git-tag-version && cd ..
git commit -am "Release v0.2.0" && git tag v0.2.0 && git push && git push origin v0.2.0

The builds are not signed with an Apple Developer ID or a Windows code-signing certificate, so first launch shows a warning:

  • macOS: "Redline can't be opened / is damaged". Open it once from System Settings → Privacy & Security → Open Anyway, or run xattr -dr com.apple.quarantine /Applications/Redline.app.

  • Windows: SmartScreen "Windows protected your PC". Click More info → Run anyway.

The installers contain the desktop capture app only. The MCP server is still run from a checkout (see Connect the MCP server).

License

Redline is released under the MIT License. © 2026 S Islam Rafi.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers