How Can a Web App Process Large Files Offline? A Look at WebAssembly and Browser Sandboxes
Learn how the File API, Web Workers, WebAssembly, and browser sandboxes enable local file processing—and where privacy, network, and memory limits still apply. Includes Qudo as a practical example.
elect a PDF in a browser, wait for it to finish, and download the result. It feels like using an online service, so it is easy to assume the file must have been sent to a server.
But a web page can provide the interface and the program without sending the selected file away. Once the necessary code is loaded, the browser can read, transform, and export the file on the user’s device. The technology’s name does not determine whether a file is uploaded. What matters is whether the code sends the file’s contents over the network.
This article follows a file from local selection to download, explains what WebAssembly and browser sandboxes do, and looks at where local processing reaches its limits.
First, separate “using a web app” from “uploading a file”
When you visit a website, the browser usually downloads HTML, JavaScript, stylesheets, and other resources the tool needs. The app’s code comes from a server, but the file you select does not necessarily have to go back to one.
A page can receive a file through a file picker such as <input type="file"> or a drag-and-drop action. The browser represents that selection as a File object, which page code can read. The MDN File API documentation describes file access as being granted when users select or drop files.
Opening a page and uploading a file are different events. A web page may contact servers to load its code, ads, analytics, or updates while still processing a PDF locally. Conversely, using WebAssembly does not prove that a tool never uploads files.
The useful questions are about the specific tool’s data handling and observable network behavior. Qudo says that tools marked “local processing” generally do not upload selected files or input content to Qudo servers, while noting that each tool may work differently and its own page should be checked. Qudo Terms of Use · Qudo’s explanation of local processing
How does a browser read a local file?
A web page cannot freely scan a computer’s hard drive like a desktop app might. The user normally has to select or drop a specific file. The browser’s File API lets the page read the contents of that selected file; reading it does not itself send the file to a server. MDN: Using files from web applications
After a user selects a PDF, a typical flow looks like this:
- The browser provides a file object and access to its bytes.
- JavaScript coordinates the operation, updates the interface, and calls a processing library.
- For performance-intensive work or code written in languages such as C or C++, the page may call a WebAssembly module.
- The program produces new file data.
- The browser offers that result as a download.
What is WebAssembly? It is not an “offline” switch
WebAssembly, often shortened to Wasm, is a low-level bytecode format that can run in browsers and other environments. Developers can compile programs written in languages such as C, C++, or Rust to Wasm, then call them from JavaScript. For computationally intensive work—such as parsing PDFs, compressing images, or converting formats—Wasm can help web apps reuse mature code and reduce dependence on JavaScript performance.
Wasm’s security model matters: modules run in a restricted sandbox and cannot freely access the host operating system. Interaction with the page or external resources goes through interfaces provided by the runtime. The WebAssembly security documentation describes its isolation and bounds-checking model.
But Wasm does not decide whether a file should be uploaded. JavaScript in the page can still make network requests, and a Web Worker can use APIs such as fetch(). MDN’s Web Workers guide explains that workers can run computations in the background and make network requests. So “uses Wasm” or “uses a Worker” is not, by itself, evidence that files stay local.
In short:
- Wasm concerns how computation runs and what the module can access.
- Whether a file is uploaded depends on whether the app sends its contents in a network request.
Web Workers: keeping the interface responsive
PDF conversion may take seconds or longer. If all of the work runs on the same main thread that handles buttons, scrolling, and screen updates, the page can become temporarily unresponsive.
A Web Worker can move some computation to a background thread. The page can show progress and accept user interaction while the worker handles a long-running task, then returns a result or status message. MDN: Using Web Workers
Workers improve responsiveness and task organization; they are not a privacy boundary. A worker is still part of the web app and can access network APIs. Whether it uploads anything depends on the code.
The file’s path: from File to Blob
A common local-processing flow can be represented like this:
Local disk
│ User selects or drops a file
▼
Browser File object
│ JavaScript reads the data
▼
Web Worker (optional)
│ Calls JavaScript / WebAssembly processing code
▼
Output data is created as a Blob
│ Browser creates an internal object URL
▼
User downloads and saves the result locally
A Blob represents a chunk of file data. URL.createObjectURL() creates a temporary browser URL that refers to that Blob, which the page can use as a download link. MDN: Blob · MDN: Using object URLs to download Blobs
That blob: URL is not an address on Qudo’s or another website’s server. It is a browser-managed way to refer to data created locally. Apps should release object URLs when they are no longer needed to avoid retaining resources.
This flow is local only if the file data remains on the device and the app does not send it in a network request. Loading the page may still involve network traffic. To check a specific tool, you can inspect requests in the browser’s Network panel before and during processing. You can also load the page fully, disconnect the network, and try the operation. That test can show whether the current operation depends on connectivity, but it is not a full audit of the code or every possible request.
What does a browser sandbox protect—and what doesn’t it?
A browser sandbox restricts the permissions available to web code. For example, Chromium’s Site Isolation puts different websites in separated processes and limits one site’s access to another site’s data. Chromium: Site Isolation
This can reduce the risk of a malicious page accessing data from another site or directly reaching device resources. It does not mean that:
- a page cannot access the network;
- selected files cannot be sent by the page;
- third-party scripts, browser extensions, or malware on the device pose no risk;
- processing results are always correct; or
- Wasm programs cannot contain bugs.
Wasm’s memory bounds checks reduce some classes of out-of-bounds access, but they do not replace security maintenance for PDF parsers, page JavaScript, dependencies, or the browser itself. A sandbox protects boundaries in the execution environment; it does not automatically audit what a developer promises.
“2–4 GB per tab” is not a universal limit
When people discuss large files in browsers, they often say a tab can use only “2–4 GB of memory.” That is not a fixed rule shared by every browser and device. Available memory depends on the browser version, operating system, device architecture, current memory pressure, and how the app handles the file. A process can run out of memory before reaching any theoretical address-space limit.
A PDF’s size on disk also does not equal the memory needed to process it. The app may hold the original file, parsed structures, page objects, temporary output, and exported data at the same time. Scanned pages may also need to be decoded into high-resolution bitmaps.
For scale, rendering one A4 page at 300 DPI as an uncompressed RGBA bitmap takes about 33 MiB. If a workflow keeps 100 such page images in memory at once, the image data alone can exceed 3 GiB, before other overhead. Whether a particular app renders every page at once depends on its implementation; this example simply shows why a modest compressed PDF can still put pressure on a browser.
Wasm has its own memory model and bounds, but it does not bypass limits imposed by the browser, operating system, or device. Wasm memory grows in 64 KiB pages, and its practical range also depends on runtime support and available resources. MDN: The WebAssembly memory model
When memory runs short, the page may slow down, the tab may crash, processing may fail, or the result may not export. Trying smaller batches, reducing image resolution, or closing other memory-heavy tabs may help. Desktop software is often a better fit for hundreds of scanned pages, batch OCR, or production workflows because it can manage files, temporary storage, and long-running jobs more directly.
Which tasks suit local browser tools?
Browser-based local processing is often a good fit for:
- merging, splitting, or rotating a small number of PDF pages;
- compressing images or handling routine format conversions;
- viewing or cleaning metadata such as EXIF data;
- files of ordinary size that do not need long-running batch work; and
- quick tasks when you do not want to install software or are using another device.
Desktop software or a dedicated deployment may be a better fit when:
- files are very large, have many pages, or need lengthy batch processing;
- scanned-document OCR needs high accuracy or specific language support;
- the work involves complex PDF editing, prepress workflows, or professional digital signatures; or
- the system must run offline under centrally managed software, dependencies, and network policies.
According to Qudo’s documentation, tools marked “local processing” generally process files in the browser, but the site also notes that tools differ and very large files may be limited by browser memory. Qudo Terms of Use For highly sensitive files or strict compliance requirements, check the specific tool’s page, the browser’s network behavior, and your organization’s security rules.
The practical meaning of “local processing”
WebAssembly lets a page run high-performance modules. The File API gives a page access to files the user selects. Web Workers can keep long-running jobs from blocking the interface. Blobs and object URLs let the browser turn locally generated data into a download.
Together, these technologies mean that many everyday file tasks no longer need to upload documents to a server. But privacy is not guaranteed by any single technology name. To decide whether a tool is appropriate for your files, check how it reads and processes input, whether it makes upload requests, which features require a connection, and whether your device can handle the job reliably.