Rust vs Python vs Node.js Speed Comparison on ZIP Image Loading Benchmark

Lycoris52 — Wed, 04 Mar 2026 14:26:01 +0000

When I previously created a manga viewer application in Rust called RustMangaReader, the most important thing for considering which programming language to be used was loading speed.

So I need to test which programming language is the fastest.

If you are interested in the manga viewer itself, it's on this github:

Lycoris52 / RustMangaReader

Windows Manga Viewer written in Rust

日本語の説明はこちら

RustMangaReader

RustMangaReader is a high-performance, lightweight offline manga and comic viewer built in Rust.
Designed specifically for the Windows, it focuses on providing a fluid, lag-free reading experience through preloading and native rendering.

⚡ Key Features

Built for Speed: Uses a dual-buffer system to preload upcoming and previous pages in the background, ensuring near-instant page turns.
Optimized for Windows:
- Leverages Windows-native sorting (so "Page2" comes before "Page10")
- High-performance GPU rendering.
- No Zip extraction required RustMangaReader reads directly from compressed files saving disk space without sacrificing speed.
Smart Scaling: Includes multiple resampling algorithms from Nearest Neighbor to Lanczos3 to make every scan look its best on your monitor.
Tailored Reading: Supports Single Page, Double Page (Left-to-Right), and Double Page (Right-to-Left) modes, including a "Cover + Spreads" shift toggle (Odd/Even page).

🎁 Free & Open Feedback

MangaReader is a completely free application!
I want to make it…

View on GitHub

Since I already ran some benchmarks before developing it, I thought it might be helpful to share the results.

Choosing the Languages

Here is my speculation about each language before testing:

C++
Probably the fastest, but honestly it is really painful to write.

Python
Very easy to write, and I use it a lot at work.
But it is slow.
Still, if I want to add AI features later, it will be really useful if the base program is developed using python.

JavaScript
Very easy to deploy on many operating systems.
There are many native libraries, so I expected it might not be too slow.

Rust
I have been curious about Rust for a long time and wanted to learn it.
But since I had never used it before, I wasn’t sure if it was really that fast.

So I decided to write simple programs in each language and measure the speed.

(I didn’t write the C++ version because it looks too troublesome… sorry.)

Preparation

The main feature I wanted for the manga viewer was:

Reading images directly from a ZIP file without extracting it.

So the benchmark program does exactly that.

Now, I needed a ZIP file containing many images, so I created one.
I asked ChatGPT to generate a random 4K image, duplicated it 10 times, and put them into a ZIP file.

Size of one image: 7.17 MB
ZIP file size: 71.7 MB

Machine Specifications

The benchmark machine specs:

CPU  : AMD Ryzen 9 7900
RAM  : G.Skill F56000J3036G 32GB DDR5x2
NVMe : Samsung 990 Pro 4TB

Benchmark Code

Rust

use std::env;
use std::fs::File;
use std::io::{Read, Seek};
use std::time::Instant;

fn parse_arg(args: &[String], key: &str, default: &str) -> String {
    args.iter()
        .position(|a| a == key)
        .and_then(|i| args.get(i + 1))
        .cloned()
        .unwrap_or_else(|| default.to_string())
}

fn main() -> anyhow::Result<()> {
    let zip_path = "./benchmark_images.zip";
    let iters: usize = 10;

    // Warmup + timed iterations
    let mut best_ms = f64::INFINITY;
    let mut last_stats = (0usize, 0u64);

    for iter in 0..iters {
        let file = File::open(&zip_path)?;
        let mut archive = zip::ZipArchive::new(file)?;

        let start = Instant::now();

        let mut count = 0usize;
        let mut total_bytes: u64 = 0;

        // Iterate entries in zip
        for i in 0..archive.len() {
            let mut f = archive.by_index(i)?;
            let name = f.name().to_string();

            let mut buf = Vec::with_capacity(f.size() as usize);
            f.read_to_end(&mut buf)?;
            total_bytes += buf.len() as u64;

            // Decode to pixels (forces actual image parsing)
            let img = image::load_from_memory(&buf)?;
            // Force pixel materialization
            let _rgba = img.to_rgba8();

            count += 1;
        }

        let elapsed = start.elapsed().as_secs_f64() * 1000.0;
        last_stats = (count, total_bytes);

        // skip first run as warmup-ish if you want, but we’ll just keep best
        if elapsed < best_ms {
            best_ms = elapsed;
        }

        eprintln!("iter {}: {:.2} ms", iter + 1, elapsed);
    }

    let (count, total_bytes) = last_stats;
    let secs = best_ms / 1000.0;
    let mb = total_bytes as f64 / (1024.0 * 1024.0);

    println!("zip: {}", zip_path);
    println!("images: {}", count);
    println!("bytes read: {} ({:.2} MiB)", total_bytes, mb);
    println!("best time: {:.2} ms", best_ms);
    if secs > 0.0 {
        println!("throughput: {:.2} images/s", count as f64 / secs);
        println!("throughput: {:.2} MiB/s", mb / secs);
    }

    Ok(())
}

Python

import time
import zipfile
from io import BytesIO
from PIL import Image

def run_once(zip_path: str) -> tuple[float, int, int]:
    t0 = time.perf_counter()

    count = 0
    total_bytes = 0

    with zipfile.ZipFile(zip_path, "r") as zf:
        for info in zf.infolist():
            data = zf.read(info)  # read entry into memory (no extracting)
            total_bytes += len(data)

            # Decode image fully (force pixel load)
            with Image.open(BytesIO(data)) as im:
                im.load()

            count += 1

    t1 = time.perf_counter()
    return (t1 - t0), count, total_bytes

best = float("inf")
last = (0, 0)

for i in range(10):
    sec, count, total_bytes = run_once("benchmark_images.zip")
    last = (count, total_bytes)
    best = min(best, sec)
    print(f"iter {i+1}: {sec*1000:.2f} ms")

count, total_bytes = last
mib = total_bytes / (1024 * 1024)

print(f"zip: benchmark_images.zip")
print(f"images: {count}")
print(f"bytes read: {total_bytes} ({mib:.2f} MiB)")
print(f"best time: {best*1000:.2f} ms")
print(f"throughput: {count/best:.2f} images/s")
print(f"throughput: {mib/best:.2f} MiB/s")

Javascript(Node.js)

import fs from "node:fs";
import yauzl from "yauzl";
import sharp from "sharp";

function hrNowSec() {
    return Number(process.hrtime.bigint()) / 1e9;
}

async function readEntryToBuffer(zipFile, entry) {
    return new Promise((resolve, reject) => {
        zipFile.openReadStream(entry, (err, stream) => {
            if (err) return reject(err);
            const chunks = [];
            let total = 0;
            stream.on("data", (c) => { chunks.push(c); total += c.length; });
            stream.on("end", () => resolve({ buf: Buffer.concat(chunks, total), bytes: total }));
            stream.on("error", reject);
        });
    });
}

async function runOnce(zipPath, mode) {
    const t0 = hrNowSec();

    let count = 0;
    let totalBytes = 0;

    const zipFile = await new Promise((resolve, reject) => {
        yauzl.open(zipPath, { lazyEntries: true }, (err, zf) => {
            if (err) return reject(err);
            resolve(zf);
        });
    });

    const done = new Promise((resolve, reject) => {
        zipFile.readEntry();

        zipFile.on("entry", async (entry) => {
            const { buf, bytes } = await readEntryToBuffer(zipFile, entry);
            totalBytes += bytes;

            // Force actual decode to pixels
            // raw().toBuffer() makes sharp decode the image data
            await sharp(buf).raw().toBuffer();

            count += 1;
            zipFile.readEntry();
        });

        zipFile.on("end", () => resolve());
        zipFile.on("error", reject);
    });

    await done;
    zipFile.close();

    const t1 = hrNowSec();
    return { sec: (t1 - t0), count, totalBytes };
}

async function main() {
    const zip = "benchmark_images.zip"
    const iters = 10;

    let best = Number.POSITIVE_INFINITY;
    let last = { count: 0, totalBytes: 0 };

    for (let i = 0; i < iters; i++) {
        const r = await runOnce(zip);
        last = r;
        best = Math.min(best, r.sec);
        console.log(`iter ${i + 1}: ${(r.sec * 1000).toFixed(2)} ms`);
    }

    const mib = last.totalBytes / (1024 * 1024);
    console.log(`zip: ${zip}`);
    console.log(`images: ${last.count}`);
    console.log(`bytes read: ${last.totalBytes} (${mib.toFixed(2)} MiB)`);
    console.log(`best time: ${(best * 1000).toFixed(2)} ms`);
    if (best > 0) {
        console.log(`throughput: ${(last.count / best).toFixed(2)} images/s`);
        console.log(`throughput: ${(mib / best).toFixed(2)} MiB/s`);
    }
}

The programs all do the same thing:

Open the ZIP file
Read each image entry into memory
Decode the image

Each test runs 10 iterations, and the best time is used as the result.

Benchmark Results

-	Rust	Python	Javascript
iter 1	557.73 ms	1056.06 ms	811.30 ms
iter 2	556.50 ms	1034.25 ms	819.17 ms
iter 3	555.70 ms	1036.28 ms	803.66 ms
iter 4	556.82 ms	1034.54 ms	813.86 ms
iter 5	555.07 ms	1035.30 ms	816.00 ms
iter 6	557.37 ms	1036.74 ms	793.65 ms
iter 7	556.83 ms	1033.83 ms	792.46 ms
iter 8	555.69 ms	1035.08 ms	774.49 ms
iter 9	564.42 ms	1035.40 ms	771.28 ms
iter 10	554.54 ms	1034.46 ms	734.43 ms
bytes read	75252870 (71.77 MiB)	75252870 (71.77 MiB)	75252870 (71.77 MiB)
best time	554.54 ms	1033.83 ms	734.43 ms
throughput	18.03 images/s	9.67 images/s	13.62 images/s
throughput	129.42 MiB/s	69.42 MiB/s	97.72 MiB/s

Conclusion

As expected, Rust was the fastest.
However, JavaScript was actually not bad at all.

As for Python, if I want to add AI translation features later, I might implement them as a separate API server instead.
For this kind of task, Python is simply too slow.

The results were not very surprising, but I hope they are useful for someone.

Forem: Lycoris52