Real-Time AI Frame Interpolation & Super-Resolution. Built for AMD GPUs. Powered by ROCm. Open Source.
Pre-Alpha -- Active development. Many features are broken. Contributors & AMD GPU testers urgently needed!
Student Indie Project -- Built by a solo developer exploring the limits of AMD GPU compute. Not affiliated with AMD. Just a passionate dev trying to make AMD GPUs shine in AI workloads.
AMD-FluidMotion is an open-source, real-time AI video enhancement toolkit built exclusively for AMD GPUs. It combines two powerful neural networks:
| Feature | Description |
|---|---|
| Frame Interpolation | Convert 24/30 FPS video to 60/120/240 FPS with AI-generated intermediate frames |
| Super-Resolution | Upscale 480p/720p/1080p to 4K/8K in real-time |
| AMD-Native | Runs directly on ROCm -- no CUDA, no translation layers, no NVIDIA dependency |
Think of it as an open-source alternative to NVIDIA DLSS Frame Generation + RTX Video Super Resolution -- but for AMD GPUs.
| Reason | Detail |
|---|---|
| ROCm Kernels | Custom HIP kernels that leverage RDNA 3 wavefront-level parallelism |
| Infinity Cache | Optimized memory access patterns for AMD's cache hierarchy |
| WMMA Instructions | RDNA3 matrix cores (Wave Matrix Multiply-Accumulate) for optical flow |
| No CUDA Fallback | This is intentional. Adding NVIDIA support would dilute focus on AMD optimization |
"If you have an NVIDIA GPU, use DAIN/RIFE. If you have an AMD GPU, you had nothing -- until now."
+---------------------------------------------------+
| Input Video (24/30 FPS) |
+---------------------------+-----------------------+
|
+------------------v------------------+
| Optical Flow Estimator |
| (PWC-Net + WMMA kernels) |
+------------------+------------------+
|
+------------------v------------------+
| Bidirectional Flow Fusion |
| (Custom HIP Kernel) |
+------------------+------------------+
|
+------------------v------------------+
| Adaptive Frame Synthesizer |
| (U-Net + Attention Gate) |
+------------------+------------------+
|
+------------------v------------------+
| Optional: Super-Resolution |
| (ESPCN + PixelShuffle) |
+------------------+------------------+
|
+---------------------------------------------------+
| Output Video (120/240 FPS, 4K) |
+---------------------------------------------------+
| Input | Output | FPS | Latency | VRAM Used |
|---|---|---|---|---|
| 1080p24 to 1080p120 | Interpolation | 118 | 2.1ms | 6.2 GB |
| 1080p24 to 1080p240 | Interpolation | 96 | 3.4ms | 7.1 GB |
| 1080p60 to 4K60 | Upscale | 58 | 4.8ms | 8.4 GB |
| 720p30 to 4K120 | Both | 44 | 7.2ms | 10.1 GB |
| 480p24 to 1080p60 | Both | 72 | 5.5ms | 7.8 GB |
Benchmarks from developer's RX 7900 XTX. Your mileage may vary. RX 6000 series: ~40-60% slower.
Full benchmark methodology
- GPU: AMD Radeon RX 7900 XTX (24GB)
- Driver: ROCm 6.1.0
- Precision: FP16 with WMMA acceleration
- Test video: 5-minute clip, averaged over 3 runs
- Measurement: End-to-end including decode + inference + encode
- Real-time 120+ FPS output on RX 7900 XTX
- 2x, 4x, 8x frame rate multiplication
- 2x, 4x resolution upscaling
- Custom optical flow (PWC-Net, optimized for AMD WMMA)
- Motion blur compensation -- handles fast-moving scenes
- Per-scene adaptive blending -- reduces artifacts
- Low latency mode -- usable for gaming (experimental)
- Batch processing -- process entire video libraries
- Linux-first (Windows via WSL2, experimental)
- AMD GPU with ROCm support (RX 6000 series or newer, Radeon Pro, Instinct)
- ROCm 5.7+
- Python 3.10+
- Ubuntu 22.04+ / Fedora 38+
# Clone
git clone https://github.com/Jack-Bismi/amd-fluidmotion.git
cd amd-fluidmotion
# Install ROCm deps
sudo apt install rocm-libs miopen-hip rocblas
# Setup environment
python3 -m venv .venv && source .venv/bin/activate
pip install -e .
# Download models
bash scripts/download_models.sh
# Run demo!
python scripts/run_demo.py --input video.mp4 --fps-target 120 --upscale 2xdocker build -t amd-fluidmotion -f docker/Dockerfile.rocm .
docker run --device=/dev/kfd --device=/dev/dri --group-add video \
-v $(pwd)/videos:/data \
amd-fluidmotion python scripts/run_demo.py --input /data/video.mp4# Basic frame interpolation (24fps -> 120fps)
python scripts/run_demo.py --input movie_24fps.mp4 --fps-target 120
# Upscale 1080p to 4K
python scripts/run_demo.py --input stream_1080p.mp4 --upscale 2x
# Both interpolation + upscale (the full FluidMotion experience)
python scripts/run_demo.py --input anime_720p24.mp4 \
--fps-target 60 --upscale 2x --smooth-motion
# Real-time webcam enhancement
python scripts/run_demo.py --webcam --fps-target 60 --denoise
# Benchmark your AMD GPU
python scripts/bench_amd.py --full-suite --output results.json| Component | Status | Notes |
|---|---|---|
| PWC-Net Optical Flow | Working | WMMA-accelerated |
| Frame Synthesis U-Net | Working | Needs temporal consistency fix |
| 2x Upscaling (ESPCN) | Stable | |
| 4x Upscaling | Beta | Occasional checkerboard artifacts |
| Real-time Pipeline | Beta | Frame pacing issues on RX 6600 |
| Audio Sync | Beta | Drift after 10+ minutes |
| GUI (Qt6) | WIP | Crashes on Wayland |
| Windows Support | Research | WSL2 only, native ROCm Windows TBD |
| VapourSynth Plugin | Planned | |
| OBS Plugin | Planned |
Urgently needed: AMD GPU testers with RX 6000/7000 series, Radeon Pro W7000, or Instinct cards!
- RX 6600/XT: Occasional VRAM overflow on 4K workloads (#23)
- Wayland: GUI crashes on GNOME Wayland (#17)
- HDR content: Colorspace conversion artifacts (#31)
- Long videos: Memory leak after 30+ minutes (#28)
- Audio: A/V sync drift on multi-hour content (#12)
- Fix Wayland GUI crash
- 4K upscaling artifact reduction
- RX 6000 series VRAM optimization
- Audio sync rewrite
- VapourSynth plugin
- Multi-GPU support (RX 7900 XTX x 2)
- OBS Studio plugin
- Windows native (ROCm on Windows)
- 8K upscaling (experimental)
- HDR10+ passthrough
- AV1 hardware encode integration
- Real-time collaborative streaming mode
amd-fluidmotion/
├── README.md
├── requirements.txt
├── setup.py
├── .gitignore
├── LICENSE
├── configs/
│ └── default.yaml
├── fluidmotion/
│ ├── __init__.py
│ ├── engine/
│ │ ├── interpolator.py # PWC-Net + U-Net interpolation
│ │ ├── upscaler.py # ESPCN super-resolution
│ │ ├── pipeline.py # End-to-end video processing
│ │ └── hip_kernels.py # Custom HIP kernels for AMD
│ ├── models/
│ │ ├── flow_net.py # PWC-Net optical flow
│ │ ├── fusion_net.py # Attention-based frame fusion
│ │ └── sr_net.py # ESPCN 2x/4x upscaling
│ ├── utils/
│ │ ├── rocm_utils.py # AMD GPU detection & optimization
│ │ └── benchmark.py # Performance benchmarking
│ └── app/
│ ├── player.py # Video file reader
│ └── gui.py # Qt6 preview GUI
├── scripts/
│ ├── run_demo.py # Interactive demo
│ ├── bench_amd.py # AMD GPU benchmark suite
│ └── download_models.sh # Download pre-trained models
├── tests/
│ └── test_interpolator.py # Unit tests
└── docker/
└── Dockerfile.rocm # ROCm Docker image
This project desperately needs AMD GPU testers and contributors!
- Fork the repo
- Create your branch (
git checkout -b fix/rx6600-vram-issue) - Hack away
- Submit a PR with GPU model + ROCm version in description
- Testers with RX 6000 series -- most optimization needed
- Testers with Radeon Pro W7900 -- workstation validation
- Anyone with multi-GPU AMD setup -- distributed inference testing
- Qt/Wayland developers -- GUI fixes
- FFmpeg/VapourSynth experts -- plugin architecture
MIT (c) 2024 -- Indie Developer
Built with and an AMD GPU. Not affiliated with Advanced Micro Devices, Inc.
- AMD ROCm Team -- for the incredible compute platform
- RIFE Paper -- Huang et al., real-time interpolation
- ESPCN -- Shi et al., real-time super-resolution
- The open-source AMD community
Star this repo if you want AMD GPUs to be first-class AI citizens!
"AMD has the hardware. Let's build the software."
hipErrorNoBinaryForGpu — Your GPU architecture isn't compiled. Run python scripts/compile_kernels.py --arch gfx1032 (replace with your arch).
Out of memory on 4K — Try --tile-size 512 or switch to 1080p mode. RDNA2 cards with 8GB VRAM can't handle full 4K frames.
GUI doesn't start — Make sure you have PyQt5 installed. On Ubuntu: sudo apt install python3-pyqt5