Benchmark: size, memory and idle CPU

How much does the app around your coding agents cost your Mac before the agents do anything? This benchmark measures it for Next Term, two IDEs (Cursor and PhpStorm) and a native editor with its own terminal (Zed): apps you can run coding agents in. Each had the same small project open, with three idle terminal tabs, and was left alone. For each app it records the download, the installed size, memory as Activity Monitor shows it, idle CPU and wake-ups, and the app’s own processes.

The short version. Next Term 0.10.1 used about 160 MB of memory; Cursor used about 1.5 GB and PhpStorm about 1.8 GB. Zed, the other native editor with a terminal, was in Next Term’s range on memory and used less idle CPU in the same minute: see where Next Term does not win. Each app was measured in one session, on one Mac that was busy with other work, so treat the ratios as rough.

The benchmark was run by Next Term’s developer, so read it with that in mind. Everything needed to check it is on this page: the method, every caveat, the scripts and every raw sample, so you can run it yourself.

Results

Measured on 10–11 October 2026 on a 14-inch MacBook Pro (Apple M3 Pro, 18 GB of memory) with macOS 26.5.2. Memory, CPU, wake-ups and processes are the app’s own, with three idle zsh tabs open in it; the shells are left out of every figure.

App	Download	Installed	Memory (Activity Monitor)	Idle CPU	Wake-ups a second	Processes
Next Term 0.10.1	20.3 MB	44.4 MB	159.9 MB	1.03%	6.7	1 (2)
Cursor 3.23.23	458.6 MB	1.45 GB	1.47 GB	10.4%	651.6	16 (19)
PhpStorm 2026.1.1	1.00 GB	2.98 GB	1.83 GB	12.4%	94.8	3 (3)
Zed 1.22.0	118.5 MB	268.0 MB	153.4 MB	0.34%	174.6	2 (2)

• Download is each vendor’s own file on 10 October 2026. Next Term’s and Cursor’s are universal (Apple silicon and Intel); PhpStorm’s and Zed’s are their Apple silicon builds. Cursor no longer served the tested 3.23.23, so its figure is the current 3.24.12 universal disk image; its Apple-silicon-only one is 295.4 MB.
• Installed is the app on disk (du -sk). Download and installed sizes count 1 MB as 1,000,000 bytes, as Finder does.
• Memory is Activity Monitor’s “Memory” column, the physical footprint, which includes compressed and swapped-out memory, added up over all of the app’s processes. It is the median of three samples taken about 60, 80 and 100 seconds after the app was ready. Like Activity Monitor, it counts 1 MB as 1,048,576 bytes.
• Idle CPU is the CPU time the app’s processes used in the minute from 60 to 120 seconds after ready, as a share of one core: 100% is one core fully busy. Wake-ups are how often a second those processes woke the CPU, in the same minute.
• Processes are the app’s own. In brackets, with the macOS services the system runs for it, such as the Metal shader compiler. Next Term runs as one process; its second is a 12 MB macOS Safari helper.

Against Next Term, Cursor used 9.4× the memory and PhpStorm 11.7×. Each agent connected to Next Term over MCP starts its own small bridge process, about 3 MB, as a child of the agent, so it is not counted above. With the three that were running counted against Next Term, the ratios are 8.9× and 11.0×. Next Term woke the CPU about 7 times a second, against about 650 for Cursor and 95 for PhpStorm, and used about a tenth of their idle CPU. Its download was 20 MB against 459 MB and 1 GB, and it took 44 MB on disk against 1.45 GB and 2.98 GB.

For reference: a text editor with no terminal

Sublime Text was measured too, as a reference point. It is a text editor, not an IDE, and has no built-in terminal, so it does not do the same job and is not compared with the apps above: it had the folder open, with an empty untitled tab, in safe mode with only its default packages.

App	Download	Installed	Memory (Activity Monitor)	Idle CPU	Wake-ups a second	Processes
Sublime Text Build 4215	53.3 MB	146.6 MB	170.9 MB	0.009%	0.4	3 (4)

Its download is the universal disk image (Apple silicon and Intel); every other column is measured as above.

What the extra memory pays for

Cursor and PhpStorm index your code and run language servers, a debugger and refactoring tools. Next Term has an editor, side-by-side diffs and git tools, but none of those: it is not a full IDE. If you rely on them, an IDE earns its weight. If you mostly want a window for your agents and their diffs, it is a lot to carry, and Next Term also works next to the IDE you keep.

Where Next Term does not win

• Zed used about the same memory, and less idle CPU. Zed 1.22.0 used 153.4 MB to Next Term’s 159.9 MB, and 0.34% of a core in its idle minute to Next Term’s 1.03%. Zed is also a full editor, with language servers, a debugger and an agent of its own. Most of its wake-ups came from its separate crash-handler process.
• Sublime Text idled far more quietly: 0.009% of a core and 0.4 wake-ups a second, at 170.9 MB. It has no built-in terminal and ran in safe mode with only its default packages, so it had the folder open and no terminal tabs: a reference point, not the same job.
• Next Term did not give its memory back at once. After the three tabs were closed it held 117.0 MB, against 96.5 MB with only its Welcome window open before the test. It was back at 96.5 MB about 70 minutes later.

Caveats

• One Mac, one session per app, and the Mac was busy. Swift builds and coding agents were running during the test: the 1-minute load average was between 3.6 and 43, about 8 GB of swap was in use, and the disk had 2.4–3.5 GB free. Memory footprint and per-process CPU time hold up under that load, but treat differences under about 10% as noise and every ratio as rounded. The load average and macOS memory pressure at each sample are in the raw data.
• Next Term was not freshly launched. It was the developer’s own copy, open for about 47 minutes and used before, with only its Welcome window open until the test opened the project. Its window was visible but not in front.
• Cursor was signed out, with extensions off, in a fresh profile, with updates, telemetry and its crash reporter turned off by its own switches, so its AI features sat idle. Signed in and with your extensions it may use more; that was not measured. Its window was the classic editor in its default layout, with the Agent side panel open. Its 16 processes include four extension hosts, a JSON language server and a git worker. Cursor also started a fourth shell for its agent, left out like the other three. One earlier Cursor run was thrown away because its window was closed during the settling minute.
• PhpStorm stayed hidden and started one shell. It was launched hidden and stayed hidden, while the other apps showed their windows, and of its three restored terminal tabs it started a shell only for the visible one. Both favour PhpStorm. It was measured on the 8th launch of its profile, with its indexes built, its default memory settings (-Xmx2048m) and no file open. The shared JetBrains daemon (jetbrainsd), which macOS attributes to PhpStorm, is counted: about 17 MB. Under the memory pressure on this Mac only 0.2–0.6 GB of PhpStorm’s 1.83 GB footprint was resident; both figures are in the raw data.
• Zed was signed out and offline. Its server address pointed at a closed local port, so there was no sign-in, collaboration or update traffic. Its trust prompt (“Restricted Mode”) was left unanswered and no file was open, so no language server ran. Its first sample came about 93 seconds after ready, not 60.
• Sublime Text ran in safe mode: a clean data folder, default packages only, unregistered.
• Each app opened at its own default window size: Next Term 1100×720, Cursor 1280×800, Zed 1536×1095, PhpStorm 1400×1000, Sublime Text 800×632.
• Idle shells stood in for agents. An agent uses the same memory in whichever app it runs, so the shells and everything in them are left out, and only the app around them is measured. None of this says how the apps behave while agents stream output.
• The size ratios mix builds. Next Term’s figures are for its universal app, while Zed’s and PhpStorm’s are Apple-silicon-only builds, so the ratios against those two are smaller than like-for-like ones would be.
• A second run is not used. Every app was sampled again about 3 minutes after ready (the -late files in the raw data), and the table uses the first run for all of them. Next Term’s memory fell near the end of its first run, at the moment macOS reported memory pressure. Cursor’s, Zed’s and Sublime Text’s runs had no such warning, and PhpStorm’s first run had one without its memory falling, so the later figure would favour Next Term.

Not measured

• Launch time. Next Term’s copy was already running and was not restarted, so there is no launch figure for it. The other apps’ launches were timed only roughly, once each under heavy load, so no launch time is published or compared.
• Battery life.
• Agents at work, or more than three tabs.
• Any other app. The results are no guide to other IDEs or editors, even ones built on the same code as Cursor or PhpStorm.

How it was measured

The scenario

The same project everywhere: demo-acme-api, a small TypeScript HTTP API with four source files, a test, a package.json and a tsconfig.json, no node_modules, committed once in its own git repository. In each app the folder is open, three integrated terminal tabs each run an idle zsh, no file is open in an editor and nothing else is open, and the app is left alone.

What counts as the app

• Every process whose program is inside the app’s bundle, and every process started from one: helpers, renderers, GPU and network processes, extension hosts, the Java runtime, language servers, file watchers and crash handlers.
• Processes that macOS attributes to the app (its “responsible” process) and that are not shells: system services started for it, such as Safari’s helper, the Metal shader compiler and audio, and daemons it launched, such as JetBrains’ jetbrainsd.
• Left out: shells (zsh, bash, sh, login and the like) and everything below them, and processes started from the bundle with --cli. Those are Next Term’s MCP bridges, which agents start, one per connected agent; they are listed separately in the raw data.

The protocol

1. Ready is the moment the app shows the folder and all three terminal shells have started.
2. Wait 60 seconds, idle.
3. Take three samples, 20 seconds apart. Each adds up the physical footprint (phys_footprint, Activity Monitor’s “Memory”) over the app’s processes; the reported memory is the median of the three. Resident size and ps RSS are recorded as cross-checks.
4. Idle CPU is the CPU time the app’s processes used from the first sample to 60 seconds later, including short-lived children they reaped (such as git), divided by the wall time. Wake-ups (package idle and interrupt wake-ups) come from the same minute.
5. After that minute, /usr/bin/footprint reads the same processes once, as a cross-check; it never runs inside the CPU minute. In every run it matched the sampler’s own reading at the same moment to within 0.1%. Where it differs from the median (Next Term’s and Cursor’s first runs), memory really changed during that minute.
6. A second, identical run follows, so that an app that settles slowly is not judged on its first minute alone. Its first samples came 153–199 seconds after ready.

The counters come from pstat, a small C program that reads every process’s footprint, resident size, CPU time, wake-ups and responsible process through macOS’s libproc (proc_pid_rusage, proc_pidinfo and responsibility_get_pid_responsible_for_pid). It only reads, and needs no root.

Sizes and versions

• Installed: du -sk on the app bundle (allocated blocks), shown in MB of 1,000,000 bytes. The apparent size and the file count are in raw/sizes.json.
• Download: the vendor’s own source on the day: the GitHub release asset sizes for Next Term and Zed, the content-length of the official download for Cursor and Sublime Text, and JetBrains’ release API for PhpStorm (data.services.jetbrains.com/products/releases?code=PS, its Apple silicon download).
• Versions: CFBundleShortVersionString and CFBundleVersion from each app’s Info.plist: Next Term 0.10.1 (1035), Cursor 3.23.23, PhpStorm 2026.1.1 (PS-261.23567.149), Zed 1.22.0, Sublime Text Build 4215.

Run it yourself

You need a Mac with Xcode’s command line tools (xcode-select --install) and Python 3. Nothing needs root. Download benchmark-2026-10.zip (64 KB: the scripts, the demo project and every raw sample), then build the two tools and commit the demo project:

unzip benchmark-2026-10.zip && cd benchmark-2026-10
clang -O2 scripts/pstat.c -o scripts/pstat
swiftc -O scripts/windows.swift -o scripts/windows
(cd demo-acme-api && git init -q && git add -A && git -c user.name=Benchmark -c user.email=benchmark@example.invalid commit -qm "Initial commit")

measure.py counts every process from the app’s bundle, so quit your own copy of Cursor, PhpStorm, Zed or Sublime Text before measuring it. Those apps are launched below with a throwaway profile in your temporary folder ($TMPDIR), then closed and the profile deleted. Keep $TMPDIR short: Cursor’s and PhpStorm’s sockets need a path under 104 characters.

Each app is measured the same way: wait until it is ready, then run the sampler twice in a row. The second run starts as the first ends, about 2 minutes after ready, and takes its first sample a minute later. For Zed:

python3 scripts/wait_shells.py /Applications/Zed.app/Contents/MacOS/zed 3 120 &&
python3 scripts/measure.py --label zed-demo-3tabs --bundle /Applications/Zed.app/ --out raw/zed-demo-3tabs.json &&
python3 scripts/measure.py --label zed-demo-3tabs-late --bundle /Applications/Zed.app/ --out raw/zed-demo-3tabs-late.json

Name your files as in raw/, and python3 scripts/build_results.py rebuilds results.json from them. No script writes raw/sizes.json or raw/environment.json; update them from Sizes and versions and your Mac.

Next Term

1. Start with no project window open in Next Term, only its Welcome window, and run the commands from another terminal app, so that Next Term has only the test window.

2. With the Welcome window in front, press ⌘O and choose the demo-acme-api folder: in 0.10.1, as measured, that is File › Open Project…; from 0.11 it is the Welcome window’s Open…. The project window opens with one terminal tab.

3. Press ⌘T twice, so that three tabs run a shell.

4. Measure:

   python3 scripts/wait_shells.py "/Applications/Next Term.app/Contents/MacOS/NextTerm" 3 120 &&
   python3 scripts/measure.py --label nextterm-demo-3tabs --bundle "/Applications/Next Term.app/" --out raw/nextterm-demo-3tabs.json &&
   python3 scripts/measure.py --label nextterm-demo-3tabs-late --bundle "/Applications/Next Term.app/" --out raw/nextterm-demo-3tabs-late.json

For this page the folder and its three tabs were opened through Next Term’s own MCP tool new_tab (called three times, with the demo folder as directory), and closed with close_tab afterwards. It makes the same window.

Cursor

S=$(mktemp -d "${TMPDIR%/}/ntbc.XXXX"); mkdir -p $S/d/User $S/e $S/h
cp scripts/scenario/cursor-settings.json $S/d/User/settings.json   # updates and telemetry off, automatic tasks on, trust off
mkdir -p demo-acme-api/.vscode && cp scripts/scenario/cursor-tasks.json demo-acme-api/.vscode/tasks.json   # three tasks running /bin/zsh -l when the folder opens
open -n -g -j -a /Applications/Cursor.app --env HOME=$S/h --args --classic --skip-onboarding --skip-welcome \
  --skip-release-notes --disable-telemetry --disable-updates --disable-crash-reporter --disable-workspace-trust \
  --use-inmemory-secretstorage --use-mock-keychain --user-data-dir $S/d --extensions-dir $S/e --disable-extensions "$PWD/demo-acme-api"

• --classic opens the editor window with the folder. Without it, Cursor 3 opens its Agents window instead.
• --skip-onboarding avoids a full-window sign-in screen that otherwise keeps the tasks from running.
• Cursor shows the folder, its Agent side panel and three task terminals, and starts a fourth shell for its agent, so wait for 4 shells under /Applications/Cursor.app/Contents/MacOS/Cursor.
• To quit: kill -9 the main process (it avoids an update-on-quit path), then delete $S and demo-acme-api/.vscode.

Zed

Z=$(mktemp -d "${TMPDIR%/}/ntbz.XXXX"); mkdir -p $Z/h/.config/zed $Z/d/config
cp scripts/scenario/zed-settings.json $Z/h/.config/zed/settings.json; cp scripts/scenario/zed-settings.json $Z/d/config/settings.json
open -n -g -j -a /Applications/Zed.app --env HOME=$Z/h --env ZED_SERVER_URL=http://127.0.0.1:9 \
  --env ZED_RPC_URL=http://127.0.0.1:9/rpc --args --user-data-dir $Z/d "$PWD/demo-acme-api"

• ZED_SERVER_URL points at a closed local port, so this copy cannot sign in or download an update: it runs signed out and offline.

• For the three terminals, quit Zed after this first launch (kill -TERM), add them to Zed’s own session database, and launch it again with the same command; Zed restores them with the project:

  sqlite3 $Z/d/db/0-stable/db.sqlite "INSERT OR REPLACE INTO kv_store(key,value) VALUES('\"TerminalPanel\"-\"1\"','{\"items\":[1001,1002,1003],\"active_item_id\":1001}');
    UPDATE workspaces SET bottom_dock_visible=1, bottom_dock_active_panel='TerminalPanel' WHERE workspace_id=1;"

  The key and its format are from Zed’s source at the v1.22.0 tag (crates/terminal_view/src/terminal_panel.rs and persistence.rs).

• Leave the trust prompt (“Restricted Mode”) unanswered. To quit: kill -TERM, then delete $Z.

PhpStorm

P=$(mktemp -d "${TMPDIR%/}/ntbp.XXXX"); mkdir -p $P/{config,system,plugins,log,home}
printf "idea.config.path=$P/config\nidea.system.path=$P/system\nidea.plugins.path=$P/plugins\nidea.log.path=$P/log\n" > $P/idea.properties
cp /Applications/PhpStorm.app/Contents/bin/phpstorm.vmoptions $P/phpstorm.vmoptions
sed "s#\$BENCH_TMP/phpstorm#$P#g" scripts/scenario/phpstorm-vmoptions-additions.txt >> $P/phpstorm.vmoptions   # temporary user.home; no consent, trust or update prompts
open -n -g -j -a /Applications/PhpStorm.app --env PHPSTORM_PROPERTIES=$P/idea.properties \
  --env PHPSTORM_VM_OPTIONS=$P/phpstorm.vmoptions --args "$PWD/demo-acme-api"

1. PhpStorm does not save its state when it gets SIGTERM, so give its first launch a script: before the open command, run echo "-Dtestscript.filename=$PWD/scripts/scenario/phpstorm-save-state-script.txt" >> $P/phpstorm.vmoptions. The bundled Performance Testing plugin then runs %closeAllTabs and %saveDocumentsAndSettings, which marks “What’s New” as seen and saves the project with no file open. Let PhpStorm index the project, quit it with kill -TERM, and take that line out of $P/phpstorm.vmoptions again.
2. In the workspace file $P/config/workspace/<ProjectId>.xml, set the Terminal tool window to visible="true" and put the three tabs from scripts/scenario/phpstorm-terminal-tabs-storage.xml into its TerminalTabsStorage component.
3. Launch it again with the same open command and measure. PhpStorm restores the three tabs but starts a shell only for the visible one, so wait for 1 shell under /Applications/PhpStorm.app/Contents/MacOS/phpstorm. The measured copy was the 8th launch of its profile, and stayed hidden.
4. To quit: kill -TERM PhpStorm, stop jetbrainsd, then delete $P, demo-acme-api/.idea and the jetbrainsd-extracted* folders it leaves in $TMPDIR.

Sublime Text

open -n -g -j -a "/Applications/Sublime Text.app" --env HOME=$(mktemp -d) --args --safe-mode "$PWD/demo-acme-api"

Safe mode uses a clean, separate data folder with only the default packages. There are no shells to wait for: it is ready when scripts/windows wait "/Applications/Sublime Text.app/" 60 sees its window. Sublime Text ignores $HOME for its data and creates ~/Library/Application Support/Sublime Text (Safe Mode) and ~/Library/Caches/Sublime Text (Safe Mode); delete both afterwards.

What the apps leave behind

Even with separate profiles, some apps write to your own Library while they run:

• Cursor rewrites ~/Library/Preferences/com.todesktop.230313mzl4w4u92.plist and writes crash-reporting state in ~/Library/Application Support/Cursor.
• PhpStorm starts the shared JetBrains daemon, which writes under ~/Library/Application Support/JetBrains/Daemon and ~/Library/Logs/JetBrains/Daemon, and may rewrite ~/Library/Preferences/jetbrains.jetprofile.asset.plist. It may also pick up a licence by itself at first start, most likely from a JetBrains Account signed in on the Mac; that lands in the temporary profile and goes with it.
• Sublime Text in safe mode touches its URL cache (~/Library/Caches/com.sublimetext.4 and ~/Library/HTTPStorages/com.sublimetext.4).
• Next Term adds the demo folder to its recent projects.

Scripts and raw data

Everything is also in benchmark-2026-10.zip. results.json holds every measurement on this page, built from the raw samples by build_results.py.

Script	What it does
pstat.c	Reads every process’s footprint, resident size, CPU time (with reaped children), wake-ups and responsible process through libproc. Read-only, no root. Build: clang -O2 pstat.c -o pstat
windows.swift	Lists an app’s windows, or waits for its first normal window, with CGWindowListCopyWindowInfo. Read-only. Build: swiftc -O windows.swift -o windows
measure.py	The sampler: the protocol above, one JSON file per run. It writes paths in your home folder as ~/… and in your temporary folder as $TMPDIR/…, so the files hold no user name.
wait_shells.py	Waits until a number of shells run below an app’s main process.
build_results.py	Builds results.json from raw/.

The scenario files: Cursor’s settings and tasks; Zed’s settings; PhpStorm’s VM options, properties, terminal tabs and save-state script.

Raw samples	What they are
nextterm-asis	Next Term before the test, with only its Welcome window open
nextterm-demo-3tabs, late	Next Term with the project and three tabs: the first and second runs
nextterm-after-close	Next Term after the three tabs were closed
nextterm-asis-end	Next Term about 70 minutes later, Welcome window only
cursor-demo-3tabs, late	Cursor: the first and second runs
phpstorm-demo-3tabs, late	PhpStorm: the first and second runs
phpstorm-folder-0tabs	PhpStorm’s first launch, with the folder and no terminal (not in the table)
zed-demo-3tabs, late	Zed: the first and second runs
sublime-demo-folder, late	Sublime Text: the first and second runs
sizes	Versions, installed sizes, file counts and download sizes, with their sources
environment	The Mac, macOS, the load, and the apps’ versions

Found a mistake, or got different numbers on your Mac? Please open an issue with your raw files.

Trademarks

Cursor is a trademark of Anysphere, Inc. PhpStorm and JetBrains are trademarks of JetBrains s.r.o. Zed is a trademark of Zed Industries, Inc. Sublime Text is a trademark of Sublime HQ Pty Ltd. No affiliation or endorsement.