Verified Benchmark — February 2026

Excel Compare Performance:
1M Rows in 21 Seconds (2026 Benchmark)

~184K cells/second (value comparison mode, dataset-dependent). Character-level diff, formula detection, fuzzy matching, and multi-sheet support — all processed in your browser with zero server transmission. Works alongside CSV Compare for mixed file workflows, or see the full tool overview.

Peak Throughput
184K/s
cells/sec (value mode)
Maximum Tested
1M+
rows (~85MB .xlsx)
File Uploads
Never
zero transmission
Comparison Modes
6
value, formula, fuzzy...

Files never transmitted to any server. Privacy policy →

Best For
10K–100K row workbooks (0.7–2.7s). Value comparison, formula audits, financial close validation, CRM migration checks.
Slower When
Fuzzy matching enabled (~5× overhead vs value-only). Formatting comparison enabled (~2× overhead). Files with 20+ columns.
Not For
Files over ~85MB / 1M rows. Automated pipelines (no API). VBA comparison. Batch processing across multiple file pairs.
Speed range: 0.7s (10K rows, value only) → 21.66s (1M rows, value only) → ~34s (1M rows + formula). For 50M+ rows or automated workflows, use Python openpyxl or Microsoft Spreadsheet Compare instead.

Benchmark Results by Configuration

Processing Time by Row Count (value comparison, seconds)

Time (seconds)
100 rows
0.5
1K rowsFASTEST
0.2
10K rows
0.7
100K rows
2.7
1M rows
21.7

Lower values indicate better performance (faster processing)

ConfigurationProcessing TimeCells/SecondNotes
100 rows · 5 cols · value only~0.50s~1,020 cells/secWorker init overhead visible at small file sizes — dominates total time
1,000 rows · 6 cols · value only~0.20s~30K cells/secSub-second across all reasonable small file sizes
10,000 rows · 6 cols · value only~0.72s~83K cells/secEnterprise daily report comparison; includes key-column auto-detection
100,000 rows · 4 cols · value only~2.7s~148K cells/secFinancial close and CRM validation use case
1,000,000 rows · 4 cols · value only~21.66s~184K cells/secPeak benchmark — sustained throughput across entire 1M row file
1,000,000 rows · 4 cols · formula + value~34s~118K cells/secFormula comparison enabled; SheetJS reads cell formula strings alongside values
200,000 rows · 4 cols · fuzzy 85%~28s~36K cells/secFuzzy matching enabled; Levenshtein distance computed per differing cell
All benchmarks: Chrome 132 (stable), Windows 11, Intel i7-12700K (3.6GHz), 32GB DDR4-3200 RAM, February 2026. 10 runs per configuration, highest and lowest discarded, remaining 8 averaged. Results vary ±8–15% based on hardware, browser, column count, and comparison settings active.

Feature Overhead: What Each Setting Costs

Not all comparison settings are equal. The choice of which features to enable is the single largest factor in performance after file size. Understanding the cost lets you configure appropriately for your use case.

Value Comparison Only (Baseline)
Baseline
~184K cells/sec
Pure value comparison — reads cell values, applies key-based row matching, generates diff output. No formula reads, no format checks, no fuzzy logic. Fastest throughput. Use for bulk data validation where formulas and formatting are not the concern.
Formula Comparison Enabled
+56% time
~118K cells/sec
SheetJS reads the cell formula string alongside the value for every cell — even cells that haven't changed. This is necessary because formula presence must be checked before a "same value" result can be declared as truly unchanged. Adds memory pressure on large files. Enable when auditing financial workbooks or policy documents where formula integrity matters.
Formatting Comparison Enabled
+94% time
~95K cells/sec
Formatting reads require parsing cell style metadata (fill color, font, border) from the SheetJS workbook object for every cell. Style objects are not streamed — they are parsed upfront from the file binary. This is the highest single-feature overhead. Use for design-sensitive spreadsheets where color-coded data has semantic meaning, or compliance workflows where visual formatting is audited alongside values.
Character-Level Diff Enabled
+15% time
~160K cells/sec
Character diff runs only on cells flagged as "changed" — not all cells. A standard merge-diff algorithm (O(n·m) where n and m are string lengths) runs per changed cell pair. Overhead is proportional to the number of changed cells and their string length, not the total row count. On a file with sparse changes (< 1% of cells differ), the overhead is negligible. On a file where 30%+ of cells differ, overhead can be significant.
Fuzzy Matching Enabled (85%)
+411% time
~36K cells/sec
Fuzzy matching is the most expensive feature. Levenshtein edit distance (O(n·m) per pair, where n and m are string lengths) is computed for every cell where values differ and at least one value is a string. On a 200K row file where 50% of string cells have minor variations, this means ~100K Levenshtein computations. Use only when comparing datasets with known typo or normalization differences. Disable for numeric-heavy files where fuzzy matching adds no value.
All Features Combined
+557% time
~28K cells/sec
Maximum configuration: formula + formatting + character diff + fuzzy matching all enabled simultaneously. Best comparison depth, highest processing cost. Suitable for regulatory audits, legal document review, or any comparison where every type of difference must be detected and documented. Not recommended for routine file validation where speed matters more than completeness.
All overhead figures measured on 1M row dataset (value comparison baseline), February 2026, Chrome 132, 32GB RAM, i7-12700K. Results vary by hardware, browser, data density, column count, and file format.

Input Format Performance

.xlsx (Open XML)
Recommended
~184K cells/sec
SheetJS decompresses the ZIP archive and parses XML — efficient and well-tested. Memory-efficient flags applied (cellFormula optional, cellHTML disabled, cellText disabled). Best overall format for comparison workloads. Most Excel files saved by modern Excel are .xlsx.
.xls (Legacy BIFF8)
Slower startup
~130K cells/sec (estimate)
Legacy binary format requires BIFF8 binary parsing before any processing begins. 20–40% slower to load for equivalent data size. Functionally identical results — values, formulas, and formatting all read correctly. Convert to .xlsx first if performance matters on large legacy files.
.xlsm / .xlsb
Macros ignored
~180K cells/sec
.xlsm is structurally identical to .xlsx for data purposes — macros are stored separately and ignored during comparison. .xlsb is a binary format that reads 10–15% faster from disk but differences are marginal when the file is already in browser memory. Both format types fully supported.

Calculate Your Time Savings

Manual baseline: ~2 hours per multi-sheet workbook comparison — based on internal workflow analysis, February 2026. Covers: open both files, write VLOOKUP/IF formulas to flag mismatches, scroll through all differences across each sheet, manually highlight findings, document every change for audit, and export a summary. SplitForge completes the same comparison in 4–18 seconds and automatically produces an exportable highlighted Excel and CSV report.

Typical: 1–4 hours for a multi-sheet file

Monthly = 12, Weekly = 52, Daily = 260

Analyst avg: $45–75/hr

Annual Time Saved
48.0
hours per year
Annual Labor Savings
$2,399
per year at your hourly rate

Estimate based on 2h manual comparison time vs ~2.7s with SplitForge (100K row benchmark — 1M row files take ~22s, see benchmarks table above), across 24 comparisons per year at $50/hr. Actual savings vary by file complexity, sheet count, and difference density.

Benchmark Methodology

Honest Limitations: Where SplitForge Excel Compare Falls Short

No tool is perfect for every use case. Here's where Python (openpyxl/pandas) and Microsoft Spreadsheet Compare might be a better choice, and the real limitations of our browser-based architecture.

Browser-Based Processing

Performance depends on your device's RAM and CPU. Modern laptops (2022+) handle 10M+ rows easily, but older devices may struggle with very large files.

Workaround:
Close unnecessary browser tabs to free up memory. For files over 50M rows, consider database solutions.

No Offline Mode (Initial Load)

Requires internet connection to load the tool initially. Processing happens offline in your browser after loading.

Workaround:
Once loaded, you can disconnect and continue processing. For true offline environments, desktop tools may be better.

Browser Tab Memory Limits

Most browsers limit individual tabs to 2-4GB RAM. This is the practical ceiling for file size.

Workaround:
Use 64-bit browsers with sufficient RAM. Chrome and Firefox handle large files best.

Browser Memory Ceiling (~1–2GB / ~1M Rows)

Maximum practical file size is approximately 85MB (.xlsx) or roughly 1M rows at 4 columns. SheetJS loads the full workbook into memory before processing. Very large files (500K+ rows, 10+ columns, formula-heavy) may exhaust browser memory.

Workaround:
Split large workbooks with Excel Splitter before comparing. For 10M+ row validation, use Python openpyxl with chunked reading, or a dedicated data diffing library such as daff or csvdiff.

No Automation or API

Excel Compare is a browser tool — no REST API, CLI, or pipeline integration. Cannot be triggered from a CI/CD job, scheduled, or embedded in an ETL workflow.

Workaround:
For automated comparison, use Python openpyxl + custom diff logic, or Microsoft Spreadsheet Compare (Windows only, ships with Office Professional). For CSV outputs, daff provides a command-line diff tool with multiple output formats.

Fuzzy Matching Is Slow on Large Files

Fuzzy matching at 85% threshold on a 200K row file takes approximately 28 seconds — versus 2.7 seconds for value-only comparison. The Levenshtein overhead scales with both the number of differing cells and string length.

Workaround:
Enable fuzzy matching only for files where you know text normalization differences exist. Run a value-only comparison first to identify the scale of differences, then re-run with fuzzy matching on a filtered subset if needed.

Side-by-Side View Capped at 1,000 Rows

The side-by-side visual preview panel renders at most 1,000 rows to prevent browser tab crashes on large files. The unified diff table and all export formats contain the complete diff output for all rows.

Workaround:
Use the Unified Table view (Differences tab) for navigating large result sets — it supports search, filter by change type, and pagination at 50 items per page.

One File Pair at a Time

No batch comparison across multiple file pairs in a single session. Each comparison requires uploading two files individually.

Workaround:
For batch file comparison (e.g., validating 20 pairs of files), use Python with openpyxl in a loop, or a shell script wrapping a diff tool.

VBA Macros Not Compared

Macro code (.xlsm VBA) is ignored during comparison. Only cell values, formulas, and formatting are compared.

Workaround:
To diff VBA code between versions, extract the .xlsm as a ZIP, locate the VBA source in xl/vbaProject.bin, and use a VBA-aware diff tool or decompile to text for comparison.

When to Use Python (openpyxl/pandas) and Microsoft Spreadsheet Compare Instead

You need Excel comparison in an automated pipeline or scheduled job

SplitForge has no API or CLI. Browser-only workflow cannot run without a human present.

💡 Python openpyxl with custom diff logic in a cron job, or Microsoft Spreadsheet Compare with command-line mode on Windows.

Your workbooks exceed 1M rows or are very wide (20+ columns)

Browser memory limits practical ceiling to roughly 85MB / 1M rows at 4 columns. Wider or larger files will exceed available memory.

💡 Python openpyxl with chunked reading, or pandas read_excel with converters for large files.

You need to compare VBA macro code between workbook versions

SplitForge reads cell content only. VBA module code is not parsed or compared.

💡 Extract .xlsm as ZIP, locate xl/vbaProject.bin, decompile with oletools, then use any text diff tool.

You need a desktop application with persistent configuration and team sync

SplitForge runs entirely in-browser with no account system. Settings do not persist or sync across users.

💡 Microsoft Spreadsheet Compare (Office Professional, Windows) or Beyond Compare for team-licensed desktop diff workflows.

Questions about limitations? Check our FAQ section below or contact us via the feedback button.

Frequently Asked Questions

How accurate is the 184K cells/second benchmark?

Why is fuzzy matching so much slower than value comparison?

What is key-based row matching and does it affect performance?

Does multi-sheet comparison multiply processing time?

How does Excel format (.xlsx vs .xls vs .xlsb) affect speed?

What is the practical upper limit for file size?

Can I reproduce these benchmarks?

Does running in a Web Worker really make a difference?

Benchmarks last updated: February 2026. Re-tested quarterly and after major algorithm changes. Last algorithm update: February 2026 — improved key-column auto-detection accuracy and reduced fuzzy matching memory pressure by ~12%.

Ready to Compare 1M Rows in 21 Seconds?

No installation. Files never uploaded. Character-level diff, formula detection, fuzzy matching, and multi-sheet support — all in your browser.