Why I Built a File Converter That Doesn't Upload Your Files

Source: Dev.to

The Problem with Cloud Converters

We’ve all been there. You have a PNG you need as a JPG. You have a WAV file you need as an MP3. Or maybe a JSON file you need to convert to YAML.

You Google it. You click the first result: “Free Online Converter!” It asks you to upload your file.

You hesitate.

• Maybe that file is a scan of your ID.
• Maybe it’s a financial spreadsheet.
• Maybe it’s a confidential work document.
• Or maybe it’s just a personal photo you’d rather not share with a random server in a jurisdiction you can’t pronounce.

But you’re in a hurry. You upload it, wait for the progress bar, download the result, and hope that “Delete after 24 hours” is actually true.

This workflow is broken. In 2026, with the computing power available in our web browsers, there is absolutely no reason to send a 5 MB image to a server halfway across the world just to change its file format.

That is why I built Sagasu Tools.

The Paradigm Shift: Local‑First Web Apps

The web has evolved. It used to be a dumb terminal for displaying text. Then it became a way to send forms to servers.

Today, the browser is a full‑fledged operating system.

With technologies like WebAssembly (Wasm), Service Workers, and the File System Access API, we can bring desktop‑class performance and privacy to the web.

My goal with tools.sagasu.art was simple: Zero server‑side processing.

How It Works

When you visit a traditional converter site:

• Client: Select file → Upload (bandwidth cost + privacy risk)
• Server: Receive file → Spin up process → Convert (CPU cost) → Save temp file
• Client: Download result (bandwidth cost)

When you use Sagasu Tools:

• Client: Select file → Browser processes it locally → Save result.

There is no step 2. The server serves the static HTML/JS/Wasm assets once, then gets out of the way. You could literally turn off your Wi‑Fi after the page loads, and the tool would still work.

Under the Hood: FFmpeg.wasm and Friends

The secret sauce for many media converters today is FFmpeg, the Swiss Army knife of audio/video processing.

Traditionally, FFmpeg runs on Linux servers. Thanks to the Emscripten compiler toolchain, we can compile FFmpeg’s C code into WebAssembly.

// Example: loading ffmpeg.wasm in a Web Worker
import { createFFmpeg, fetchFile } from '@ffmpeg/ffmpeg';
const ffmpeg = createFFmpeg({ log: true });
await ffmpeg.load();
await ffmpeg.write('input.mp4', await fetchFile(file));
await ffmpeg.run('-i', 'input.mp4', 'output.webm');
const data = ffmpeg.read('output.webm');

ffmpeg.wasm allows the browser to run FFmpeg directly in a Web Worker. This means when you convert a video on my site, your CPU fan might spin up, but your network card stays quiet. The data never leaves your RAM.

Benefits

• Privacy: Data never leaves your device, so it can’t be intercepted, stored, or sold. GDPR‑compliant by design because there is no data processing on my end.
• Speed: For many files, uploading and downloading takes longer than the actual conversion. Local conversion is instant for small files.
• Cost: I host only static files (thanks to Cloudflare Pages), so the hosting bill is effectively zero, allowing a free, ad‑free tool.
• Reliability: No “Server Overloaded” errors. If your computer works, the tool works.

The Challenges of Client‑Side Processing

It’s not all sunshine and rainbows. Building a local‑first converter comes with trade‑offs.

1. Browser Constraints

Browsers sandbox everything. Managing memory in WebAssembly can be tricky. Converting a 4 GB video in Chrome might crash the tab because browsers limit how much RAM a single tab can use. Cloud servers can throw 128 GB of RAM at a problem; your browser tab gets maybe 4 GB.

2. Initial Load Time

The ffmpeg.wasm core is large (around 25 MB). Downloading this takes time on the first visit.

Solution: Aggressive caching. Once you’ve visited the site once, the Wasm binary is stored in your cache. Subsequent visits are instant.

3. Format Support

While FFmpeg is extensive, compiling every codec into Wasm bloats the file size. I have to be selective about which formats to support to keep the app lightweight.

Beyond Media: Unit Conversion, JSON, and More

The same local‑first philosophy applies to everything on tools.sagasu.art.

• JSON Formatter: Why send your config files to a server to pretty‑print them? Do it in JavaScript.
• Base64 Encoder: Simple string manipulation that should never touch a backend.
• Unit Converter: Pure math. Zero latency.

Why This Matters

We are seeing a swing back towards “thick clients.”

• In the 1990s, we installed .exe files.
• In the 2010s, we moved everything to the cloud (SaaS).
• In the 2020s, we are moving back to the edge and the client, but delivered via the web.

This hybrid model—Web distribution, Local execution—is the future of utility software. It combines the friction‑free access of a website (no install required) with the privacy and performance of a desktop app.

I built this converter because I wanted to use it. I wanted a bookmark I could click, drag a file onto, and get a result, without worrying about who is looking at my data.

If that sounds like something you need, give it a try at tools.sagasu.art. No signup, no upload, no nonsense. Just tools.