Open a Large CSV
Files up to 250 MB and millions of rows, opened in this tab. Parsing runs on a background thread with a real progress bar, and only the rows on screen ever become HTML, so scrolling a million-row file feels like scrolling a hundred-row one. Nothing is uploaded.
Nothing big to hand? Make one.
This builds a genuine CSV in your own browser, in slices so the tab keeps responding, then opens it in the viewer below through exactly the path a dropped file takes. It reports the file size and how long it took, on your machine rather than ours.
Why the file will not open
There are three separate walls, and it helps to know which one you have hit.
The spreadsheet's row limit. An Excel worksheet holds 1,048,576 rows. Hand it a longer file and it loads the first million-odd and tells you the file was not loaded completely. That is not a warning about performance; it means data is missing from what is on your screen, and any total you compute is wrong. Google Sheets has a cell budget instead of a row limit and refuses in its own way.
The text editor's memory. Editors load the whole file and build an index of every line, which for a few hundred megabytes means several times the file's size in RAM, and a tool that was never designed to scroll a million lines smoothly. Some now refuse large files outright rather than trying.
The web tool's upload. Most online CSV viewers post the file to a server. That means waiting for the upload, hitting a free-tier size cap, and handing your data to somebody else. A 250 MB file is a slow upload on a good connection and an impossible one on a bad one, and if the file holds customer records it should not be leaving your machine at all.
This page has none of the three. There is no worksheet, so no row limit. The file is never fully turned into DOM, so rendering cost does not grow with it. And there is no upload, so the ceiling is your device's memory rather than a server's tolerance, and the file opens in seconds because it never travels.
How it actually works
Three decisions do most of the work, and they are worth stating plainly because they are the difference between a page that claims to handle large files and one that does.
Only the visible rows exist. The grid measures the file and gives the scroll container a height of row count times row height, so the scrollbar is real and behaves correctly. Then it draws about forty rows, positioned to sit where you are looking. Scroll, and those forty are repainted with different values. At no point are there a million rows in the document, which is why a million-row file scrolls exactly like a hundred-row one.
Parsing happens off the main thread. Anything over 2 MB goes to a worker, which reads the file in four-megabyte chunks and posts its progress in bytes as it goes. That is why the progress bar moves smoothly and reflects reality: it is reporting bytes decoded, not guessing. The tab stays interactive throughout, so a thirty-second parse does not look like a crash.
The table is stored by column, not by row. A million rows of five columns held as arrays of strings means five million small JavaScript strings, each with its own object overhead, which costs several times what the file costs. Instead each column is kept as one concatenated string plus an array of offsets into it. A cell is a slice, computed only for the rows being painted. That representation is also cheap to hand back from the worker, because the offsets are transferable buffers rather than something that has to be copied.
The upshot is that the ceiling is memory, and memory is about the size of the file rather than a multiple of it. 250 MB is the honest number for a browser tab. The full editor goes to 1 GB by streaming into DuckDB instead, which is a different technique with a different trade-off.
What you can do with a file this size
Sort a million rows
Sorting reorders an index rather than the data, so nothing is copied. Numbers sort as numbers, dates as dates, and blanks stay at the bottom in both directions.
Filter as you type
The scan is debounced so typing stays responsive, and the counter tells you how many of how many rows match. region:north narrows a term to one column.
Statistics over the file
Blanks, distinct count, min, max, mean, median and sum from a header click. Very large columns are read from a generous sample and the popover says so rather than pretending.
Freeze the key columns
Pin up to three columns to the left edge so the identifier stays visible while you scroll a wide export sideways.
Export a subset, not the file
Download CSV and .xlsx write the current view. Filter a million rows to the two hundred that matter and the download is those two hundred.
Copy a range
Select cells and Copy as TSV, CSV, Markdown or JSON, without the intermediate step of exporting a file you are going to delete.
Values kept exactly
Leading zeros, long identifiers and unusual date formats survive, because cells are strings and the type badge is a label rather than a conversion.
A real progress bar
Reporting bytes decoded, not a guess. A long parse looks like a long parse rather than like a hung tab.
An honest ceiling
Over 250 MB you get the file's size, the limit, and a link to the full editor. Not a hang, not a crash, not a silent truncation.
A worked example: the demo file
Set the generator above to 1,000,000 rows and press the button. It builds an orders table with ten columns, in slices of twenty thousand rows, yielding to the browser between each so the progress bar can actually paint. On a current laptop this takes a few seconds and produces a file somewhere around 105 MB.
Then it hands the file to the viewer as a real File, through the same entry point a drag and drop uses. That matters: the demo is not a shortcut that loads an in-memory table straight into the grid. It goes through the worker, the parser and the store exactly as your own file would, so the timing you see is the timing you would get.
Once it is open, try the things that are supposed to be hard. Scroll to the bottom by dragging the scrollbar: the rows keep up. Click a header to sort a million rows by amount. Type a customer name in the filter and watch the counter fall from 1,000,000 to whatever matches. Click the sigma on the amount column for the min, max, mean, median and sum. Then filter to something small, and Download CSV, and check that the file you get holds the filtered rows rather than all of them.
The generated data is deterministic: the same seed produces the same file every time, so if you run it twice you get an identical CSV, and two people comparing how long it took are comparing the same work.
Notes on memory, honestly
- 250 MB is a ceiling, not a promise. It is the point past which this page hands you to the full editor. Whether a 240 MB file opens comfortably depends on your device, what else the browser is holding, and how wide the rows are.
- Wide beats long for cost. A million rows of five columns is cheaper than two hundred thousand rows of a hundred columns, because per-column overhead is what adds up. If a file is struggling, the column count is usually why.
- A 32-bit or memory-constrained browser will stop sooner. Mobile browsers in particular have much lower per-tab budgets than the desktop numbers here imply.
- The grid holds up to two million rows. Past that you are told the true total and shown the first two million, rather than being quietly given a truncated table with no note.
- Closing the tab frees everything. Nothing is written to disk, nothing is cached between visits, and there is nothing to clean up.
Frequently Asked Questions
How big a CSV can I actually open here?
250 MB, which is roughly one to three million rows depending on how wide they are. That is a browser-tab memory ceiling rather than an upload limit, because there is no upload: the file is read from your disk in your own tab. Above 250 MB, the full editor streams files up to 1 GB without holding all of them in memory at once.
Why does my spreadsheet refuse to open the file?
An Excel worksheet holds 1,048,576 rows. Given a longer file it loads the first million-odd rows and warns that the file was not loaded completely, which is a polite way of saying the rest is missing. Google Sheets has a cell budget instead and gives up in the same spirit. Neither limit applies here, because a browser grid is not a worksheet.
How can a browser show a million rows without freezing?
It does not show a million rows. Only the roughly forty rows in your viewport become HTML elements; the scrollbar is real because the container is the right height, and the other 999,960 rows are arithmetic. Scrolling repaints those forty. That is why scrolling a million-row file feels the same as scrolling a hundred-row one.
Can I really generate a million-row file here?
Yes, and you should, because a claim about large files is worth more when you can test it on your own machine. The button on this page builds a real CSV in your browser, in slices with a progress bar so the tab stays responsive, then opens it in the viewer through the same path a dropped file takes. It tells you the file size and how long it took.
Does it use all my memory?
It is careful with it. A table is held as one concatenated string per column plus an array of offsets, rather than as millions of small row arrays, which costs roughly what the file costs rather than several times more. The parse also runs in a worker and hands the result back as transferable buffers, so a million rows do not get copied on the way out.
Is anything uploaded?
No. There is no upload endpoint on this page, which is also why the size ceiling is about your device rather than about somebody's bandwidth bill. A 250 MB file that would take minutes to upload to a web service opens here in seconds because it never goes anywhere.
What can I do with the file once it is open?
Sort by any column, filter as you type, read per-column statistics including min, max, mean, median and sum, freeze the first columns, select a range and copy it as TSV, CSV, Markdown or JSON, and export the current view as CSV or Excel. The export follows the view, so filtering first gives you the subset rather than the whole file.
What happens if the file is too big even for this?
You get told, with the file's size and the ceiling, and a link to the full editor rather than a hang or a crash. The full editor handles up to 1 GB by streaming into DuckDB rather than holding the file in a JavaScript structure, and gives you SQL over it as well.
Related tools and guides
Test the claim on your own machine
Generate a million rows, open them, sort them, and see how long it takes. No upload, no account, no row limit.
Back to the viewer