Devo · portfolio

Pixlate

Live

Overview

Pixlate is a Go-based image transformation tool that converts standard images into pixel-art output with a focus on speed, determinism, and batch usage. The project is built for users who want a reliable CLI workflow instead of a heavy graphical editor.

What It Is

A command-line pixelation pipeline that reads an image, processes it in parallel, and writes a stylized output file.

Problem

Naive pixelation approaches get slow on large inputs because they process every region sequentially. That makes the workflow painful when the goal is to generate results quickly and repeatedly.

How It Works

Pixlate divides the input into blocks, samples or transforms each block independently, and runs those blocks through goroutines so multiple chunks are processed at the same time.

Why It Stands Out

The implementation is intentionally simple at the interface level but strong under the hood. It keeps the surface area small, the output predictable, and the runtime fast enough for large images.

Repository Structure

cmd/pix contains the Pix CLI entry point

core conversion logic handles pixelation, sorting, and output generation

flag parsing wires input, output, size, and variation controls

shared helpers support image loading, color handling, and export

Installation

go install github.com/arnabjena007/pixlate/cmd/pix@latest
Add your GOBIN or $HOME/go/bin directory to PATH
git clone https://github.com/arnabjena007/Pixlate.git
cd Pixlate
go build ./cmd/pix

Local Run

pix -in picture.jpg
pix -in picture.jpg -out pix.output.png -width 800 -height 800
pix -in picture.jpg -sweep
pix -in picture.jpg -variations 4

Flags

-in: input image path or URL

-out: output image path

-width and -height: output dimensions

-white-percent, -colorsort, -random, -reverse

-sweep, -random-seed, -variations

-compress: PNG compression level

-seeds: seed positions in "x y x y ..." format

Code Snippets

Parallel block pipeline

type Job struct {
  X int
  Y int
  Block image.Image
}

func processJobs(jobs []Job) []image.Image {
  out := make(chan image.Image, len(jobs))
  for _, job := range jobs {
    go func(j Job) {
      out <- convertBlock(j.Block, j.X, j.Y)
    }(job)
  }
  return collectResults(out, len(jobs))
}

bash

CLI invocation

pix -in picture.jpg -out pix.output.png -width 800 -height 800
pix -in picture.jpg -sweep
pix -in picture.jpg -variations 4

Setup Notes

Requires Go 1.18+

The install command is the easiest way to get the binary

You can also build the pix binary locally from source

Key Features

Parallel image processing with Goroutines

High-resolution image support

Adjustable pixel block size

Command-line workflow for automation

Fast conversion pipeline for large inputs

Multiple output and variation modes

Stack used

Golang

For more cool projects, visit my GitHub.