Performance Benchmarks

PyImageCUDA is designed for GPU-accelerated image processing. These benchmarks compare its performance against industry-standard libraries (Pillow and OpenCV) across common operations.

Test Environment

All benchmarks were conducted on the following hardware:

• CPU: AMD Ryzen 7 3700X
• GPU: NVIDIA RTX 3070
• RAM: DDR4
• Storage: Standard SSD
• OS: Windows 11
• Driver: Latest NVIDIA drivers

Each test ran 50 iterations with a 1920×1080 (1080p) RGBA source image.

Understanding the Results

The benchmarks are divided into two categories:

Pure Algorithm (Compute Bound)

These tests measure raw processing speed without disk I/O. The image is loaded once, then the operation runs repeatedly in memory. This shows the true computational performance difference between libraries.

When this matters:

• Batch processing multiple operations on the same image
• Real-time video processing pipelines
• Interactive applications with live previews
• Server-side processing with images already in memory

End-to-End (Disk I/O + Encode)

These tests include the complete workflow: load image from disk → process → encode → save to disk. This represents real-world scenarios where you load and save files repeatedly.

When this matters:

• Simple scripts that process individual files
• One-off image transformations
• Workflows where you must save intermediate results

Performance Highlights

PyImageCUDA delivers 10-400x faster performance in pure computation:

• 376x faster - Blend/Composite operations
• 260x faster - Arbitrary angle rotations
• 132x faster - Bilinear resizing
• 54x faster - Gaussian blur (heavy filters)
• 35x faster - Lanczos resizing (high-quality)

For end-to-end workflows with disk I/O, PyImageCUDA typically provides 1.5-2.7x speedup over CPU libraries.

Best Practices for Maximum Performance

✅ DO: Reuse Buffers

Pre-allocate buffers and reuse them across operations:

from pyimagecuda import Image, load, Transform, save, ImageU8

# Pre-allocate buffers
src = Image(1920, 1080)
dst = Image(1920, 1080)
u8_buffer = ImageU8(1920, 1080)

for file in image_files:
    load(file, f32_buffer=src, u8_buffer=u8_buffer)
    Transform.flip(src, direction='horizontal', dst_buffer=dst)
    save(dst, f"output_{file}", u8_buffer=u8_buffer)

# Clean up once at the end
src.free()
dst.free()
u8_buffer.free()

Result: 3-11x faster than allocating new buffers each time.

✅ DO: Chain Operations on GPU

Keep data on GPU for multiple operations:

from pyimagecuda import load, Filter, Adjust, save

img = load("photo.jpg")

# All operations run on GPU without CPU transfers
Filter.gaussian_blur(img, radius=10, dst_buffer=img)
Adjust.brightness(img, 0.2)
Adjust.contrast(img, 1.3)

save(img, "output.jpg")
img.free()

❌ DON'T: Use GPU for Single Simple Operations

For one-off crops or flips with file I/O, CPU libraries are competitive:

# This won't be significantly faster than Pillow/OpenCV
img = load("photo.jpg")
cropped = Transform.crop(img, 0, 0, 512, 512)
save(cropped, "output.jpg")

Use PyImageCUDA when building processing pipelines with multiple operations.

When to Use PyImageCUDA

✅ Perfect For:

• Batch processing thousands of images
• Real-time video processing (60+ FPS)
• Complex multi-step pipelines
• Interactive applications with live preview
• Heavy filters (blur, drop shadows, etc.)

⚠️ Not Ideal For:

• Single simple operations (crop, flip) on individual files
• Small images (<500×500)
• Environments without NVIDIA GPU
• Scripts that rarely run

Detailed Results

Below are the complete benchmark results across 7 common image processing operations. Each operation was tested 50 times, and results show both pure algorithm performance and end-to-end performance including disk I/O.

Generated automatically by /benchmarks/benchmarks.py

Gaussian Blur Benchmark (1080p)

Config: Image: photo.jpg, Radius: 20, Iterations: 50

Pure Algorithm (Compute Bound)

End-to-End (Disk I/O + Encode)

Blend Normal Benchmark (1080p)

Config: Image: photo.jpg, Iterations: 50

Pure Algorithm (Compute Bound)

End-to-End (Disk I/O + Encode)

Resize Bilinear Benchmark (1080p -> 800x600)

Config: Image: photo.jpg, Target: 800x600, Interpolation: Bilinear, Iterations: 50

Pure Algorithm (Compute Bound)

End-to-End (Disk I/O + Encode)

Resize Lanczos Benchmark (1080p -> 800x600)

Config: Image: photo.jpg, Target: 800x600, Interpolation: Lanczos/Bicubic, Iterations: 50

Pure Algorithm (Compute Bound)

End-to-End (Disk I/O + Encode)

Rotate 35° Benchmark (1080p)

Config: Image: photo.jpg, Angle: 35°, Expand: True, Iterations: 50

Pure Algorithm (Compute Bound)

End-to-End (Disk I/O + Encode)

Flip Horizontal Benchmark (1080p)

Config: Image: photo.jpg, Direction: Horizontal, Iterations: 50

Pure Algorithm (Compute Bound)

End-to-End (Disk I/O + Encode)

Crop Center Benchmark (1080p → 512×512)

Config: Image: photo.jpg, Source: 1920×1080, Output: 512×512, Iterations: 50

Pure Algorithm (Compute Bound)

End-to-End (Disk I/O + Encode)