JetBrains IDE History vs a System Clipboard Manager: Which Wins?

JetBrains IDEs — IntelliJ IDEA, PyCharm, WebStorm, Rider, GoLand, CLion, PhpStorm, RubyMine, Android Studio — ship with a built-in clipboard history that is scoped to the project, not to the OS. This is a meaningful distinction. A developer working on three projects in three IDE windows has three independent clipboard histories, one per project. The OS clipboard (Win+V, Ditto, CopyQ, Edge-Drop) sees everything, regardless of which project the copy came from. The two layers solve different problems, and developers who try to use only one end up fighting the tool.

This guide compares JetBrains' built-in clipboard history with an OS-level shelf or manager, and explains when each wins. It is written for developers using JetBrains IDEs alongside terminals, browsers, and chat. For neighbouring topics, see VS Code: built-in clipboard ring vs an OS manager, git paths, SHAs, and PR URLs: a pin set, and best clipboard habits for developers in 2026.

What JetBrains clipboard history does

JetBrains IDEs expose clipboard history via Ctrl+Shift+V (Windows/Linux) or Cmd+Shift+V (macOS). The shortcut opens a dialog listing recent copies made within the current project. The default history size is 5 items, configurable in Settings → Editor → General → Maximum number of contents to keep in clipboard.

Key behaviours:

• Project-scoped. Copies made in project A's IDE window do not appear in project B's clipboard history dialog. Each project has its own history.
• Editor-scoped within the project. Copies made in the editor, the run console, the terminal panel, and other IDE panels are all added to the history. Copies made in external apps are not.
• Selectable via dialog. The dialog shows the first line of each item plus a preview. Selection is by mouse or arrow keys, not by cycling.
• Configurable size. The default of 5 is small for real development; raising it to 20 or 50 is a common first-week setting change.

The dialog model is different from VS Code's cycle model. VS Code cycles through items in place at the cursor; JetBrains shows a list and asks the developer to choose. The list is slower for the last 2-3 items but faster for older items, because the developer can see all of them at once.

What an OS shelf or manager does

An OS-level clipboard manager — Win+V (built into Windows), Ditto, CopyQ, or Edge-Drop — tracks copies across all apps. Win+V shows the last 25 items as a searchable panel. Ditto extends the history to hundreds or thousands of items with full-text search. CopyQ adds scripting and transformation rules. Edge-Drop adds spatial access (hover-open edge shelf) and real file drag-out.

The OS layer is OS-scoped: it sees everything, regardless of which app the copy came from. The cost is that opening the panel, searching, and clicking takes longer than a keyboard shortcut in the IDE. The OS layer is also subject to its own limits — Win+V's 25-item cap, 4 MB per item, restart-clears-unpinned — and to whatever sync settings the user has enabled.

Where JetBrains' history wins

The project-scoped history is the right tool when:

• The work is happening inside one project. You copied a class name, a method signature, a SQL fragment, an import statement, and a test fixture from within the project. The JetBrains dialog has all of them; the OS panel has all of them plus everything else copied today.
• The copy needs context. The JetBrains dialog shows the project name in the title bar; the OS panel does not. When working across multiple projects, the project context helps confirm "this is the right copy".
• You want to avoid leaking project content into the OS clipboard. A copied API key, a database query with sensitive data, or a proprietary algorithm stays inside the IDE's history. It does not reach Win+V or any other OS-level manager. This is a privacy benefit, not a complete solution (the OS clipboard still receives the most recent copy when the developer pastes), but it does reduce the surface.
• The IDE has a longer effective history than Win+V. With the size raised to 50, the JetBrains dialog holds more project-relevant items than Win+V's 25-item cap allows for cross-app history.

Where an OS shelf wins

An OS-level manager is the right tool when:

• The source is outside the IDE. You copied a stack trace from a terminal, a request URL from a browser, a config block from a chat message. The JetBrains history does not see these.
• The destination is outside the IDE. You are pasting a code snippet into Slack, a SQL query into a database tool, a file path into a Jira ticket. The JetBrains history only pastes into the IDE.
• You need to move content between projects. A copy from project A needs to land in project B. The OS clipboard sees both; the per-project JetBrains histories do not.
• You need search. JetBrains' dialog is a list, not a search. For "the connection string I copied two hours ago", Win+V or Ditto's search is the right tool.
• You need pinning across restarts. OS-level managers support pinning; the JetBrains history clears when the IDE restarts (unless configured otherwise).

The interaction between the two layers

When a developer copies in the IDE, two things happen:

1. The IDE adds the item to its project-scoped history.
2. The IDE writes the item to the OS clipboard, which adds it to whatever OS-level manager is running.

When a developer pastes via Ctrl+V, the IDE reads the current OS clipboard content and pastes it. The IDE's project-scoped history is not consulted for Ctrl+V; only the dialog (Ctrl+Shift+V) consults it.

The implication: the OS clipboard always has the most recent copy, regardless of where it came from. The IDE history has only the IDE-scoped copies. A developer who copies in the browser, switches to the IDE, and presses Ctrl+V will get the browser copy, not the last IDE copy. This is usually what the developer wants, but it can be surprising when the developer expects the IDE history to be the source of truth.

Practical configuration for a JetBrains developer

For a developer using a JetBrains IDE on Windows, the configuration that works:

1. Raise the JetBrains history size in Settings → Editor → General → Maximum number of contents to keep in clipboard. Default is 5; 20 or 50 is more useful.
2. Leave Win+V on with sync off. Use it for cross-app history and search.
3. Learn Ctrl+Shift+V for in-IDE selection from the project-scoped history. Use Ctrl+V for the most recent OS clipboard item.
4. Pin long-lived items in Win+V (a SQL query, a curl command, a test payload) rather than in the JetBrains history, because pinning survives restarts.
5. Promote any snippet used more than once into source control. Neither the JetBrains history nor Win+V is a snippet library. See snippet managers for code: project files win.

This stack uses each layer for what it does well. The JetBrains history is the fast in-project picker; the OS manager is the cross-app and search layer; source control is the persistent snippet store.

What about Rider, Android Studio, and the rest

The clipboard history behaviour is consistent across the JetBrains IDE family because they share the IntelliJ platform. Rider, Android Studio, GoLand, CLion, PhpStorm, RubyMine, and the others all behave the same way: Ctrl+Shift+V opens the project-scoped history dialog, with the same configurable size limit and the same interaction with the OS clipboard. The settings location is the same (Settings → Editor → General), and the keyboard shortcut is the same on Windows and Linux (Cmd+Shift+V on macOS).

The only IDE-specific note is that Android Studio's default keymap sometimes remaps Ctrl+Shift+V to paste-with-formatting; in that case, the clipboard history is available via the Edit menu or via a redefined shortcut. Check the keymap in Settings → Keymap if the shortcut does not open the dialog.

A note on Fleet

JetBrains Fleet, the newer lightweight editor from JetBrains, does not (as of mid-2026) have the same clipboard history dialog as the IntelliJ-family IDEs. Fleet is built on a different architecture and is missing some of the IntelliJ platform features. Developers using Fleet should rely on the OS-level clipboard manager (Win+V, Ditto, CopyQ) for history, and on Fleet's own multi-cursor and smart paste features for in-editor work. This may change as Fleet matures; check the Fleet docs for the current state.

Related reading

• Git Paths, SHAs, and PR URLs: A Pin Set
• WSL and Windows Clipboard: What Crosses the Boundary
• Best Clipboard Habits for Developers in 2026
• Clipboard Tools on Multi-Monitor Windows Setups

Sources

• JetBrains — Clipboard history in IntelliJ IDEA — official documentation for the project-scoped clipboard history dialog, including the configurable size limit
• JetBrains — Editor general settings — official settings reference for the "Maximum number of contents to keep in clipboard" option
• Microsoft Support — Using the clipboard on Windows — official Win+V documentation, including the 25-item cap and pinning
• JetBrains — Fleet documentation — official Fleet documentation, which does not list a clipboard history dialog as of the current version
• JetBrains — IntelliJ Platform SDK — for developers writing plugins that interact with the clipboard; documents the platform APIs the IDE uses for copy and paste

Copy. Stack. Drop.

Transform your clipboard into an interactive edge shelf. Stack, pin, and drag assets into any app with zero friction.

Download for Windows Get from Microsoft Store

How to Install Guide · First 10 Minutes Guide · Drag & Drop Guide · Edge-Drop vs Win+V · Support