acidcam-gpu is a CUDA-accelerated real-time video effects engine. It contains a library of 905 GPU filter kernels that run entirely on the NVIDIA GPU, a unified dispatch kernel that chains any ordered subset of those filters per frame, a rotating device-side frame history buffer for temporal effects, and a CLI application that drives the full pipeline from camera or file input through to live display and optional MXWrite output encoding.

ACMX2 is the Qt-based orchestration layer it wraps the same library and CLI with a visual interface, shader pass ordering, session persistence, and process monitoring. Together they form a layered creative tool: CUDA for pixel-level power, OpenGL for display, Qt for control, and Podman containers for distribution.

The system operates as a two-stage GPU pipeline: first, CUDA kernels process every pixel in parallel on the GPU's streaming multiprocessors (one thread per pixel), applying a user-defined chain of filters entirely in device memory. Then, the CUDA output is transferred to OpenGL via a Pixel Buffer Object (PBO) — a zero-copy GPU-to-GPU transfer — where it becomes a texture. GLSL fragment shaders then apply additional full-frame visual effects in one or more stacked passes using ping-pong framebuffers. Both the CUDA filter chain and the GLSL shader pass stack are independently configurable and orderable, producing a combinatorial explosion of possible visual outcomes.

Stack: C++20 / CUDA 12.x / OpenCV CUDA / OpenGL / Qt6 / MXWrite / libmx2

Download the full Guide here: ACMX2 - Programming Guide

shell-cmd is a command-line utility written in C++20 that recursively walks a directory tree, finds files matching a regex pattern, and executes a shell command for each match. Think of it as a cleaner, more intuitive alternative to chaining find with -exec.

The core idea is simple: you write a command template with placeholders like %0 (filename), %1 (full path), %b (basename without extension), and %e (file extension), and shell-cmd fills them in and runs the command for every matched file. No more wrestling with find's arcane -exec {} \; syntax or fragile shell loops with xargs.

What makes shell-cmd genuinely useful is the breadth of its filtering options. Beyond regex matching, you can filter by file size (--size +10M), modification time (--mtime +7), ownership (--user, --group), permissions (--perm 755), and file type. You can limit recursion depth, exclude paths with a second regex, and even include hidden files when you need them. These options compose naturally, so building precise queries feels effortless.

The dry-run mode (-n) is a standout feature — it lets you preview exactly what commands would be executed before committing to anything. Pair it with verbose mode (-v) and the confirmation prompt (-c) and you have a safe, transparent workflow even for destructive operations like bulk deletes or file moves.

Parallel execution via -j N is another strong point. Batch-converting audio files, resizing images, or compiling sources can be parallelized with a single flag. Under the hood, shell-cmd manages a proper process pool with fork/exec and careful signal handling — no shell hacks, no race conditions.

The extra argument system (%2, %3, ...) is a nice touch that eliminates the need for wrapper scripts in many cases. Passing a destination directory as an extra arg to a copy or move command keeps everything in one readable line.

It builds cleanly with CMake, requires only a C++20 compiler, and has zero external dependencies. The codebase is small and self-contained — including a header-only argument parser — so it compiles in seconds and installs system-wide with a single make install.

If you spend any amount of time doing batch file operations from the terminal, shell-cmd is worth adding to your toolkit.

shell-cmd — GitHub Repository - About shell-cmd - Documentation

The audio I used to create this video is not included due to Copyright concerns.

Demonstrating ACMX2 and acidcam-gpu — a real-time video effects engine powered by NVIDIA CUDA and OpenCV compiled with CUDA support. Watch as live webcam footage is transformed through 736 GPU different filter kernels running entirely on the graphics card, with every pixel processed in parallel across thousands of GPU threads.

What You're Seeing:

• Live webcam input processed through a two-stage GPU pipeline: CUDA compute kernels for pixel-level effects, followed by GLSL fragment shaders for full-frame post-processing
• 736 stackable CUDA filters — temporal trails, geometric distortions, color manipulation, glitch/noise, bitwise XOR operations, wave effects, kaleidoscopes, and more
• Filters chain in real-time: each filter's output feeds directly into the next, all within a single kernel launch — no CPU round-trips
• Audio-reactive mode: microphone/line input drives visual parameters so the effects pulse and shift with sound amplitude
• Zero-copy GPU pipeline via CUDA/OpenGL PBO interop — frames never leave the GPU between the CUDA and shader stages

Technical Stack:

• CUDA 12.x — one thread per pixel, 2M+ threads in parallel at 1080p
• OpenCV with CUDA support — GpuMat frame history ring buffer stored entirely in device memory
• OpenGL + GLSL 330 — Shader passes with ping-pong framebuffers
• Qt6 interface (ACMX2) for filter selection, shader pass ordering, and session management
• C++20 / MXWrite (FFmpeg wrapper) for video encoding
• Runs on Linux with NVIDIA RTX hardware (developed on RTX 2070)

Why It Looks Different Every Frame:

Filter order matters — the same set of filters in a different order produces completely different visuals. On top of that, per-frame parameters (alpha oscillation, frame history index sweeps, random seeds, square size modulation) continuously evolve, so the output is never static. The combinatorial space of filter orderings × shader pass stacks × parameter evolution produces a large array of visuals.

Source code: https://github.com/lostjared/acidcam-gpu

Technical Reference: https://lostsidedead.biz/acmx2-explained.html

Liquid JavaScript Drop is a WebGL 2.0 browser version of a 2D puzzle game, built with JavaScript, HTML, and CSS. The project centers around controlling a 3-block piece, placing it strategically to form horizontal, vertical, and diagonal color matches, while gravity causes floating blocks to fall after clears. The repository includes desktop keyboard controls as well as touch and mouse support for mobile-style play, and it stores high scores locally in the browser using localStorage. The game is designed to be run from a local web server because it loads assets from its data/ directory, and the source shows a 1280x720 WebGL 2 canvas setup that scales to fit the browser window.

Play it here: Liquid JavaScript Drop