From a Forgotten Python Script to a 2500x Faster Rust Tool: The Evolution of PNGToSVG

Sun, 19 Apr 2026 00:00:00 +0000

I just wanted to share the story behind a tool I’ve been working on called . As you can probably guess, it converts PNG images into SVG vectors.

The project started back in 2019 as a small Python script I wrote for a frontend job. Sometimes we needed to work with SVGs, and I just wanted a quick way to convert images locally without uploading them to some random remote service. When I switched jobs, I took that code, tossed it onto GitHub, and completely forgot about it.

Fast forward five years. Out of nowhere, a contributor (“Kartik Nayak” on GitHub) made the first Rust implementation of the tool. A few months later, someone else (“Salman Sali”) jumped in and improved it by adding parallelization.

This was late 2024. Seeing the community breathe new life into my old script blew my mind and gave me the perfect excuse to dive in and learn Rust myself. Since then, I’ve been rewriting, polishing, and tweaking the tool, focusing heavily on ease of use and performance.

What used to be a sluggish script that took a couple of seconds to process a tiny 64x64 icon can now chew through 8000x8000 images in a fraction of that time. To put this performance leap into perspective, I ran a benchmark using a relatively complex ~900KB image.

Here is how the evolution of the project looks:

Version	Time (Seconds)	Relative Performance	Speedup Strategy
Python (Legacy)	1,124.14s	100% (Baseline)	Original implementation
v0.4.0 / v0.4.1	~24.50s	~2.18%	Initial Rust Port (O(n) lookups)
v0.5.0	1.15s	0.10%	O(1) Hash-Set Optimization
v0.6.0	0.43s	0.04%	Memory Reuse & Direct IO

Going from over 18 minutes in the original Python implementation to under half a second in Rust represents a massive ~2580x speedup. But the numbers only tell half the story. Translating this project into Rust became an amazing learning exercise, and the technical journey went roughly like this:

Phase 1: The Rust Port (v0.4.x): Moving to Rust gave us a huge baseline boost (about 45x faster than Python), but the code still relied on linear searches for neighbor lookups, which struggled under the heavy weight of complex paths.
Phase 2: The Breakthrough (v0.5.0): As I learned more, I realized we could replace vector-based neighbor checks with O(1) Hash-Set lookups. This single change killed the quadratic scaling bottleneck and dropped processing time from 24 seconds to just 1.1 seconds—a 20x jump just within the Rust codebase.
Phase 3: Total Efficiency (v0.6.0): Finally, I focused on memory efficiency. Instead of constantly allocating new structures for every shape, we now reuse memory buffers, read pixel data directly via raw buffers, and use sorted edge lookups to trace shapes.

Recently, I published the latest release (v0.6.1), which polishes a few rough edges and includes a shiny new (and very “programmer art”) icon, hahaha. Since then, I’ve received plenty of feedback from the community. Based on that, I’m already planning the improvements for v0.6.2, as well as a v0.7.0 release (which will include some breaking API changes, hence the version bump).

Honestly, the best part of this whole experience hasn’t been the crazy performance gains. It’s the fact that randomly deciding to share a quick script allowed me to receive very useful community contributions, learn a completely new language, and actually build a fast, easy-to-use tool that actually helps me without interrupting my workflow with wait times in my own projects.

Performance |

From a Forgotten Python Script to a 2500x Faster Rust Tool: The Evolution of PNGToSVG