How to Measure a Clipboard App's Idle RAM and CPU Yourself

To measure a clipboard app's idle cost, let it run untouched for a few minutes, then add up the memory of every process it runs and count how many CPU-seconds it uses over one quiet minute. Task Manager gives a quick reading; PowerShell's Get-Process gives exact figures you can repeat and compare between apps. Published numbers rarely match your PC, so your own measurement is the one to trust.

What counts as idle

An app is idle when it has been running for a few minutes, you haven't copied anything in the last minute, and its window or panel is closed. Measure straight after launch and you'll catch startup work instead; measure right after a copy and you'll catch the processing of that item.

Quick check in Task Manager

1. Press Ctrl+Shift+Esc to open Task Manager.
2. On the Processes page, find the app. If there's an arrow beside it, the app runs several processes; the collapsed row shows their combined total.
3. Watch the CPU column for a minute. An idle clipboard app should sit at or near 0% almost all of the time.
4. For per-process detail, open the Details page, right-click a column heading, choose Select columns, and add CPU time. This is the total CPU the process has used since it started.

Task Manager's CPU percentage is a share of the whole processor, across all cores. That's why a figure measured as a share of one core, as below, looks larger.

Exact figures with PowerShell

First find the app's process name: on Task Manager's Details page it's the .exe name without the extension, for example Ditto for Ditto.exe.

Memory, summed across all processes

Open PowerShell and run:

$name = 'Ditto'
$p = Get-Process -Name $name
$p | Select-Object Name, Id, @{n='PrivateMB';e={[math]::Round($_.PrivateMemorySize64/1MB,1)}}, @{n='WorkingSetMB';e={[math]::Round($_.WorkingSet64/1MB,1)}}
'{0:N1} MB private memory across {1} process(es)' -f (($p | Measure-Object PrivateMemorySize64 -Sum).Sum / 1MB), $p.Count

• PrivateMB is memory allocated to that process that can't be shared with other processes (the Private Bytes counter). Summing it across processes gives a fair total.
• WorkingSetMB is the physical RAM the process is using right now, including shared pages such as system libraries. Summing working sets overcounts, because shared pages appear in more than one process.

Neither figure is identical to Task Manager's Memory column, so compare apps using the same method each time.

Idle CPU over one minute

$name = 'Ditto'
$before = (Get-Process -Name $name | Measure-Object CPU -Sum).Sum
Start-Sleep -Seconds 60
$after = (Get-Process -Name $name | Measure-Object CPU -Sum).Sum
'{0:N2} CPU-seconds in 60 s ({1:P2} of one core)' -f ($after - $before), (($after - $before) / 60)

Don't touch the app or copy anything while it runs. If one of the app's processes starts or exits during the minute, the result is skewed; run it again.

How to compare apps fairly

Then check two more things. Repeat the memory command after a few hours of normal use: memory that keeps rising and never drops back points to a leak. And copy a large image while Task Manager is open to see the cost under load; why copying a large image spikes CPU explains what you'll see.

Common mistakes

• Measuring one process of a multi-process app. Electron apps run a main process plus a renderer process for each window, so a single row understates the total.
• Summing working sets. Shared pages get counted several times; use private memory for totals.
• Comparing different units. Task Manager's CPU column is a share of all cores; the PowerShell result above is a share of one core.
• Measuring during startup. Wait a few minutes after launch. How much a clipboard app slows startup covers that separately.

Measuring Edge Drop

Edge Drop, the screen-edge clipboard shelf made by the team behind this site, has no published RAM or CPU measurement, so measure it as above. With the GitHub installer build, use Edge-Drop as the process name; as an Electron app it runs several processes. Some small idle activity is expected from its design: it listens for the Windows clipboard-change notification, with a fallback check every 600 ms, and it checks the pointer position every 75 ms on mains power (100 ms on battery) while the pointer is away from its edge, faster when it's near. GPU hardware acceleration is turned off to save memory. How much RAM a clipboard manager should use covers what to do with the numbers you get.

FAQ

Why doesn't my number match the one the developer quotes?

History size, image count, Windows version and how long the app has been running all change the result. Many published figures also don't say what was measured.

Is 1% CPU at idle too much?

Measured as a share of one core over a full minute, a well-behaved clipboard app should use a small fraction of that. Constant activity while you do nothing is worth reporting to the developer.

Can I log the numbers over a whole day?

Yes. Run the memory command at intervals and note the totals, or use Performance Monitor for continuous logging.

Related reading

• How Much RAM Should a Clipboard Manager Use?
• Does a Clipboard Manager Drain Laptop Battery?
• Lightweight Clipboard Managers for Windows (Low-RAM Picks)
• How Much Does a Clipboard App Slow Windows Startup?

Sources

• Get-Process (Microsoft Learn) — the cmdlet used to read process memory and CPU.
• Process.PrivateMemorySize64 (Microsoft Learn) — private memory that can't be shared; equivalent to the Private Bytes counter.
• Process.WorkingSet64 (Microsoft Learn) — the working set includes shared and private data.
• Process model (Electron documentation) — main process and renderer processes in Electron apps.
• Performance Counters (Microsoft Learn) — the counter system behind Performance Monitor.

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