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.

~9 min read • View on GitHub • More from apex-compute

A wide laboratory bench seen slightly from above. Two identical game frames sit side by side under small glass specimen frames, perfectly aligned, with brass calipers measuring the gap between them. A magnifying instrument on an articulated arm hovers over the right-hand frame, an open ruled ledger records one row per frame, and a sealed black shipping crate sits at the far edge of the bench with a small blank tag. The image explains the article's thesis: identical inputs are judged and measured by an open instrument while the sealed thing being measured stays closed.
The whole story in one bench: two identical frames, an instrument that measures the gap, and a sealed crate at the edge.
Key Takeaways

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.

selimsandal, Top contributor listed by the repository · apex-compute/ANR

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, Project announcement, as quoted by GamingOnLinux · GamingOnLinux launch report

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.

The recorder loses frames on purpose. Watch the ring fill and the next frame drop, because stalling the game would falsify the measurement.

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.

A tight close-up of four physical archival objects on a shelf: a single index card in a card-catalog drawer, a ruled ledger with exactly 64 tiny uniform rows per page and ticked edges, a stack of photographic glass plates each etched with a faint 8x8 tile grid with one plate lifted out to show the grid, and a small reel of paper tape with dense tick marks. The image makes an abstract binary format physical, turning the fixed 64-byte index record and the 8x8 chunk tiling into objects a reader can hold.
Four files, four objects: metadata, a fixed 64-byte index, gridded texture plates, and a tape of call 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.

ProjectVendor scopeWhat's openFrame generationNotes
ANRNVIDIA, AMD, Intel, Steam Decknr-record only; model is closed binariesFG in beta; SR/RR not releasedNo license stated at launch
NVIDIA DLSS / DLSS-GNVIDIA RTX onlyClosedYes, matureThe principal benchmark target; more consistent in independent beta testing
AMD FSRBroad, some cross-vendorPartially openYes (varies by version)No direct ANR/FSR head-to-head in available evidence
Intel XeSSBroad, Arc-firstClosedYesNot an all-vendor, all-feature suite
OptiScalerCross-vendorOpenNo (it is a compatibility layer)The route ANR FG uses to install into games
Lossless Scaling / LSFGBroadClosedYes, application-levelPractical 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.

GamingOnLinux, Publication · GamingOnLinux launch report

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.