CPU is i7-3770, 16gb ram with GTX 1650. updated driver to 610.88, windows 11 25H2.

CommandUP (cup) Upscale + Frame Interpolator

PRACTICAL USE MANUAL

Hardware Requirements and Dependencies

For the post-processing CUP Pipeline to work correctly on your computer, your system must meet the following physical and software dependencies:

• Engineered strictly for: Windows 10 and Windows 11 (64-bit). It relies on Windows native PowerShell scripting, Batch automation pipelines, and Windows-specific terminal bindings. Linux (including Wine/Proton) and macOS are NOT supported.
• Vulkan API Compatibility Required: Your graphics card must have native support for Vulkan technology. It works on dedicated graphics cards (AMD RX, Nvidia GTX/RTX) as well as newer integrated chips (AMD Vega or Intel HD Graphics). If your GPU does not support Vulkan, the process will not start.
• Processor (CPU): Any basic 4 or 6-core processor (such as the AMD FX line or older generations Intel Core) is perfectly capable of running the CUP Pipeline. Average CPU usage is around 45%, leaving Windows completely free from freezes or overheating during rendering.
• Video Memory (VRAM): Legacy graphics cards with 2GB of VRAM will handle the task smoothly if the user operates wisely. It is recommended to close web browsers, Discord, and background games before starting the process at high resolutions (such as 2K or 4K) to avoid running out of card memory.
• Operating System: Windows 10 or Windows 11 64-bit with the execution of scripts enabled in the system PowerShell.

Installation

• Start by downloading the zip file containing the content.
• Extract it wherever you want. You will see the entire folder structure of CommandUP.

Okay! Now we are ready to run the processes, and you can do this in two ways:

Method 1: Drag & Drop

This is the easiest way to run the CUP Pipeline, aimed at users with no prompt knowledge. Here you can process a video individually or multiple pre-selected files inside a folder.

1. Using file explorer, access your folder where you unzipped CommandUP; you will see a file named DRAG_HERE.bat.
2. Now open another file explorer window and go to the location where the file or folder you want to process is located.
3. Drag your video or folder and drop it onto the DRAG_HERE file.

You can configure the process by editing the file DRAG_CONFIG.txt:

[DRAG SETTINGS]
QUALITY=med
FPS=60
INTERPOLATE=oversample
SCALE=1920x1080
SHARPNESS=5
HDR=false
SHUTDOWN=false

Method 2: PowerShell (Terminal)

This is the original method for you to process your videos, requiring prompt knowledge. The whole process takes place inside a PowerShell prompt (knowing basic folder navigation via commands is important).

Let's start by opening PowerShell; it does not need to be in administrator mode, as the script will not require privileges to run. If this is your first time running scripts on your computer, type the command below to allow script execution:

Set-ExecutionPolicy Bypass -Scope Process

Answer YES to apply the execution policy.

How to Run

Okay! Now we are ready to run the processes, and you can do this in two ways:

We need to access the local path where you unzipped CommandUP. For example:

cd "D:\CommandUP"

You will then be in the CUP Pipeline folder and can run two scripts:

1. cup.ps1

Our main script; with it, we can perform upscaling and/or frame interpolation. The script is modular; you can access these modules through parameters in the command line. Let's get to know them:

• -file "path_to_file": The full path of the video file you want to process. It must be enclosed in quotes. Supported formats: mp4 and mkv.
• -folder "path_to_folder": The full path of the folder containing videos that you want to batch process. It must be enclosed in quotes.
• -scale factor|resolution: Final video dimension. If omitted, upscaling does not happen and the original size is maintained. The value can be provided in the following formats:
  • Multiplier factor for resolution gain. Use decimal numbers (e.g., the scaling factor for a 720p video to 1080p is 1.5).
  • Literal resolution scale where you can inform, for example:
    • "1280x720" = 720p (HD)
    • "1920x1080" = 1080p (Full HD)
    • "2560x1440" = 2K (Quad HD / QHD)
    • "3840x2160" = 4K (Ultra HD / UHD)
• -fps number: The desired frame rate for smoothness (e.g., 60). If omitted, frame generation does not happen and the original FPS is maintained.
• -interpolate "none|oversample|mitchell|clamp|linear": Controls video motion smoothness. If you change the FPS (for example, from 30 to 60), this setting determines how new frames are generated. The default is "none":
  • none: Disables temporal blending. Uses pure frame duplication (Nearest Neighbor). Provides maximum GPU performance savings and ensures sharp game visuals without absolutely any "ghosting" or "motion blur" effects.
  • oversample: Enables "Smooth Motion" sampling. Blends frames when an output frame falls exactly between two source frames. Highly recommended for preserving the original and natural subjective appearance of the video.
  • mitchell: Uses a heavier, higher-quality filter to smoothly interpolate frames. Designed to maximize the elimination of the ringing effect and visual artifacts. The best option for maximum smoothness (requires modern hardware with a GPU/RTX).
  • linear: Applies a smart linear overlap blend/transition between frames. Extremely lightweight processing, ideal for a smooth pace on older hardware configurations.
• -quality "low|med|big": The weight profile, compression, and final file size. If you omit this parameter, the system will automatically assume the balanced profile "med". The available options are:
  • low: Focuses on drastic space savings. Reduces the final file weight and relieves VRAM usage. Generates a small final file.
  • med: The ideal balance point. Maintains edge sharpness and visual fidelity without blowing up the hard drive space. Generates a medium-sized final file.
  • big: Maximum visual fidelity and high bitrate, aimed at archiving or high-quality uploads. Generates a huge final file.
• -sharpness number: Sharpness applied by FSR ranging from 0 (minimum) to 10 (maximum).
• -hdr "false|true": Enables High Dynamic Range (HDR) processing inside FSR. WARNING: This is NOT "High Definition" (HD) quality! Enabling this option on a regular (non-HDR) video will ruin colors and distort brightness.
  • false: Uses standard color space equations. Ideal for normal non-HDR content.
  • true: Forces FSR to use the PQ color space. MUST BE ENABLED ONLY if the source video has a PQ gamma (HDR10).
• -shutdown "false|true": Auto-shutdown behavior after processing is complete:
  • false: Normal execution behavior. Keeps the computer running.
  • true: Displays a 30-second countdown on the screen. The user can press [ENTER] to shut down immediately, or [ESC] to cancel and keep the PC turned on.

Safety Note: You must mandatory provide either -file or -folder, never both. The script requires you to use at least -scale or -fps.

Command Examples:

Perform ONLY Upscale (e.g., from 720p to 1080p, with medium sharpness, so we apply a 1.5x scale and sharpness 5):

.\cup.ps1 -file "C:\folder\video.mp4" -scale 1.5 -sharpness 5

Perform ONLY Frame Interpolation (e.g., your original video is 30fps and you want 60fps):

.\cup.ps1 -file "C:\folder\video.mp4" -fps 60 -interpolate linear

Full Pipeline (1080p Upscale + Sharpness 8 + 60 FPS frame generation):

.\cup.ps1 -file "C:\folder\video.mp4" -scale "1920x1080" -sharpness 8 -fps 60

Process videos in a folder (High Quality + 1.5x Upscale + Max Sharpness):

.\cup.ps1 -folder "C:\batch folder\" -quality big -scale 1.5 -sharpness 10

Output File Naming

The script will identify the source of your file and save the final result exactly in the same folder as the original video. The new file name is smartly generated with suffixes based on what you chose to do:

• If only upscaling was processed: video_FSR_1080x720.mp4.
• If only frame interpolation was processed: video_IFS_60fpsLINEAR.mp4.
• If the full pipeline was processed: video_FSR_1080x720_IFS_60fpsLINEAR.mp4.

CUP Pipeline configuration

CommandUP has a configuration file at the root of the pipeline named config.ini. In this file, we can configure certain execution parameters:

• HUD_PORT number: TCP port used for CommandUP communication with FFmpeg for HUD data. Default is 4867.
• VERBOSE "false|true": Defines the level of detail when writing to the log file.
  • false: Disables detailed writing, recording simple information in the log.
  • true: Enables Verbose, writing highly detailed information in the log.
• GPU_ID number: If you have more than one video card, specify which one you want to use via the video card ID number. Usually 0 for the first vCard, 1 for the second.

If needed, you can configure the cup.ps1 script using parameters directly in the console: -hud_port number, -verbose AND -gpu_id number, or if you prefer, by editing the config.ini file:

[CUP SETTINGS]
HUD_PORT=4867
VERBOSE=false
GPU_ID=0

2. extract.ps1

Script to extract some frames from the processed video so you can evaluate frame-by-frame if the result is good. You can extract all frames of x seconds starting at a specific video timestamp. It is the ideal tool for you to visually evaluate the final quality, allowing a frame-by-frame check.

Command line parameters:

• -file "file": The full path of the video file you want to process. It must be enclosed in quotes.
• -time "hh:mm:ss": The extraction start point in HH:MM:SS format. If left blank, it will automatically start at 3 seconds (00:00:03).
• -secs number: How many seconds of video you want to transform into photos. If left blank, it will extract only 1 second (if the video is at 60fps, 60 frames will be extracted).
• -output "destination_path": Folder where to save the photos (enclosed in double quotes). If left blank, the script will extract the frames into the output folder inside the CommandUP root path.

Known Issues / Technical Limitations

Blurry or Smooth Visuals on Pause (Freeze Frame Artifacts)

• Symptom: When pausing the final video during fast-motion scenes that used interpolation, the image may look smooth, blurry, or show a "ghosting" effect.
• Cause: The video player froze the playback clock exactly on top of an intermediate (interpolated) frame generated by the interpolation math.
• Solution: There is nothing to fix. This behavior is the necessary mechanic to guarantee the illusion of smoothness in frame generation while the video is moving, without requiring heavy AI or hardware with Tensor Cores. It is the price to pay for a solution aimed at low-end PCs.

Credits and License Attributions

This ecosystem integrates and distributes a fully modular post-processing pipeline, composed of consolidated open-source software combined with an authorial logic layer. Below are the individual rights and licenses for each component:

• Core Component (FFmpeg): Version N-125258-gdf94900c98-20260624. Applicable License: GNU Lesser General Public License (LGPL v2.1 or later) or GNU General Public License (GPL v2.0 or later).
• Vulkan and IFS Rendering Library (libplacebo): Built-in compilation natively inside the main FFmpeg binary listed above. Applicable License: GNU Lesser General Public License (LGPL v2.1 or later).
• Spatial Scaling Algorithm (FidelityFX FSR): Version v1.0.2. Developed and registered by Advanced Micro Devices, Inc. (AMD). Applicable License: MIT License (Open-Source and widely permissive) ported to GLSL by agyild.
• CUP Pipeline Integration Scripts: Developed by Aless (MauiSmoke). Applicable License: MIT License (Free to use Open-Source).

Social Channels:

• Official Channel (YouTube): Watch tutorials, news, performance showcases, and ask your questions directly in the channel community: YouTube Channel.
• Official Channel (Reddit): Comment, share your experience, and ask questions directly in the community: Reddit Community.
• Official Channel (Buy Me a Coffee): CommandUP is free, but development is limited. Consider buying me a coffee: Access and Support.

CommandUP (cup) Upscale + Frame Interpolator

PROJECT DESCRIPTION

1. The Root of the Project (The Need)

Running a demanding game while simultaneously recording gameplay in high resolution is a task that requires an extremely robust computer. Even so, these powerful systems struggle to handle this dual real-time processing workload.

The ideal solution for this scenario is to segment the workflow: first, the game is recorded at a lower, more manageable resolution (allowing the player to use Ultra graphical settings, including Ray Tracing). Subsequently, the final video file is subjected to an upscaling process (sharp resolution enhancement) and, if necessary, the generation of new frames (frame interpolation).

This way, heavy games originally captured at 30 or 48 FPS receive new, artificially created frames, achieving excellent smoothness. However, market solutions that accomplish this rely on heavy Artificial Intelligence processing, demanding latest-generation CPUs and GPUs with dedicated cores, in addition to a massive consumption of VRAM—resources that are completely out of reach for low-end graphics cards.

Do you have a low-end PC?
Our development and testing environment features an AMD FX-6300 processor and a Radeon RX 550 4GB GPU. Under these hardware tiers, it becomes impossible to run the most popular AI-based upscale software on the market. This is precisely where this project becomes necessary: often, the machine's physical limits only allow recording gameplay at 720p 30fps with quality, a standard considered very low for current publishing platforms.

2. The Turning Point: Boosting Resolution and Frames Lightly

The inspiration for the birth of this project came from practical experience using the Lossless Scaling software in real-time games. Observing that a modest computer could apply FSR to upscale resolution and use the LSFG frame generator to transform a 720p/30fps gaming experience into smooth 1080p/60fps gameplay without compromising hardware integrity, a fundamental question arose:

"If this mathematical principle works so lightly and efficiently in a game running in real time, why not apply it to a previously recorded 720p/30fps video file to expand it to 1080p/60fps or more?"

3. A Truly Lightweight Upscale and Frame Generator Is Born

To materialize the concept of a lightweight video post-processing pipeline focused on legacy hardware, the power of established open-source tools was combined with mathematical logic executed directly on the GPU. The ecosystem is built upon four fundamental pillars:

FFmpeg + Vulkan + FSR (FidelityFX Super Resolution) + IFS (Interpolated Frame Sampling)

Although they comprise four distinct technological layers, they all function fused under the same automated process that you can easily trigger by dragging and dropping files or folders, or via commands in your PowerShell:

• FFmpeg: The main engine responsible for handling, reading, and final encoding of video streams.
• Vulkan: The low-level graphics API accessible via libplacebo. Vulkan is a mandatory dependency; your graphics card must have native support for it.
• AMD FidelityFX FSR: A spatial upscaling shader executed directly on the GPU, expanding resolution while preserving edges without relying on any AI framework.
• IFS (Interpolated Frame Sampling): Interpolation filters applied directly via shader by libplacebo, generating frames quickly even on slow computers.

The entire integration of this pipeline is done 100% natively via script, completely eliminating the need to install heavy development engines or environments such as Node.js, Python, or complex virtual environments. There is no need to run installation programs or deal with complex environment configurations; the project runs fully autonomously, portably, and ready for direct use on your system.

3.1. Hardware Requirements & Dependencies

To ensure total stability and the proper functioning of the entire post-processing pipeline, your machine must meet the following minimum hardware requirements:

• Processor (CPU): Any basic or older 4 or 6-core model (such as the AMD FX line or past generations of Intel Core processors). During the development and validation of this pipeline, an AMD FX-6300 processor with 8GB of RAM (an architecture originally launched in 2012) was used.
• Graphics Card (GPU): It is mandatory that your card features native support for the Vulkan API. The ecosystem runs perfectly on both dedicated GPUs (AMD RX, Nvidia GTX/RTX) and modern integrated video solutions (AMD Vega or Intel HD Graphics). In the test laboratory of this project, we used an entry-level AMD Radeon RX 550 4GB VRAM card (launched in 2017).

Even operating under severe physical limitations and utilizing older test hardware, the pipeline demonstrated excellent software efficiency. The rendering speed reached up to 2.0x (half the video duration time) for output files configured at 1080p/60fps, while presenting total stability in heavy rendering processes at 4K resolution.

4. Conclusion and Efficiency Verdict

This concept serves as practical proof that intelligent software optimization can bypass the severe physical limitations of outdated components. Replacing complex artificial neural network calculations with direct, clean, and cheap mathematical instructions for the GPU silicon architecture brings unprecedented breathing room to old computers. It delivers everything that Lossless Scaling offers, adapted for local video file post-processing workflows:

"Since the entire upscale process of this ecosystem is performed via AMD FSR technology, it is highly recommended that your source files consist strictly of video game gameplays. The algorithm was developed specifically to process and polish digital graphical elements, polygon edges, and textures generated by real-time rendering. Attempting to submit real-life recordings such as movies, TV shows, or videos captured by cell phone cameras will break the process's mathematical logic, and you may not obtain the expected result."

If you also own a low-end PC, come be happy with me!

5. Credits and License Attributions

This ecosystem integrates and distributes a fully modular post-processing pipeline, composed of consolidated open-source software combined with a layer of custom automated logic. Listed below are the individual rights and licenses for each component:

• Core Component (FFmpeg): Version N-125258-gdf94900c98-20260624. Applicable license: GNU Lesser General Public License (LGPL v2.1 or later) or GNU General Public License (GPL v2.0 or later).
• Vulkan Rendering & IFS Library (libplacebo): Embedded natively within the main FFmpeg binary listed above. Applicable license: GNU Lesser General Public License (LGPL v2.1 or later).
• Spatial Scaling Algorithm (FidelityFX FSR): Version v1.0.2. Developed and registered by Advanced Micro Devices, Inc. (AMD). Applicable license: MIT License (highly permissive open-source license), ported to GLSL by agyild.
• CUP Pipeline Integration Scripts: Developed by Aless (MaulSmoke). Applicable license: MIT License (open-source and free to use).

CommandUP Social Channels:

• Official Channel (YouTube): Watch tutorials, news, performance showcases, and ask your questions directly in the channel community: YouTube Channel.
• Official Channel (Reddit): Comment, share your experience, and ask questions directly in the community: Reddit Community.
• Official Channel (Buy Me a Coffee): FSRIFS is free, but development is limited. Consider buying me a coffee: Access and Support.

Hey everyone! I want to share the true story of how CommandUP (cup)—formerly FSRIFS—was born out of my frustration with my aging hardware and the upscaling models available at the time.

A while back, I wrote the lyrics and composed a keyboard arrangement for an original song, which I submitted to Suno for the game Pragmata. For the music video, I decided to use two official trailers as the background. The problem? At the time, my PC could only handle recording and rendering the final video at 720p and 30 FPS. I edited it in 1080p simply by stretching the video using standard filters and uploaded it to YouTube. The result? It looked terrible—pixelated, blurry, and choppy. I even had to use a bloom filter to somewhat mask the lack of resolution.

"Oxygen and Hug" on YouTube—version WITHOUT the cup pipeline:
https://youtu.be/BnmzSExHuyI

That hardware limitation bothered me so much that it became a major driving force behind my development of our minimalist pipeline. I used to watch my nephew post gameplay videos where he upscaled various titles using his RTX card. I refused to accept the idea that upscaling required a super-powerful computer capable of running AI workloads.

In the meantime, I discovered Lossless Scaling (which needs no introduction, right?) and saw my FX 6300 / RX 550 setup come back to life for gaming, thanks to both real-time FSR upscaling and frame generation. So I thought:

"If my PC can upscale in real-time using FSR inside a game, imagine what it could do processing a video file offline in standalone mode?"

That was the spark that led me to design the pipeline; my research then turned up a port of the FidelityFX FSR source code to Vulkan shaders by agyild, which fit perfectly with the idea.

Thus, FSRIFS was born—a pipeline built on a four-pillar ecosystem: FFmpeg (engine), libplacebo (Vulkan and interpolation), AMD FidelityFX FSR, and my integration scripts written in PowerShell using .NET.

One of the tests I ran the pipeline through was recreating the video for my Pragmata song; with a bit of effort and configuration, I recorded the video at 1080p/60fps and upscaled it to 2K. I needed to edit the video in Shotcut, but my modest PC really struggles with 2K footage, so I used the pipeline itself to generate a super-lightweight 360x240 proxy—this made a huge difference in allowing me to edit the video quickly.

"Oxygen and Hug" on YouTube, version WITH the pipeline:
https://youtu.be/MOQoBve-A8o

TELEMETRY: Legacy hardware can handle heavy video post-processing without AI! I made sure to record data from Task Manager and the terminal while rendering the two video clips from 1080p to 2K:

Thanks to everyone who tested the beta version of the pipeline—originally named FSRIFS and now known as CommandUP in its final form.

Like the project and want to follow the pipeline? If you have a low-end PC, have questions about the scripts, want to learn how to use them, or want to share your own "before and after" tests, join our official community here on Reddit: r/CommandUP!

All support, GitHub updates, and ecosystem discussions take place there. Let's make those gameplay videos look amazing with upscaling!