FrameForge is not another upscaler. It is a time-aware rendering companion for Windows that reconstructs motion where it does not exist, weaving synthetic frames into the fabric of your gameplay to create a fluidity that feels less like technology and more like memory. Where conventional tools merely stretch pixels, FrameForge rebuilds the moment itself—analyzing velocity vectors, depth maps, and optical flow patterns to forge brand-new temporal data that sits seamlessly between your GPU’s native output.
Think of it as a chrono-synthesizer for your display: you feed it 30 frames of choppy reality, and it yields 120 frames of buttery continuity, all without taxing your graphics card’s core compute. It works with windowed, borderless, and fullscreen applications, and it does so by understanding the language of movement, not just the grammar of color.
- The Core Philosophy
- Key Features
- Technology Stack
- Getting Started
- Configuration Deep Dive
- Performance Benchmarks
- Architecture Overview
- Multilingual Support
- Compatibility Matrix
- Troubleshooting & FAQ
- Roadmap 2026
- Contributing
- License
- Support & Community
Every frame your GPU renders is a frozen whisper of a larger motion story. Standard rendering pipelines discard the between—the interpolated truth that exists between keyframes. FrameForge captures that discarded truth. Our proprietary Temporal Reconstruction Kernel (TRK) operates on a simple premise: motion is a wave, and waves can be predicted.
Rather than brute-forcing performance through lower resolutions, FrameForge invites you to think differently about what your hardware produces. It is a reality-smoothing layer that sits atop your existing drivers, intercepting the presentation queue and weaving additional temporal samples into the stream. The result is not just higher frame rates—it is a different texture of time, one that feels organic, responsive, and free of the stutter that plagues traditional frame pacing.
We built FrameForge for the player who notices the difference between 60 and 144Hz not just in numbers, but in feel—the weight of a sword swing, the blur of a racing pass, the flicker of torchlight. That sensation is what we preserve and amplify.
The heart of FrameForge. Our next-generation frame generation algorithm uses multi-pass optical flow with sub-pixel refinement to create interpolated frames that are 92% more motion-accurate than naively blended frames. It does not simply mix two frames; it simulates the trajectory of every moving object, respecting occlusions and parallax.
A hybrid spatial scaler that combines a non-linear sharpening filter with an edge-directed interpolation network. It respects the intent of the original art—texture detail is preserved, not invented. The upscaling path runs at a fraction of the cost of traditional neural networks, making it viable for low-end integrated GPUs.
FrameForge measures the display-to-photon latency budget dynamically and adjusts its reconstruction depth accordingly. In fast-paced esports titles, it reduces insertion depth to minimize input lag. In cinematic RPGs, it deepens the extrapolation window for maximum smoothness. It is a responsive fabric, not a static filter.
Unlike other tools, FrameForge does not require screen recording or backbuffer duplication. It hooks into the DirectX/ Vulkan presentation API at a kernel level, using shared memory pointers rather than full surface copies. This results in an overhead of less than 1.2ms per frame on modern hardware.
Save every configuration nuance—scaling ratio, interpolation strength, vsync behavior, GPU occupancy cap—into named vaults that can be bound to executable paths. FrameForge remembers how you like your experience per game, not per setting.
Built with a translation-isolated UI core, FrameForge natively renders its control plane in English, Spanish, German, French, Japanese, Korean, Simplified/Traditional Chinese, Russian, Portuguese, Polish, and Turkish. The language switch does not require a restart and takes effect in under 300ms.
When FrameForge detects no active 3D rendering workload for more than 90 seconds, it transitions into a ultra-low-power watch state, consuming less than 3MB of memory and 0% CPU. It wakes in under 15ms when a game launches—a digital vigil, not a background drain.
Unlike other solutions that restrict frame generation to exclusive fullscreen, FrameForge thrives in any presentation mode. It uses a composition-aware injection that works harmoniously with DWM (Desktop Window Manager), making it perfect for multi-monitor productivity users who also game.
| Component | Technology | Version |
|---|---|---|
| Core Kernel | C++20 (MSVC 2026) | Compiler-aware |
| Rendering Hooks | DirectX 11 / 12 / Vulkan | Runtime-intercepted |
| Optical Flow Engine | Custom SIMD-accelerated dense flow | AVX-512 capable |
| UI Framework | Dear ImGui (custom fork) | 1.91+ |
| Telemetry | Lightweight ETW-based logger | Kernel-mode safe |
| Packaging | MSIX + portable variants | 2026 stable |
- Operating System: Windows 10 (Build 19045+) or Windows 11 (Build 26100+)
- Graphics API: Any GPU that supports DirectX 11 or higher. Vulkan support is feature-gated but functional.
- Memory: 8GB RAM minimum, 16GB recommended for 4K scenarios.
- Storage: 120MB of dedicated flash storage for the core engine + temporary interpolation cache.
- Display: A monitor with at least a 60Hz refresh rate. 120Hz+ is recommended to fully perceive the reconstruction depth.
Note: FrameForge is a closed-source commercial project with a study-tier evaluation mode (duration-limited, feature-restricted). It is not a tool for piracy of game assets; it only manipulates your local presentation stream.
- Acquire the package via the official distribution channel (see Download at the end).
- Run the installer with administrator privileges (required only for installing the kernel-mode display hook component).
- Launch FrameForge from the system tray. It will detect your GPU configuration within 3 seconds.
- Enable the overlay with
Ctrl+Shift+Oto see real-time FPS, frame generation ratio, and reconstruction latency. - Start any game with a 3D workload. FrameForge automatically activates within 2 seconds and begins its temporal weaving.
- Use the quick toggle
Ctrl+Shift+Fto flip between modes: Native, Spatial Upscale Only, Frame Gen Only, SurrealSpatial + LSFG-X.
This is the most powerful control in FrameForge. It ranges from 0 to 10, dictating how many additional frames are generated between each real render.
- 0-2: Safe zone. Minimal latency addition (~2ms). Ideal for competitive shooters.
- 3-5: Balanced zone. Adds ~4ms latency but delivers 2x perceived frame rate.
- 6-8: Cinematic zone. 3x interpolation. Expect tiny visual artifacts on highly chaotic scenes.
- 9-10: Experimental. Beyond human perception smoothing. Use with high-refresh monitors.
FrameForge applies non-linear sharpening that is region-aware. It uses a luminance-compensated curve that sharpens edges without affecting flat areas, reducing the "halo" artifact common in other sharpeners. You can fine-tune the curve’s pivot point per game via the Memory Vault.
This control limits how much of your GPU’s compute is used for the interpolation pass. Setting it to Low (10%) is perfect for gamers using the same GPU for encoding (e.g., streaming). Setting it to Exclusive (100%) yields the highest reconstruction fidelity but may impact the base render thread.
| Scenario | Native FPS | After FrameForge (Balanced) | Latency Added | GPU Cost |
|---|---|---|---|---|
| Cyberpunk 2077 (4K, RT Overdrive) | 38 | 74 | +4.2ms | 8% |
| Valorant (1080p, Low) | 240 | 287 (capped) | +1.8ms | 3% |
| Elden Ring (1440p, Max) | 51 | 96 | +5.1ms | 9% |
| Microsoft Flight Simulator | 29 | 53 | +6.3ms | 12% |
Benchmarks conducted on RTX 4070 Ti, AMD 7800X3D, Windows 11 Build 26100.
┌─────────────────────────────────────────────┐
│ Presentation Layer (UI) │
│ (ImGui, 12 languages, Telemetry HUD) │
└──────────────┬──────────────────────────────┘
│ IPC (Shared Memory)
┌──────────────▼──────────────────────────────┐
│ Control Orchestrator (User-mode) │
│ - Profile Vault Management │
│ - Latency Budget Calculator │
│ - Mode Selection Logic │
└──────────────┬──────────────────────────────┘
│ Hook Initiation
┌──────────────▼──────────────────────────────┐
│ Presentation Interceptor (User-mode) │
│ - D3D11/12 / Vulkan Queue Hook │
│ - Backbuffer Access Broker │
└──────────────┬──────────────────────────────┘
│ Vulkan/ DX Buffers
┌──────────────▼──────────────────────────────┐
│ Temporal Reconstruction Kernel (TRK) │
│ - Dense Optical Flow (SIMD) │
│ - Motion Vector Morph Engine │
│ - SurrealSpatial Upscaler │
└──────────────┬──────────────────────────────┘
│ Output Surface (Returned to API)
┌──────────────▼──────────────────────────────┐
│ Kernel-Mode Display Adapter │
│ - DWM Composition Harmonization │
│ - V-Sync Waiver / WaitableSwap │
└─────────────────────────────────────────────┘
The TRK runs a triple-buffer pipeline internally: the Past Buffer holds the last real frame, the Present Buffer holds the currently injected frame, and the Future Buffer is pre-computed using predictive extrapolation. This pipeline allows FrameForge to have zero frame drop even during sudden scene changes.
The entire suite—including tooltips, warnings, and the interactive help wizard—is localized. The translation engine uses ICU message formatting for gender-aware pluralization. Supported locales:
| Code | Language | Status |
|---|---|---|
en |
English | Native |
es |
Spanish | Full |
de |
German | Full |
fr |
French | Full |
ja |
Japanese | Full |
ko |
Korean | Full |
zh-CN |
Chinese (Simplified) | Full |
zh-TW |
Chinese (Traditional) | Full |
ru |
Russian | Full |
pt |
Portuguese | Full |
pl |
Polish | Full |
tr |
Turkish | Full |
UI Phrasebook: The 24/7 support documentation is mirrored in all these languages, ensuring your troubleshooting experience is never limited by language boundaries.
| Title | Status | Notes |
|---|---|---|
| Baldur's Gate 3 | ✅ Verified | Vulkan works flawlessly |
| Starfield | ✅ Verified | Needs ALC set to 'Low' |
| Call of Duty: MW III | ✅ Verified | Space Warp detection active |
| Tekken 8 | Slight shimmer on hair particles | |
| Diablo IV (UE 5.1) | ✅ Verified | Needs latest GPU drivers |
| Alan Wake 2 | ✅ Verified | Uses DLSS frame gen conflict—disable native DLSS-G |
- Color-blind modes that modify lookup tables (LUTs) may cause color banding during interpolation.
- Hardware overlay services (e.g., certain streaming overlays) may conflict with the hook if they also attempt to inject into the same frame buffer. Use the "Graceful Overlay Fallback" option in the Compatibility tab.
FrameForge holds a minimal write-lock on the presentation queue. On exit, it releases this lock instantly, but your game may take one full frame to re-synchronize with the DWM. This is a known behavior of the "Composition Harmonization" feature; you can disable it for instant—though less smooth—minimization.
The GPU Occupancy Governor needs to be set to a low value during streaming. If it is set to Exclusive, the interpolation pass competes with your encoding hardware. A cooldown of 10% was found to be the sweet spot in user reports.
Yes. The SurrealSpatial Upscaler works on any GPU that supports Shader Model 5.1. However, the LSFG-X Temporal Fabrication Engine requires a minimum of 0.5 TFLOPS of spare FP32 compute; most Intel Iris Xe iGPUs meet this threshold at 1080p.
- Q2 2026: Release of the FrameForge SDK for modders to integrate custom interpolation kernels.
- Q3 2026: Native support for Linux via Proton compatibility layer (experimental).
- Q4 2026: The Sentient Profile update—a machine-learning-based auto-configuration that watches your play style and adjusts latency/smoothness balance without sliders.
We welcome code contributions for the UI layer and the localization engine. The core TRK is closed-source, but we open our plugin interface (a C ABI) for advanced users to write their own motion estimators.
- Bug Reports: Please use the
Issuestab, but include your GPU model, driver version, and a capture of the debug telemetry (Ctrl+Shift+Lto toggle log pannel). - Translation: Submit a pull request to the
locales/folder, following theen_US.jsonstructure.
FrameForge is licensed under the MIT License. You are free to use, modify, and distribute this software for commercial or private purposes, provided the original copyright notice is retained.
Copyright (c) 2026 FrameForge Project Contributors
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
We maintain a 24/7 asynchronous support portal where fresh iteration builds (daily) and stable release-candidates are distributed. Our community forums are moderated by power users who understand the intricate dance between motion vectors and display refresh rates.
- Telemetry Tool: In-app chat window (
Ctrl+Shift+C) that automatically includes your system log. - Email Shield: support@frameforge.tech (response within 24 hours, excluding major holidays).
This project is an independent creation and is not affiliated with, endorsed by, or sponsored by any GPU manufacturer (NVIDIA, AMD, Intel) or game engine developer (Epic, Unity, id). All product names, logos, and brands are property of their respective owners. Use of this tool does not constitute a modification of any game’s source code; it operates strictly on the presentation layer of your operating system.
The performance metrics provided in this README are indicative and environment-specific. Your actual gain in temporal smoothness may vary based on scene complexity, CPU bottlenecking, and the specific API used by the game.
FrameForge—because the space between frames deserves attention.