WolfSuiteWolfXLWolfPPTWolfDocxWolfRender

In-browser workbook check

See what openpyxl and WolfXL do to your workbook

Drop an Excel workbook. This page runs openpyxl 3.1.5 and WolfXL Community 2.0.9 in your browser on the same bytes, makes the one-cell edit from our agent-edit study with each, saves, and lists what did not survive side by side. If another tool already broke a file, drop the original and the broken copy to see what was lost and, for a workbook, rebuild the cell changes onto the original. Files never leave your device.

Check a workbook

Each file gets the study's edit, once per library, each in its own worker. The page then compares each saved copy with your original. Your original file is not changed.

  • openpyxl 3.1.5: load the workbook (with keep_vba=True for .xlsm), set Z1 on the first sheet to =1+1, and save. This is the edit-step half of the study's openpyxl workflow.
  • WolfXL Community 2.0.9: load with modify=True (and keep_vba=True for .xlsm), set Z1 on the first sheet to =1+1, call wb.calculate(), and save. This mirrors the study's WolfXL workflow. The extra calculate() call is Community's own Python formula evaluation, not LibreOffice, and the openpyxl side has no equivalent step, so the two sides are not identical operations.

Size limit: 25 MiB per file, applied to the compressed .xlsx or .xlsm as it sits on disk. A larger file is rejected before it is read or any Python starts. The limit says nothing about the unzipped size: a file under it can still expand to far more XML in memory, and a check that runs out of memory fails with an error on its own result.

Python loads only after you choose a file. Each file starts a fresh Python runtime for each library (Pyodide 0.29.5, then openpyxl 3.1.5 or WolfXL Community 2.0.9) and stops it when that library answers, so a large selection is checked one file at a time and every file pays the start-up time again. The browser's cache normally avoids repeating the downloads.

What the check measures

  • Package parts removed: every zip part in the original that is absent after the save, excluding xl/calcChain.xml because Excel rebuilds it. The byte-identical and total part counts include every source part.
  • Feature families lost: fewer primary parts for VBA, pivot tables and caches, charts, slicers, timelines, external links, drawings, tables, comments, or a Power Pivot model.
  • Sheet extension features: x14 extension elements, conditional formatting blocks, and data validation rules across all worksheets, plus a digest of the x14 content so a changed extension is not mistaken for an intact one. The comparison row lists which of these changed.
  • Warnings: the messages each library raised while loading and saving.

This is the edit step only. An agent workflow that then recalculates the file through LibreOffice can change more; the study measures both steps. The measurement says what happened to your file in this one edit. It does not show that either library preserves every workbook, or anything about Excel's own rendering of the result. The comparison code is the study harness's, and the public harness reruns the full method, recalculation included, on your machine.

Diagnose a broken file

Another tool saved your file and something went missing. Drop the original and the modified copy, both .xlsx or .xlsm workbooks, .docx documents, or .pptx presentations. The page lists every package part the modified copy removed, added, or changed, names the features it lost (images, charts, comments, VBA, embedded objects, and for workbooks pivot tables, slicers, timelines, tables, external links, and threaded comments), and lists extension (ext) entries that disappeared from changed XML parts.

For a workbook pair it can go one step further: WolfXL Community 2.0.9 finds the cells whose value or formula changed and writes them into a copy of your original in modify mode, which is designed to copy the other package parts through unchanged. The rebuilt file downloads as <original name>.rebuilt.xlsx (or .xlsm), and the page compares it with your original so you can see what the replay actually touched.

To check what an AI agent's edit did to a Word, Excel or PowerPoint file, compare the two copies on the agent edit check instead, where the result starts with a verdict on whether the edit stayed contained.

Size limit: 25 MiB for each file, as it sits on disk. The size and kind of both files are checked before either is read: a pair with a file over the limit, a file that is not .xlsx, .xlsm, .docx or .pptx, or two different kinds of file (a workbook against a document, say) is rejected without reading either file.

The part comparison runs in one background worker without Python, for every kind of file. Python (Pyodide 0.29.5) and WolfXL Community 2.0.9 load only for a workbook pair with replay switched on, in that same worker, which stops when it answers.

What the replay can and cannot do

  • Only cell contents are replayed: values and formulas, on the sheets both files share. Every other change the comparison lists is reported as not replayed, including formatting and styles, charts, drawings, pivots, defined names, and document properties.
  • Structural worksheet changes are not replayed: sheets added, removed, or renamed (a rename shows as one removed and one added sheet), inserted or deleted rows and columns, moved ranges, merges, and the ranges of conditional formatting and data validation. An inserted row shows up as many separate cell changes, which are written at their new addresses without shifting formulas, merges, or ranges in the original, so check such a result before you rely on it.
  • Some values are not written: cell values outside text, numbers, booleans, dates and times, and plain formulas (array and data-table formulas, rich text, or error values, for example) are listed as not replayed, with their reason.
  • Change limit: at most 100,000 cell changes are replayed per pair. Changes past the limit are listed as not replayed, never dropped silently.
  • No recalculation: formulas are written without calculated results, and wb.calculate() is not called. A spreadsheet app computes them when it recalculates; a reader that only uses stored results sees none until then.
  • Read-back check: every replayed cell is read back from the saved file and compared with the modified copy. A cell that reads back differently is listed as not replayed.
  • How parts are compared: by the CRC-32 checksum and unpacked size each zip directory records, so recompressing a part without changing its content does not count as a change. CRC-32 is not a cryptographic hash: two different versions of a part could in principle share a checksum and size and would then be reported as unchanged. Feature counts come from part names, so a part that kept its name but lost its content shows as changed, not as a lost feature. Extension entries are counted by URI in changed or removed XML parts, up to 200 MiB of unpacked XML per pair; past that the result says the scan is incomplete.
  • Documents and presentations are compared, not rebuilt. Replay covers .xlsx and .xlsm workbooks only.
  • Community, not Commercial: the replay runs WolfXL Community 2.0.9 in your browser, with the same limits as the edit check above. It says nothing about what WolfXL Commercial would do with the same pair.

Which WolfXL runs here

  • WolfXL Community 2.0.9, the MIT-licensed edition that is on public PyPI with no credential, compiled to WebAssembly for Pyodide 0.29.5 from the Community source. The WebAssembly build is made for this site and is not published to PyPI or any other registry.
  • WolfXL Commercial is a separate edition, installed from an authenticated package index (releases 2.1 and later). Its documentation lists native recalculation, rendering, format conversion, VBA and Power Query operations, and an operations SDK that Community does not include. None of that runs here, so these results and the replay describe Community and do not describe Commercial. See the install documentation for the difference between the editions.
  • Running in a browser has its own limits: a 25 MiB compressed-file limit for each file, including each file of a compared pair (shown above the results), memory shared with the browser, and Python 3.13 under Pyodide rather than a native interpreter.

Where your workbook goes

  • For the edit check, your browser reads the file and hands its bytes to two background workers in this tab, one per library, each with its own copy. For a broken-file comparison, it hands both files' bytes to one background worker in this tab. A file over the size limit, or a pair of mismatched kinds, is rejected before anything is read.
  • Each edit-check worker writes its copy to an in-memory filesystem, runs one library there, and is shut down when it answers. A comparison worker compares the two packages in memory without Python; for a workbook pair with replay switched on, it then loads Python and WolfXL, builds the rebuilt workbook in an in-memory filesystem, hands it back to this tab, and is shut down. The rebuilt file is offered as a download link created in this tab, released when you start another comparison or leave the page. Nothing is uploaded or stored, file names never reach a worker, and file names and results stay on this page.
  • The only downloads come from this site: the unmodified Pyodide 0.29.5 runtime (MPL-2.0), copies of the PyPI files openpyxl-3.1.5-py2.py3-none-any.whl and et_xmlfile-2.0.0-py3-none-any.whl and defusedxml-0.7.1-py2.py3-none-any.whl, and the WolfXL WebAssembly build wolfxl-2.0.9-cp313-cp313-pyemscripten_2025_0_wasm32.whl, each checked against its pinned SHA-256 before it is installed. None of these requests carries workbook data.
  • Third-party license notices for the Rust crates compiled into the WolfXL WebAssembly module and for defusedxml (PSF License) are in WOLFXL-THIRD-PARTY-NOTICES.txt.
  • The site's cookieless analytics counts the visit, as on every page. It records no file name, content, or result.

Make the same edits yourself

WolfXL Community is MIT-licensed and on PyPI, and includes modify mode, which patches the cells you change and is designed to copy the other package parts through unchanged. The check above is how you see whether that held for your file. Read the modify mode documentation or the study write-up.

# openpyxl 3.1.5
import openpyxl

wb = openpyxl.load_workbook("report.xlsx")  # keep_vba=True for .xlsm
wb[wb.sheetnames[0]]["Z1"] = "=1+1"
wb.save("report.xlsx")
# WolfXL Community 2.0.9: pip install wolfxl
import wolfxl

wb = wolfxl.load_workbook("report.xlsx", modify=True)  # keep_vba=True for .xlsm
wb[wb.sheetnames[0]]["Z1"] = "=1+1"
wb.calculate()
wb.save("report.xlsx")
wb.close()