Generate Excel Files with a Specified Number of Rows (WASM + Web Worker Best Practice!)

Morse — Tue, 21 Jul 2026 14:18:32 +0000

If you've ever needed to create a large Excel file for testing, benchmarking, demos, or importing data, you probably know how slow browser-based generators can become.

I built a free online tool that lets you generate Excel files with any number of rows directly in your browser:

👉 Generate Excel Files with a Specified Number of Rows

No installation. No signup. Everything runs locally.

Why build another Excel generator?

Many online generators have limitations:

Slow when generating large files
UI freezes during generation
Limited customization
Data uploaded to servers

I wanted something that could generate very large Excel files while keeping the browser responsive.

Features

The tool supports:

Generate Excel files with a specified number of rows
Custom data generation rules
Configure columns freely
Generate files containing millions of rows
Fast download after generation
Completely free
Runs entirely in your browser

Whether you're testing import performance, stress testing an application, or creating sample datasets, it can save a lot of time.

Behind the scenes: WebAssembly + Web Worker

The interesting part isn't the UI—it's the architecture.

WebAssembly for high-performance Excel generation

Instead of using a pure JavaScript implementation, the Excel generation engine is built with Go + Excelize and compiled to WebAssembly (WASM).

This provides several advantages:

Near-native execution speed
Better performance for large workbooks
Lower memory overhead than many JS libraries
Reuse of a mature Excel library

Generating hundreds of thousands or even millions of rows becomes much more practical.

Web Worker keeps the UI responsive

Heavy Excel generation shouldn't block the main thread.

The WASM module runs inside a Web Worker, so users can continue interacting with the page while the workbook is being generated.

Benefits include:

No frozen UI
Better user experience
Progress reporting
Suitable for long-running tasks

This combination of WebAssembly + Web Worker is one of the best patterns for CPU-intensive browser applications.

Why not generate Excel on the server?

Generating files directly in the browser has several benefits:

No file uploads
Better privacy
No server-side computing cost
Works even for very large datasets
Scales naturally because computation happens on the client

Modern browsers are powerful enough to handle workloads that previously required backend services.

Use cases

This tool is useful for:

Excel/xlsx file Import testing
Performance benchmarking
Database migration testing
QA testing
Sample dataset generation
Demo data creation

Try it

If you're looking for a free online Excel generator that can create large workbooks quickly, give it a try:

👉 free online Excel generator that can create large workbooks quickly

I'm also interested in hearing how others are using WebAssembly for high-performance web applications.

Quickly Remove Empty Rows in Excel? WebAssembly Is a Great Fit

Morse — Tue, 21 Jul 2026 03:02:03 +0000

One of the most common Excel cleanup tasks is surprisingly simple:

Remove all blank rows at the bottom of a worksheet.

It sounds trivial until you need to process dozens of large spreadsheets without uploading them to a server.

I recently built an online tool for exactly this task, and it turned out to be a perfect use case for WebAssembly.

remove empty rows in Excel (online with WebAssembly)

Why WebAssembly?

Instead of reimplementing Excel parsing in JavaScript, I reused the excellent excelize library written in Go.

By compiling it to WebAssembly, I can run the same Excel processing engine directly inside the browser.

The advantages are obvious:

🚀 Native-like performance
🔒 Files never leave the user's computer
📦 Reuse a mature Go library instead of maintaining another implementation
💻 Works on Windows, macOS and Linux without installation

Processing Real Excel Files

The tool loads standard Excel workbooks (.xlsx) and removes unnecessary blank rows at the bottom while preserving the workbook structure.

Because the processing happens locally, there is:

No file upload
No waiting for a server
No privacy concerns

For many users, that's much more important than shaving a few milliseconds off execution time.

Is a 4 MB WASM File Too Large?

This is a question I asked myself before building it.

The compiled excelize WebAssembly module is around 4 MB after gzip compression.

While that sounds large compared to typical JavaScript bundles, it's actually acceptable for an application that performs heavy document processing.

The module is downloaded only once and then cached by the browser.

Considering it replaces a backend service and processes Excel files entirely offline, the trade-off is well worth it.

Why Go + excelize?

There are several JavaScript libraries for reading Excel files.

However, excelize has been battle-tested for years and supports a large portion of the XLSX specification.

Instead of reinventing complex spreadsheet logic in JavaScript, compiling the existing Go implementation to WebAssembly lets me reuse reliable production code.

It's one of those situations where WebAssembly really shines.

Try It Yourself

If you often receive Excel files with hundreds (or thousands) of unnecessary blank rows at the bottom, you can try the tool here:

👉 Remove Blank Rows in Excel (Online)

No installation.

No uploads.

Everything runs directly in your browser.

Tech Stack

Go
excelize
WebAssembly (WASM)
Runs completely in the browser

DEV Community: Morse