Memory and CPU, measured

NotchPixel uses about 13 MB in Task Manager and 0% CPU at idle (version 0.5.64, 3 Oct 2026). This page shows how that was measured, what each number means, and how to measure your own copy the same way.

12.8 MBin Task Manager's Memory column, median over 120 seconds

0%CPU in Task Manager. Measured: 0.63% of one core, 0.05% of the whole PC

0.5.64the Microsoft Store version measured, on 3 October 2026

The measurement

This is the output of the script further down this page, run on the copy installed from the Microsoft Store while NotchPixel sat idle.

App version: NotchPixel 0.5.64.0
Date: 3 October 2026, 22:09
PC: Laptop with an Intel Core i5-11400H (12 logical cores) and 15.7 GB of RAM
Windows: Windows 10 Home 22H2 (10.0.19045)
Sample: 120 seconds, one reading a second
Memory in Task Manager: 12.8 MB medianprivate working set
Working set, incl. shared pages: 29.7 MB median, 74.9 MB max
Committed memory (private bytes): 336.5 MB medianmostly graphics buffers reserved by Direct3D, not RAM in use
CPU, share of one core: 0.63%
CPU, share of the whole PC: 0.05%Task Manager shows 0%

The script's output, unedited

Sampling NotchPixel 0.5.64.0 for 120 seconds. Leave the PC idle...

App version                  0.5.64.0
Date                         2026-10-03 22:09
PC                           11th Gen Intel(R) Core(TM) i5-11400H @ 2.70GHz, 15.7 GB RAM, 12 logical cores
Windows                      Microsoft Windows 10 Home 10.0.19045
Sample                       120 s, one reading a second
Memory in Task Manager       12.8 MB median (private working set)
Working set, incl. shared    29.7 MB median, 74.9 MB max
Committed (private bytes)    336.5 MB median, mostly graphics buffers reserved by Direct3D, not RAM in use
CPU, share of one core       0.63 %
CPU, share of the whole PC   0.05 %

Method: notchpixel.com/footprint

Numbers change from version to version and from PC to PC. Each figure on this page comes with the version and date it was measured on.

Which memory number to read

Windows keeps several memory counters for every program. The script prints three, because each one answers a different question.

Memory in Task Manager: 12.8 MB the headline number

The private working set: memory that belongs to NotchPixel alone and is in RAM right now. It is what the Memory column on Task Manager's Processes tab shows, so it is the number we quote.
Working set, including shared pages: 29.7 MB

The same, plus pages NotchPixel shares with Windows, such as Windows' own code libraries that other programs use too. In Task Manager you can add it to the Details tab as the Working set (memory) column.
Committed memory: 336.5 MB not RAM in use

Address space set aside for NotchPixel, mostly graphics buffers that Direct3D reserves for drawing. It is not RAM in use, which is why Task Manager's Memory column does not count it. On the Details tab it is the Commit size column.

How the CPU figure is worked out

The script reads how much processor time NotchPixel used during the sample and divides it by the time that passed. Over 120 seconds that came to 0.63% of one core. The test PC has 12 logical cores, so it is 0.05% of the whole PC. Task Manager's CPU column shows the share of the whole PC, and it shows 0%.

Measure it on your PC

Start NotchPixel and leave it idle: card closed, nothing playing.
Open Windows PowerShell: press Start, type PowerShell and press Enter. It does not need to run as administrator.

Paste this line and press Enter. It saves the script to your Temp folder and runs it.

irm https://notchpixel.com/assets/footprint.ps1 -OutFile "$env:TEMP\footprint.ps1"; powershell -ExecutionPolicy Bypass -File "$env:TEMP\footprint.ps1"

Leave the PC alone for two minutes. The result appears in the same window.

-ExecutionPolicy Bypass lets Windows run this one unsigned script. It applies to that run only and does not change your settings. Add -Seconds 60 to the end of the line for a shorter sample.

Prefer to read it before you run it? Download footprint.ps1, open it in Notepad, then run it from the folder you saved it in, for example:

powershell -ExecutionPolicy Bypass -File "$HOME\Downloads\footprint.ps1"

Read the script on this page

It is plain PowerShell, under 100 lines. Open footprint.ps1.

What the script does, and what it does not

What it does

Finds the running NotchPixel process and reads its memory and CPU counters once a second, for 120 seconds unless you give -Seconds.
Reads the app version from the installed package, and your processor, RAM and Windows build, so results from different PCs can be compared.
Prints the result in the PowerShell window.

What it does not do

It changes nothing: no files, no settings, no registry keys.
It sends nothing. It opens no network connection; the result stays on your screen.
It needs no administrator rights. It reads process counters only, the ones Windows keeps for every program.

Send us your numbers

If you run it, email the whole output to info@notchpixel.com. Results from older and slower PCs help most. The output already includes the version, the PC and the Windows build, so there is nothing else to add. If a number looks wrong, send it anyway.

How the app stays idle

NotchPixel is one window, drawn through DirectComposition and Skia. When nothing on it changes, nothing is redrawn. It learns that an app has started using the microphone from Core Audio session notifications, rather than by checking over and over. The FPS figure in the games strip comes from Windows' own Present events, through an ETW session that exists only while the strip is showing.

Get NotchPixel

$9.99 once. No subscription, no account.

US price; the Store shows the price for your country. The Microsoft Store installs and updates it.