Qudo Tools
blog
Published 2026-11-21 · 9 min read · Qudo Tools

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:

  1. The browser provides a file object and access to its bytes.
  2. JavaScript coordinates the operation, updates the interface, and calls a processing library.
  3. For performance-intensive work or code written in languages such as C or C++, the page may call a WebAssembly module.
  4. The program produces new file data.
  5. 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:

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:

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:

Desktop software or a dedicated deployment may be a better fit when:

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.

← Back to blog