Convert XLS to XLSX

The binary Excel format allows exactly 65,536 rows on a sheet, a number chosen when a spreadsheet lived in memory measured in megabytes. Nobody encounters it by counting. They encounter it when a database export, a transaction log or a survey extract arrives and quietly stops, and the last row is not the last record.

That is a genuinely dangerous failure, because a truncated sheet looks entirely normal. The totals are wrong and nothing says so. If a file you are reconciling ends at row 65,536, treat that as a format limit until proved otherwise, re-export into a container that can hold the data, and check the count rather than the appearance. Converting the truncated file does not bring the missing rows back — they were never written. It removes the wall so that the next export lands complete, which is why the order is convert, re-export, reconcile, and not the other way round.

The same generation capped a sheet at 256 columns, ending at IV. That was ample for a ledger and is not ample for the wide tables modern systems produce: a survey with one column per question, a monthly grid spanning several years, an analytics export with a field for every attribute.

XLSX allows 16,384 columns, out to XFD. In practice a table that genuinely needs several hundred columns is telling you something about its shape rather than its format, and is often better held long rather than wide. But the conversion removes the immediate obstacle, and reshaping the data is a decision that can be made afterwards rather than under deadline. The column limit also fails less obviously than the row limit, because a table that runs off the right-hand edge looks like a table that ends there. Nobody scrolls to column IV to check whether anything was waiting behind it.

A binary workbook can hold roughly four thousand distinct cell format combinations, where a combination is one particular mix of font, size, colour, border, fill and number format. Formatting applied a column at a time, copied between sheets and layered over years accumulates these quietly, and the workbook eventually refuses to accept another one.

The message is confusing because the workbook does not look elaborately formatted; the styles are mostly duplicates that differ in one attribute. XLSX raises the ceiling to around sixty-four thousand, which makes the error go away. It is still worth clearing unused formatting afterwards, because a workbook that reached four thousand by accident will reach sixty-four thousand the same way. The usual culprit is formatting applied to whole columns or whole sheets rather than to the used range, repeated across a dozen sheets by people copying each other’s work. Selecting the genuinely empty region and clearing its formats removes most of the accumulation in one action.

The old format carries a palette of 56 colours for the whole workbook. Anything outside it is snapped to the nearest entry, which is why a carefully chosen corporate shade turns into an approximation of itself and why two different greens sometimes become the same green.

Conditional formatting was limited to three rules per range in the same generation, which is the constraint that turns a simple traffic-light scheme into a nest of nested IF statements in a helper column. Converting removes both limits at once. The colours already flattened in the old file do not come back, but everything applied from here on behaves as expected. That is the pattern for every limit on this page and it is worth stating once: the conversion lifts the ceiling, it does not restore what hit the ceiling. Data lost to truncation, colours snapped to a palette and rules that were never added are all gone for good.

This is the one loss that catches people, and it is not a shortcoming of the converter. Microsoft deliberately separated macro-bearing workbooks into their own extension when the format changed, so a file called .xlsx is guaranteed to contain no executable code. Sending one is therefore a stronger statement than sending a binary workbook that might contain anything.

If the automation is the point of the file — a button that builds a report, a routine that validates entries on save — this conversion gives you the data and not the behaviour. That workbook needs the macro-enabled format instead, and moving it is a decision about what the file is for rather than about which container it sits in. In an archive migration this is usually a small minority of files and worth separating out before the batch runs, so that nobody discovers three months later that the quarterly reporting tool converted successfully and stopped working.

The calculation model did not change between the two generations, so formulas are carried across as formulas: the dependency graph is intact, named ranges continue to resolve, cross-sheet references still point where they pointed, and recalculating produces the same answers as before.

What is worth checking afterwards is anything that reached outside the file — a link to another workbook on a drive letter that no longer exists, a query against a database nobody has credentials for any more. Those were already broken; the conversion makes it the moment you notice, which is a good moment for it to happen. Volatile functions are the other thing to look at once. A sheet that has not been recalculated since 2011 may be showing cached results, and opening the converted file recalculates it — so a figure that changes is not the conversion being wrong, it is the old one having been stale.

Because XLSX is a ZIP archive of XML parts, the content is compressed on the way in, where the binary format stores its records as they are. Workbooks that are mostly numbers and formulas commonly come out several times smaller, which is noticeable across a shared drive full of them.

Embedded images do not compress further, since a JPEG is already compressed, so an image-heavy workbook stays roughly the same size. If a spreadsheet is large because somebody pasted screenshots into it, the conversion will not help and the screenshots are the thing to address.

The other common route to this page is an import screen. Accounting platforms, procurement portals, payroll systems and analytics tools have steadily narrowed to the modern format, partly for the limits described above and partly because the binary formats were a delivery mechanism for malicious files for years.

That last reason is why the answer is to convert rather than to ask for an exception. A file arriving as .xlsx carries no macro project, which is precisely why their intake rules were written that way, and no amount of explaining that your spreadsheet is harmless will change the upload form.

Reading a 1990s binary spreadsheet takes a full office engine, so this pair runs on a server rather than in your browser. The file goes over an encrypted connection to a container that runs LibreOffice headless and contains nothing else; the page says so rather than leaving you to assume it happened locally.

The container is not permitted to open outbound connections. Every job gets its own scratch directory and its own LibreOffice profile, and the directory is deleted as soon as the job ends, successfully or not. Anything still running after sixty seconds is terminated, because a damaged binary file is more likely to make the engine hang than to produce an error. The free limit is 25 MB per file.

If the old file was truncated at 65,536 rows, the honest question is not which spreadsheet format to use but whether a spreadsheet is still the right home. A million rows opens slowly, recalculates slowly and is edited by hand at everyone’s peril.

At that size a columnar or database format is the better destination: CSV for an import, Parquet for analysis, SQL for a load into a real table. Convert to XLSX when a person will keep working in the grid, and treat the row count as the signal that they should not have to.