ANR Shipped a Scoreboard, Not a Model
Apex Compute's neural rendering suite is mostly sealed binaries. The open part, nr-record, is a lossless capture pipeline built to judge frame generation on identical frames.
- The repository named anr contains no neural network; it contains nr-record, the capture and replay pipeline built to compare frame generators on identical frames.
- nr-record is engineered to drop frames rather than stall the game, because a stall would corrupt the very performance being measured.
- The on-disk format is pinned by compile-time layout assertions, making the recording spec a durable artifact independent of any tool version.
- Apex Compute's performance edge is developer-published; independent testing finds higher average FPS alongside weaker lows and higher latency.
The Repo Named After a Product That Isn't In It
The repository is called anr. The README leads with ANR FG, ANR SR, and ANR RR: a cross-vendor neural rendering suite pitched as the thing NVIDIA DLSS should worry about. Then it says the quiet part out loud. Source code, for ANR itself, is coming soon.
What is actually in the repo is nr-record. A recorder that captures a game's frame-generation or upscaler inputs losslessly, plus replay tools that drive ANR FG, DLSS-G, and anything else over the exact same captured data. The model ships as DLL packages (anr-fg-full, anr-fg-addon) installed into games through OptiScaler. The measuring stick is open. The thing it measures is sealed.
Apex Neural Rendering by Apex Compute.
That inversion is the story. ANR is being covered everywhere as a DLSS competitor. The open artifact is a referee.
Why Frame Generation Needs a Referee
Apex Compute's pitch is breadth. NVIDIA GTX 16 and RTX 20 through 50, AMD RX 5000 through 9000 and Steam Deck, Intel Arc A and B, on Windows and Linux/SteamOS through Proton. One suite for hardware that normally has three different answers.
But quality claims are unfalsifiable if every implementation sees a different game state. Jitter offsets, motion vectors, camera parameters, and the exact textures fed to each generator shift frame to frame and title to title. Run DLSS-G on one pass and ANR FG on the next and you are measuring two different games.
To compare frame generators you have to freeze the inputs. nr-record is that freeze.
The repository's listed top contributor is selimsandal, with 16 contributions. No verified real name or public headshot was found, so this article uses no portrait.
Introducing Apex Neural Rendering (ANR), our cross-platform Super Resolution, Ray Reconstruction, and Frame Generation technology, delivering up to 2.4× faster performance and higher quality rendering than NVIDIA DLSS.
Apex Compute's published numbers put ANR FG at 1.01 ms per generated frame and 214 MB of VRAM at 4K on an RTX 5090, against 1.26 ms and 562 MB for DLSS FG. Those are developer-published, not independent. Hold them as claims.
A Recorder That Never Stalls the Game
The recorder's header comment describes the whole architecture in one paragraph.
Four stages. The Packer codes each real frame's textures on the GPU, on the game's own command list, into a ring slot in device memory (up to 16 slots). The recorder's copy queue drains finished slots to a readback buffer. Worker threads memcpy or zstd-compress the words in 2 MiB blocks, freeing the slot. A writer thread appends frames in order to frames.bin and frames.idx.
The governing rule is that the source thread only ever issues GPU commands. It never waits.
When the ring is full, the frame is dropped and marked as a gap. Replay resets its temporal state at that gap. Dropping is the correct behavior, not a bug. A stall would corrupt the very performance being measured, which is the one thing a measurement tool must never do.
The recorder also measures itself. record.json carries pack_gpu_ms_median, copy_ms_median, and per-thread CPU seconds, so the tool's own overhead is on the record.
The Format Is the Product
The most durable artifact here is not the recorder. It is the format.
A recording is four files. record.json holds metadata, texture roles, and parameter names. frames.idx is 64 bytes per real frame. frames.bin holds each frame's textures, losslessly coded. params.bin holds every call's parameters.
The layouts are pinned by compile-time assertions.
struct IndexRecord { ... };
static_assert(sizeof(IndexRecord) == 64);
struct BlocksHeader { ... };
static_assert(sizeof(BlocksHeader) == 24);
struct CallHeader { ... };
static_assert(sizeof(CallHeader) == 32);
That makes the on-disk shape a compile-time invariant. FORMAT_VERSION is 4, with readers accepting 1 through 4, and CODING_VERSION is 3. Old recordings stay readable.
Channels pack a whole texture format into one byte (bits | type << 5 for UNORM, FP16, FP32). Textures are described as chunks of 32 8x8 tiles with two words per chunk, which allows random access and parallel decode. WorstWords() pre-bounds the coded size so GPU slots are allocated up front and the hot path stays allocation-free.
Blocks are 2 MiB, and the high bit of the length field flags stored-raw versus zstd. That lets the writer skip compression when it cannot keep up.
The detail that makes cross-implementation comparison possible is the parameter mapping. DLSS-G NGX names like DLSSG.JitterOffsetX and DLSSG.MvecScaleX map to canonical fields in an Fg struct. The vendor's convention is separated from the tool's own.
The Claims vs. the Frames
Apex Compute's own numbers favor ANR: 1.01 ms per generated frame and 214 MB of VRAM at 4K on an RTX 5090, against 1.26 ms and 562 MB for DLSS FG.
Wccftech's independent three-game beta testing (Valor Mortis, Cyberpunk 2077, The Witcher 3 Remastered) tells a more mixed story. Generally higher average displayed FPS for ANR, but weaker low-percentile frame rates in some tests. In Cyberpunk 2077 at 3X, more flicker, temporal instability, interpolation artifacts, and jitter. In Witcher 3 at 4X, reported PC latency of 57.8 ms for ANR versus 38.6 ms for DLSS.
Neither side is settled. Developer benchmarks and a single outlet's beta testing are two data points, not a verdict.
| Project | Vendor scope | What's open | Frame generation | Notes |
|---|---|---|---|---|
| ANR | NVIDIA, AMD, Intel, Steam Deck | nr-record only; model is closed binaries | FG in beta; SR/RR not released | No license stated at launch |
| NVIDIA DLSS / DLSS-G | NVIDIA RTX only | Closed | Yes, mature | The principal benchmark target; more consistent in independent beta testing |
| AMD FSR | Broad, some cross-vendor | Partially open | Yes (varies by version) | No direct ANR/FSR head-to-head in available evidence |
| Intel XeSS | Broad, Arc-first | Closed | Yes | Not an all-vendor, all-feature suite |
| OptiScaler | Cross-vendor | Open | No (it is a compatibility layer) | The route ANR FG uses to install into games |
| Lossless Scaling / LSFG | Broad | Closed | Yes, application-level | Practical alternative; no direct technical comparison available |
Open Tool, Closed Model
Here is the honest turn. The model is closed binaries. At launch the repository carried no license, and public code on GitHub is not the same thing as an OSI-approved open-source license.
So I'll refrain from calling it "Open Source" until they sort that out.
The suite's name promises frame generation, super resolution, and ray reconstruction. Only FG is testable. SR and RR are not released.
So what would it take to trust the scoreboard? Independent replication of the format's claims, a stated license, and SR and RR actually shipping. Until then, the open part is a good instrument and the product is a promise.





