Full browser-side benchmark data for SplitForge Excel Compare. Need CSV-to-CSV diffing instead? See CSV Compare for plain-text throughput numbers. For feature details, see the Excel Compare overview.
Peak Throughput
184K
cells/sec (1M rows, 4 cols)
Max Tested
1M
rows compared in 21.66s
Data Privacy
Zero
upload — browser only
Formats Supported
4
.xlsx .xls .xlsm .xlsb
Files are never uploaded. All comparison logic runs locally in your browser. Privacy policy
Best for:
Business files up to ~500K rows — two .xlsx files compared cell-by-cell with diffs highlighted in seconds.
Slower when:
Fuzzy matching, formatting diff, or formula detection are enabled — each adds 15–40% overhead on large files.
Not for:
Files requiring server-side diff reports, multi-user collaborative review workflows, or files that exceed available browser memory (~1–2GB combined).
Benchmarked February 2026 — Chrome 132, Windows 11, Intel i5-12600KF, 64GB RAM, NVMe SSD. Results vary by hardware, browser version, and comparison settings.
Typical finance reconciliation file. Time dominated by .xlsx parse, not comparison logic.
500K rows × 5 cols
3.2s
781K cells/sec
Throughput increases as parse overhead amortizes over larger dataset.
1M rows × 10 cols
8.1s
1.23M cells/sec
Wide files benefit from SIMD-accelerated string comparison in V8.
2M rows × 5 cols
17.4s
575K cells/sec
GC pressure begins to show at this size. Chrome memory ~900MB.
5M rows × 5 cols
44.0s
568K cells/sec
Approaches practical browser memory ceiling. Recommend splitting into two runs for stability.
100K rows × 50 cols
1.9s
2.63M cells/sec
Wide-format files (e.g., survey exports). High column count benefits from vectorized comparison.
500K rows × 50 cols
9.3s
2.69M cells/sec
Peak observed throughput for wide files. Memory usage ~1.1GB — near upper comfortable limit.
All runs: Chrome 132, Windows 11, Intel i5-12600KF, 64GB RAM, NVMe SSD. Value-only mode (no fuzzy match, no formula diff, no formatting diff). Median of 5 runs. Files generated with random mixed-type data (strings, integers, decimals).
Feature Overhead Breakdown
Every optional feature adds processing time. The numbers below are measured against a 100K row × 10 col baseline (value-only, no extras). Enable only what your workflow requires.
Value-only comparison (baseline)
Baseline
0.8s / 100K rows
Direct cell equality check. Fastest possible mode. Catches value changes, additions, and deletions with no extra cost.
Key-based row matching
+10–15%
~0.9s / 100K rows
Builds a hash index on the key column(s) before comparison. Overhead is proportional to key cardinality, not total row count.
Formula change detection
+35–40%
~1.1s / 100K rows
Reads raw formula strings in addition to computed values. Requires a second SheetJS parse pass over the .xlsx XML. Not applicable to .csv inputs or .xls (BIFF8) files.
Character-level (inline) diff
+15–20%
~0.95s / 100K rows
Runs a Myers diff on changed cell strings to produce Git-style inline highlights. Overhead scales with the number of changed cells, not total rows.
Fuzzy text matching
+35–45%
~1.1s / 100K rows
Levenshtein distance computed per changed cell pair. Configurable threshold (50–99%). CPU-bound — performance scales linearly with changed cell count and average string length.
Formatting diff (colors, fonts, borders)
+55–65%
~1.3s / 100K rows
Parses the styles.xml sidecar inside the .xlsx package. Dominant overhead for large style-heavy workbooks. Disabled automatically for .xls (BIFF8) inputs.
Overhead measured relative to value-only baseline (100K rows × 10 cols). Percentages are additive — enabling both fuzzy matching and formula detection adds roughly 55% total overhead.
Input Format Comparison
.xlsx (Open XML)
Recommended
Fastest
Native SheetJS parse path. XML-based structure allows streaming extraction. All features supported: formulas, formatting diff, multi-sheet. Benchmarks above use .xlsx.
.xls (Legacy BIFF8)
Legacy
20–35% slower
Binary BIFF8 format requires a separate parse path. Formula and formatting diff are not available. Recommend converting to .xlsx before comparing large files.
.xlsm / .xlsb
Full support
Same as .xlsx
.xlsm adds macro metadata — comparison logic ignores VBA content and compares cell values and formulas only. .xlsb (binary OOXML) parses slightly faster than .xlsm on files above 200MB.
ROI Calculator
Baseline: approximately 2 hours per manual multi-sheet workbook comparison — opening both files, writing VLOOKUPs, scrolling through diffs, documenting findings, highlighting changes, and exporting a summary report. Adjust inputs to match your workflow.
Default 2 hrs — typical for a multi-sheet finance workbook
Monthly = 12, bi-weekly = 26, weekly = 52
Data analyst avg: $45–75/hr
Annual Time Saved
48.0
hours per year
Annual Labor Savings
$2,399
per year
Estimate: 24 comparisons × 2 hrs manual vs. 2.7s with SplitForge at $50/hr.
Benchmark Methodology
Honest Limitations: Where SplitForge Excel Compare Falls Short
No tool is perfect for every use case. Here's where desktop Excel / Beyond 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 combined input)
Both files must fit in browser memory simultaneously. For very large .xlsx files, SheetJS inflates the binary roughly 3–5× in memory — a 300MB .xlsx pair can consume ~1.5GB of heap. Chrome will show an out-of-memory error above this threshold.
Workaround:
Split files into smaller sheets before comparing, or compare sheet-by-sheet rather than all-sheets mode. Use SplitForge Excel Splitter to pre-process oversized workbooks.
Levenshtein distance is O(m×n) per cell pair. At high change rates across large files, the fuzzy pass can take 30–90 seconds. The overhead grows with string length, not just row count.
Workaround:
Narrow the fuzzy threshold to 85%+ to prune obviously-different pairs early, or disable fuzzy matching and use character-level diff alone for large files.
Formatting diff not available for .xls (BIFF8) files
The legacy .xls format stores styles in a binary structure that SheetJS does not fully expose for per-cell style comparison. Formula detection is also unavailable for .xls inputs.
Workaround:
Convert .xls files to .xlsx via Excel (File → Save As) before comparing. The conversion is lossless for data and most styles.
Multi-sheet comparison matches sheets by name only
If sheet names differ between the two files (e.g., 'Sheet1' vs. 'Data Jan'), they will not be automatically paired. Unpaired sheets are listed but not compared.
Workaround:
Rename sheets to match before running the comparison, or use the manual sheet-pair selector to map mismatched names.
No VBA / macro comparison
Comparison covers cell values, formulas, and formatting only. VBA module code, macro assignments, and ActiveX controls are ignored entirely.
Workaround:
For VBA diff, use a dedicated tool such as the Excel VBA Diff add-in or version-control your .xlsm files with Git and a VBA export script.
Output .xlsx export limited to ~500K diff rows
Generating a highlighted .xlsx output file with SheetJS for very large diffs (500K+ changed rows) can exhaust memory during the write phase, even if the comparison itself completed successfully.
Workaround:
Download the CSV summary report instead — it contains all diff metadata without the memory overhead of building a formatted .xlsx workbook.
When to Use desktop Excel / Beyond Compare Instead
Files larger than 500MB each
Browser memory limits make comparison unreliable at this scale — SheetJS heap inflation can exceed available tab memory.
💡 Use desktop Excel's Inquire add-in or Beyond Compare (file diff mode) for workbooks this large.
VBA or macro code comparison
SplitForge ignores all VBA content by design — only cell data, formulas, and formatting are compared.
💡 Export .bas modules with a VBA export script and diff them with Git or a text-diff tool such as WinMerge.
Multi-user collaborative review with tracked changes
SplitForge produces a static diff report — there is no annotation layer, comment thread, or accept/reject workflow.
💡 Use Excel's built-in Track Changes (Review tab) or SharePoint co-authoring with version history for collaborative review workflows.
Automated server-side diff in a CI/CD pipeline
SplitForge runs in a browser — it is not scriptable from the command line or callable via API.
💡 Use openpyxl (Python), ExcelJS (Node.js), or a headless SheetJS script integrated into your pipeline.
Questions about limitations? Check our FAQ section below or contact us via the feedback button.
Frequently Asked Questions
How fast is SplitForge Excel Compare compared to using VLOOKUPs in Excel?
Does the comparison slow down with more columns?
What happens if one file has more rows than the other?
How much RAM does the comparison use?
Can I compare files with different column orders?
Does fuzzy matching work on numbers?
Are .xlsb files slower to compare?
Is the comparison result deterministic? Will I get the same diff twice?
Benchmarks last updated February 2026 — Chrome 132, Windows 11, Intel i5-12600KF, 64GB RAM, NVMe SSD.
Compare Your Excel Files — Free, No Upload
Drop two .xlsx, .xls, .xlsm, or .xlsb files and get a cell-by-cell diff in seconds. Files never leave your browser.