XLSX vs XLS Difference: File Size, Limits & Compatibility

Open any old shared drive — a company’s archive, a university department folder, a government office in Delhi or a small business in Ohio — and you’ll find them: .xls files from 2004 sitting next to modern .xlsx workbooks, looking identical in the file list but built on fundamentally different technology. The xlsx vs xls difference matters more than most people realize: it affects file size, how much data a sheet can hold, whether your file survives corruption, and what happens when you share it. If you’ve ever wondered about the difference between xls and xlsx, why Excel opens some files in “Compatibility Mode,” or whether you should convert two decades of legacy files, this guide has the complete answer.

We’ll unpack what each format actually is under the hood, compare xls vs xlsx file size with real numbers, lay out the row/column/feature limits side by side, explain xls vs xlsx compatibility in both directions, cover the security differences most people miss, and give you a practical plan for converting legacy files — including what to check after conversion so nothing silently breaks.

The 30-second answer

XLS is Excel’s old proprietary binary format (Excel 97–2003): one opaque binary blob, 65,536 rows max, larger files, and macros mixed invisibly into the same file. XLSX is the modern open standard (Excel 2007+, Office Open XML): a ZIP package of XML documents, 1,048,576 rows, typically 50–75% smaller, better corruption recovery, and macros quarantined into a separate .xlsm extension. For any file you actively use, XLSX wins on every axis — the only reason XLS files still exist is legacy: old systems, old archives, and old habits.

What XLS actually is: the old binary format

XLS is built on Microsoft’s BIFF (Binary Interchange File Format) — a proprietary binary structure where the entire workbook (data, formatting, formulas, macros, metadata) is packed into a single opaque binary stream. “Binary” here means: only software that understands BIFF’s internal record layout can read it. For a decade (1997–2003) that was fine — Excel was the only meaningful reader — but it made the format fragile and closed.

The practical consequences of binary-ness: corruption is catastrophic — damage a few bytes in the wrong place and the whole file can become unreadable, because there’s no redundancy or human-readable fallback. Interoperability was reverse-engineered — LibreOffice, Google Sheets, and every third-party tool that reads XLS does so by reimplementing BIFF from documentation and observation, which is why old files sometimes render slightly wrong elsewhere. And everything is commingled — data, code (macros), and formatting in one blob, which is both a security headache (you can’t tell by looking whether an .xls contains macros) and an auditing nightmare.

XLS was a fine format for 1999. The world’s data got bigger, sharing got broader, and security expectations grew up — the format didn’t.

What XLSX actually is: the modern open format

XLSX is Office Open XML (OOXML) — and despite the intimidating name, the concept is beautifully simple: an .xlsx file is a ZIP archive containing XML documents. Don’t believe it? Rename any .xlsx to .zip, open it, and you’ll find folders: xl/worksheets/ (one XML file per sheet), xl/styles.xml (formatting), xl/workbook.xml (structure), and so on. Every part is human-readable text.

This architecture — standardized as ISO/IEC 29500 and documented on Wikipedia’s Office Open XML article — delivers the XLSX advantages almost automatically: transparency (any tool can parse XML; dozens of libraries exist in every programming language), robustness (corruption in one sheet’s XML rarely kills the whole workbook, and damaged parts can sometimes be repaired or even hand-edited), separation of concerns (data, styles, and metadata live in distinct parts), and compression (XML compresses extremely well inside the ZIP container — hence the dramatic size difference).

The macro separation deserves emphasis: plain .xlsx cannot contain macros at all. Macro-enabled workbooks use .xlsm. This isn’t a technical limitation — it’s deliberate security design. When you receive an .xlsx, you know with certainty it contains no executable code; when you receive an .xls, you know no such thing. That single fact justifies the entire format transition for security-conscious organizations.

XLS vs XLSX file size: why the new format is smaller

The xls vs xlsx file size comparison is the most immediately visible difference. Because XLSX compresses its XML content with ZIP, the same workbook is typically 50–75% smaller as XLSX than as XLS. A 10 MB .xls often becomes a 2–3 MB .xlsx with zero data loss. The savings are biggest for text-heavy and repetitive data (which compresses well) and smallest for workbooks full of embedded images (which are already compressed).

Why does size matter beyond disk space? Email attachment limits (many corporate mail servers still cap at 10–25 MB), upload/download speed on slow connections, cloud sync efficiency (OneDrive/SharePoint sync smaller files faster), and open/save speed (less I/O per operation). For teams emailing reports daily across regions with uneven connectivity — a real factor in India, parts of Africa, and rural areas worldwide — the size difference is a daily quality-of-life improvement, not a footnote.

One nuance: XLSX files with many sheets of tiny data can occasionally be similar in size to XLS (ZIP overhead dominates), and workbooks stuffed with high-res images won’t shrink much. But as a rule: converting XLS → XLSX shrinks the file, sometimes dramatically, always without losing anything.

Row, column, and feature limits compared

The xls vs xlsx row limit is the difference most likely to bite you in practice:

XLS: 65,536 rows × 256 columns per sheet. That 65k ceiling was set in an era when it seemed enormous; today, a single year’s e-commerce orders or IoT sensor readings blows past it without noticing. Data beyond row 65,536 is silently truncated on save — the most dangerous kind of limit, because the file looks fine while missing data.

XLSX: 1,048,576 rows × 16,384 columns per sheet — 16× the rows, 64× the columns. For the vast majority of real-world datasets, this is effectively unlimited.

Feature limits follow the same pattern: XLSX supports far more conditional formatting rules, more colors (millions vs. a 56-color palette in old XLS), more characters per cell (32,767 vs. 32,767 — actually the same, but XLSX handles them better), more sheets in practice, and modern features (Tables, slicers, sparklines, data models) that simply don’t exist in the old format. When Excel opens an XLS in Compatibility Mode, it deliberately disables modern features so the file stays saveable in the old format — that “[Compatibility Mode]” in the title bar is Excel telling you you’re driving with the handbrake on.

XLS vs XLSX compatibility: what opens what

Modern Excel opening XLS: fully supported — the file opens in Compatibility Mode, content intact, modern features disabled until you convert (File → Info → Convert). This is the everyday scenario for legacy archives, and it works fine.

Old Excel (2003 and earlier) opening XLSX: not natively — but Microsoft released a free Compatibility Pack back in the day, and in 2026 this scenario is essentially extinct. If someone is still on Excel 2003, the file format is the least of their problems.

LibreOffice Calc: opens both formats well; writes both (save XLSX for sharing — see our Excel vs LibreOffice Calc guide for the full compatibility picture). Calc is often the hero tool for rescuing ancient .xls files.

Google Sheets: imports both XLS and XLSX cleanly for standard content. Our Excel vs Google Sheets comparison covers the fidelity details.

Programmatic access: XLSX wins decisively — every modern language has mature OOXML libraries (openpyxl, SheetJS, Apache POI), while XLS support is legacy-maintenance mode. If your pipeline reads Excel files in code, XLSX is the only sane choice going forward.

CSV as the neutral ground: when compatibility gets truly messy — ancient files, mixed toolchains — drop back to CSV as the interchange format. A clean CSV import via the free CSV to Excel converter sidesteps every binary-format quirk entirely. (The CSV standard itself is defined in RFC 4180 — the rare file format with an actual RFC.)

Security, recovery, and macro differences

Security: the old .xls format is a single binary blob that can invisibly contain macros — historically one of the most abused malware vectors in office software (“macro viruses” plagued the 2000s). Modern Excel mitigates this with Protected View and macro warnings, but the format itself can’t distinguish code from data. XLSX’s architecture fixes this structurally: .xlsx = no macros possible; .xlsm = macros possible. The extension tells you the risk before you even open the file. For organizations with strict attachment policies, this alone justifies banning .xls.

Recovery: corrupt an XLS and you’re often done — binary formats fail catastrophically. Corrupt an XLSX and recovery is frequently possible: Excel’s built-in repair can salvage undamaged XML parts, and in desperate cases you can unzip the file and extract individual sheets’ XML by hand. It’s the difference between a shattered vase and a Lego set with a few missing bricks.

Inspection and auditing: because XLSX is readable XML, compliance and forensics tools can scan content without Excel — searching for sensitive data, verifying structure, diffing versions with standard text tools. Try diffing two binary .xls files meaningfully; then try it with two .xlsx files unzipped. The transparency dividend is real.

XLSX vs XLS difference at a glance

Sometimes a side-by-side table settles the xlsx vs xls difference faster than paragraphs. Here’s the complete comparison:

Format basis: XLS = proprietary binary (BIFF). XLSX = open XML in a ZIP container (OOXML, ISO/IEC 29500). Era: XLS = Excel 97–2003. XLSX = Excel 2007 onward. Typical file size: XLSX is 50–75% smaller for the same content. Max rows per sheet: 65,536 (XLS) vs 1,048,576 (XLSX). Max columns: 256 (XLS) vs 16,384 (XLSX). Macros: invisibly mixed into .xls vs quarantined in .xlsm (plain .xlsx can’t contain any). Corruption recovery: often fatal (XLS) vs frequently repairable (XLSX). Open standard: no (XLS) vs yes, ISO-standardized (XLSX). Programmatic libraries: legacy-only (XLS) vs mature in every language (XLSX).

The pattern is unmistakable: on every technical axis, the modern format wins. XLS persists for exactly three reasons — legacy systems that can’t be upgraded, archives that shouldn’t be altered, and habit. Two of those are legitimate; the third is fixable today.

Should you convert old XLS files to XLSX?

For active files: yes, convert. Smaller size, million-row capacity, better recovery, full modern features, macro transparency — there’s no downside for files you actually use. The conversion itself (File → Save As → .xlsx, or File → Info → Convert) preserves content faithfully for standard workbooks.

For archives: convert copies, keep originals. Historical archives should keep the untouched original (bit-for-bit provenance matters for legal/audit purposes) plus a converted working copy. Disk is cheap; provenance arguments are expensive.

What to verify after conversion: open the converted file and check — formulas recalculate identically (spot-check totals against the original), macros still work (VBA usually survives, but test every macro — save macro workbooks as .xlsm, not .xlsx, or the code is stripped), charts render correctly, print layout is unchanged, and row counts match (if the original was near 65,536 rows, confirm nothing was truncated before conversion — truncation would have happened at the original save, not during conversion).

When NOT to convert: files feeding ancient systems that only read .xls (some legacy ERP integrations, old lab equipment software) — convert the working copies and keep generating .xls for the machine. And files under legal hold: don’t touch the original, period.

How to convert XLS to XLSX (and back)

In Excel (single file): open the .xls → File → Info → Convert (upgrades in place, keeping the same filename root) or File → Save As → “Excel Workbook (*.xlsx)”. The Convert button is the cleanest path — it handles the format upgrade and drops Compatibility Mode in one step.

In Excel (batch): for folders of legacy files, a tiny VBA loop or PowerShell script converts them all — or Power Query can ingest a whole folder of .xls files into one modern workbook. For one-off batches, converting each via Save As takes seconds per file.

In LibreOffice Calc: open the .xls → File → Save As → “Excel 2007–365 (.xlsx)”. Calc’s batch conversion wizard (File → Wizards → Document Converter) handles entire folders — genuinely useful for archive migrations.

XLSX back to XLS (rarely needed): File → Save As → “Excel 97-2003 Workbook (*.xls)”. Excel runs the Compatibility Checker first, warning about every feature that won’t survive (Tables become ranges, >65k rows get truncated, modern functions become errors). Read that report carefully — it’s telling you exactly what you’ll lose. Only do this when a legacy system demands it, and keep the XLSX master.

A note on CSV in all of this: both XLS and XLSX can be exported to CSV, and CSV remains the great neutralizer — no versions, no compatibility modes, no binary mysteries. When a legacy .xls won’t convert cleanly, exporting to CSV and rebuilding in a fresh .xlsx (via the free CSV to Excel converter) is sometimes cleaner than fighting format quirks. You lose formatting and formulas in the hop, but for pure data rescue it’s the most reliable path available — and the resulting XLSX starts life in the modern format with full row capacity and compression from day one.

The xlsx vs xls difference ultimately tells a familiar technology story: an open, transparent, compressed standard replacing a closed, fragile, binary one. The transition happened in 2007; the stragglers are archives, legacy systems, and habit. Convert what’s active, preserve what’s historical, and never create a new .xls in 2026 — your future self, staring at a 65,537th row, will thank you.