---
title: "Benchmarks - PaneStack"
description: "How fast PaneStack lists, sorts and copies, measured on a Mac mini, with the method and raw output."
canonical: https://panestack.app/benchmarks.html
---

# PaneStack benchmarks

Measured with PaneStack's own benchmark tool, `panestack-bench` (`Sources/panestack-bench/main.swift`). These are the commands that ran them:

    swift run -c release panestack-bench list [count]    # list a folder (default 100,000 files)
    swift run -c release panestack-bench sort [count]    # sort and filter it
    swift run -c release panestack-bench memory [count]  # memory per item
    swift run -c release panestack-bench copy            # copy 1 GB + 2,000 small files

All the test folders are created in the system temporary folder and deleted afterwards.

## The machine

| | |
|---|---|
| Model | Mac mini (`hw.model` Mac18,5) |
| Chip | Apple M6, 12 cores (2 Super, 4 Performance, 6 Efficiency) |
| Memory | 24 GB |
| Disk | Internal SSD, APFS (95% full when these were run) |
| macOS | 27.0 (26A428) |
| Compiler | Apple Swift 6.4.2, release build |
| Date | 13 Nov 2026 |

These numbers come from a fast, recent Mac. Older Macs, and Intel Macs especially, will be slower. Network drives and
USB disks will be much slower.

## Results

Each test was run three times (memory twice). The table shows the median run. The full output is below.

### Listing a folder

The folders hold empty files called `file 000000.txt` and so on. "FileManager" is Apple's standard
`contentsOfDirectory` call asking for the same four facts PaneStack needs (size, modified, created, folder or not). Most Mac
apps list folders this way.

| Folder | First rows ready | Whole folder (PaneStack) | Whole folder (FileManager) | Speed-up |
|---|---|---|---|---|
| 10,000 files | 2.5 ms | 4.2 ms | 20.8 ms | 5.0× |
| 100,000 files | 3.9 ms | 71.8 ms | 218.3 ms | 3.0× |

PaneStack's budget (PLAN.md) is first rows in under 150 ms for 10k items and under 1 s for 100k. Both are met with plenty to
spare. "First rows" means the first batch the bulk lister returns (5,781 items here), which is enough to fill the
window while the rest loads.

### Sorting and filtering 100,000 items

| Step | Time |
|---|---|
| Build sort keys and sort by name (first load) | 177.7 ms |
| Re-sort by size | 84.2 ms |
| Re-sort by name, descending | 83.4 ms |
| Filter by "99" (3,691 matches) | 25.0 ms |

Name sorting is Finder-style: case- and accent-insensitive, with numbers in natural order.

### Memory

| Folder | Memory used | Per item |
|---|---|---|
| 100,000 items | 22.4 MB | 234 bytes |
| 10,000 items | 1.5 MB | 159 bytes |

This is the heap memory the folder model (`FolderContents`) uses once the folder is loaded and sorted. It doesn't count
the window, icons or thumbnails, so it is not the app's total memory use. One `FileItem` takes 112 bytes.

### Copying

The test folder holds four 250 MB files and 2,000 files of 4 KB each: about 1 GB in total. It is copied to another folder
on the same APFS disk.

| Copy | Time |
|---|---|
| Normal copy (APFS clone) | 173.1 ms |
| Verified copy (clone, then both sides read back and compared with SHA-256) | 1,269.2 ms |

To be clear about what this shows: on APFS, PaneStack clones files, so a copy on the same disk is almost instant and takes
no extra space. Finder does the same. The 173 ms is mostly the 2,000 small files. This is **not** a measure of how
fast data moves to an external or network drive. The disk's speed decides that. The verified run reads about 2 GB to
check it, which is the extra work PaneStack does by default when copying to removable and network drives.

## Raw output

```
== list 10000 run 1
first batch (4096)                 3.7 ms  (5781 items)
DirectoryLister (all)              5.1 ms  (10000 items)
FileManager + 4 resource keys     20.8 ms  (10000 items)
== list 10000 run 2
first batch (4096)                 2.6 ms  (5781 items)
DirectoryLister (all)              4.2 ms  (10000 items)
FileManager + 4 resource keys     20.8 ms  (10000 items)
== list 10000 run 3
first batch (4096)                 2.5 ms  (5781 items)
DirectoryLister (all)              4.2 ms  (10000 items)
FileManager + 4 resource keys     21.5 ms  (10000 items)
== list 100000 run 1
first batch (4096)                 4.2 ms  (5781 items)
DirectoryLister (all)             73.4 ms  (100000 items)
FileManager + 4 resource keys    220.6 ms  (100000 items)
== list 100000 run 2
first batch (4096)                 3.9 ms  (5781 items)
DirectoryLister (all)             71.8 ms  (100000 items)
FileManager + 4 resource keys    218.3 ms  (100000 items)
== list 100000 run 3
first batch (4096)                 3.9 ms  (5781 items)
DirectoryLister (all)             63.5 ms  (100000 items)
FileManager + 4 resource keys    216.7 ms  (100000 items)
== sort (100000) runs 1-3
build keys + sort by name        175.2 / 178.2 / 177.7 ms
re-sort by size                   82.5 /  85.6 /  84.2 ms
re-sort by name desc              83.4 /  85.4 /  83.4 ms
filter "99"                       25.0 /  25.1 /  24.8 ms  (3691 items)
== memory (100000) runs 1-2
FileItem stride: 112 bytes
FolderContents for 100000 items: 22.4 MB (234 bytes each)
== memory 10000
FolderContents for 10000 items: 1.5 MB (159 bytes each)
== copy runs 1-3
copy 1 GB + 2000 small (clone)   169.3 / 173.6 / 173.1 ms
same, verified (SHA-256)        1274.9 / 1269.2 / 1266.6 ms
```

The "(4096)" label in the first line is the size of the tool's first batch request. The lister actually returned
5,781 entries in that batch.

## Limits of these tests

- The files in the test folders are empty, so this tests listing speed, not icons or thumbnails.
- Only one machine was tested. There are no Intel results yet.
- The comparison is against Apple's FileManager API, not against Finder or any other app.
- Scrolling smoothness and memory with 10 tabs open (also in the PLAN.md budgets) are not measured by this tool.