Pixon: A Fast, Native Image Processing Command-Line Tool

Sudiip Lahiri — Sun, 21 Dec 2025 08:12:44 +0000

Summary

Pixon is a high-performance, native image-processing command-line tool built for speed, predictability, and cross-platform use. It supports common image operations such as resizing, cropping, rotation, flipping, color adjustments, blurring, sharpening, alpha-channel modifications, and image compositing.

Built in C++ using OpenCV, Pixon provides a chainable CLI that lets you run multiple transformations in a single command. The tool is language-agnostic and works smoothly with Python, Node.js, Go, and shell-based workflows. Its reproducible and extensible design makes it a good fit for automated pipelines, backend services, and large-scale image-processing tasks.

Statement of Need

Image processing is a core component of many modern software pipelines, including web applications, media servers, continuous integration workflows, and AI/ML preprocessing systems. In practice, existing solutions often involve trade-offs:

High-level libraries provide ease of use but can introduce performance overhead and memory inefficiencies at scale.
Low-level native tools offer superior performance but are harder to integrate, automate, and maintain across heterogeneous environments.

Pixon bridges this gap by providing native performance with simple integration, chainable operations, and predictable behavior. Its architecture minimizes intermediate file I/O, streamlines automation, and ensures consistent results across platforms and programming languages.

Implementation

Architecture

Language: C++
Core Library: OpenCV

Design Principles

Single, self-contained binary
Chainable command-line operations
Works across languages (Python, Node.js, Go, shell workflows)
Minimal overhead and deterministic execution

Features

Resize, crop, rotate, flip, and flop images
Adjust brightness, contrast, and saturation
Blur and sharpen images
Composite multiple images
Add or remove alpha channels
Extend canvas and trim transparent edges
Export to PNG, JPEG, or WebP
Chain multiple operations in a single command

Cross-Language Integration

Pixon can be called from any environment that can run system commands, making it easy to integrate with Python, Node.js, Go, shell scripts, or other programming languages.

Python

import subprocess

# Path to input image (adjust if needed)
input_file = "input.png"
output_file = "output.jpeg"

# Run Pixon CLI
result = subprocess.run([
    "pixon",
    input_file,
    "resize", "400", "300", "0",
    output_file
], capture_output=True, text=True)

# Print stdout and stderr
print("STDOUT:\n", result.stdout)
print("STDERR:\n", result.stderr)

# Check return code
if result.returncode == 0:
    print(f"Success! Output saved to {output_file}")
else:
    print(f"Failed with return code {result.returncode}")

Node.js

const { execFile } = require('child_process');

const inputFile = 'input.png';
const outputFile = 'output.jpeg';

execFile(
    'pixon',
    [inputFile, 'resize', '400', '300', '0', outputFile],
    (error, stdout, stderr) => {
        if (error) {
            console.error('Error:', error.message);
            console.error('STDERR:', stderr);
            return;
        }

        console.log('STDOUT:', stdout);

        if (stderr) {
            console.warn('Warnings:', stderr);
        }

        console.log(`Success! Output saved to ${outputFile}`);
    }
);

package main

import (
    "fmt"
    "os"
    "os/exec"
)

func main() {
    inputFile := "input.png"
    outputFile := "output.jpeg"

    cmd := exec.Command("pixon", inputFile, "resize", "400", "300", "0", outputFile)

    // Combine stdout and stderr
    out, err := cmd.CombinedOutput()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error executing pixon: %v\n", err)
        fmt.Fprintf(os.Stderr, "Output:\n%s\n", string(out))
        os.Exit(1)
    }

    fmt.Printf("Pixon output:\n%s\n", string(out))
    fmt.Printf("Success! Output saved to %s\n", outputFile)
}

Quality Control

Unit tests cover all image operations
Chainable workflows are tested for correctness and reproducibility
Minimal external dependencies keep installation simple
Continuous integration ensures testing across all supported platforms

Performance and Benchmarking

Benchmarks were conducted using a representative test image. Outputs were saved under pixon/test/benchmark_outputs/.

Note

The Single Operation Benchmark results were collected during a batch execution of all operations, which caused a few operations to take longer (around ~3 seconds). In real-world usage, running a single operation independently generally takes less than one second.

Single Operation Benchmark

Operation	Time (seconds)
Resize	0.856
Rotate	0.967
Crop	0.808
Blur	1.084
Sharpen	0.974
Flip	1.022
Flop	1.036
Composite	1.060
Color Adjust	1.052
Add Alpha	3.151
Remove Alpha	1.278
Extend Canvas	1.107
Trim	3.564

Multiple Operations Benchmark

Operations Chain	Time (seconds)
Resize → Sharpen → Color Adjust → Flip → Composite	0.710

Observations

Most individual operations finish in under 1.1 seconds
Alpha addition and trimming are slower due to extra memory use and pixel-level processing
Chaining multiple operations in a single command improves performance by reducing intermediate file I/O
Overall, these results highlight the efficiency of Pixon’s command architecture for automated workflows

Availability

Operating Systems

Linux (x64): Fully supported
Linux (ARM): Experimental
macOS: Experimental
Windows: Not officially supported, but works via WSL

Programming Languages

Native: C++
Integration via system calls: Python, Node.js, Go, Shell

Installation

For installation instructions, please refer to the GitHub repository:

👉 https://github.com/sudiplahiri3123-alt/pixon

License

Pixon uses the Pixon Source-Available License (PSAL) v2.0.

See the GitHub repository for full license terms.

Reuse Potential

Pixon is designed to be flexible and reusable across a wide range of projects, including:

Automated image processing pipelines
Backend services for web and mobile applications
AI/ML preprocessing workflows
Educational and research projects in computer vision

The architecture is extensible, making it easy for contributors to add new filters, transformations, or platform support.

References

Figures and Tables

Example Output

Original image

Original image vs. blurred using Pixon:

pixon input.png blur 3 blur.jpeg

pixon input.png blur 15 blur.jpeg

Original image vs. Resize → Sharpen → Color Adjust using Pixon:

pixon input.png resize 400 300 0 sharpen coloradjust 0.1 1.2 1.3 output.jpeg

Original image vs. extend → Sharpen → Color Adjust using Pixon:

pixon input.png extend 5 5 5 5 sharpen coloradjust 0.2 1.1 1.0 output.jpeg

Original image vs. composite using Pixon:

pixon input.png composite overlay.png 50 50 0.7 composite.jpeg

Architecture Overview

👉 GitHub Repository:

https://github.com/sudiplahiri3123-alt/pixon

DEV Community: Sudiip Lahiri