Kill Feed Detection: Auto-Clip Any Game

Your game isn't on the list. You checked Medal — no automatic clipping. Outplayed — not a supported title. NVIDIA Highlights — the developer never integrated it. So the 4k you hit in Squad last night is buried somewhere inside a three-hour VOD, and the only kill feed detection software you currently own is your own scrubbing thumb.

Here is the premise of this guide: the supported-games list is an artifact of how legacy tools detect kills, not a law of nature. Every list-based clipper needs the game to announce kills to it — through an API, an event hook, or an SDK someone had to build. But there is a second way that needs nothing from the game at all: read the screen. If your game draws a kill feed, every kill is already being displayed, in a fixed corner, in a consistent format, with your name on it. Pixel and OCR detection reads that feed the way you would — frame by frame, at scan speed instead of watch speed. Any game. Any recorder. Day one of release.

Full disclosure up front: we build GameClipper Advanced, a Windows 10/11 app that does exactly this, and we use it as the worked example below. The mechanics, though, are tool-agnostic — by the end you'll understand precisely how kill feed detection software works and why it makes the supported-games list obsolete.

What Is a Kill Feed?

A kill feed is the constantly updating log of eliminations a game draws on screen — usually in the top-right corner. Each kill adds a new row showing the killer, often a weapon or headshot icon, and the victim. Nearly every competitive shooter renders one, making it a universal on-screen record of every kill in the match.

Three properties make the kill feed ideal for machine detection. It appears in a fixed screen region that never moves during play. Kill rows have a consistent visual signature — same font, same layout, same accent colors — that a vision model can learn to spot. And each row contains the killer's name in readable text, which means software can tell your kills from your teammates'. The game is broadcasting a structured kill log to your monitor every second you play; detection software just needs to be taught to read it.

How Auto-Clipping Software Detects Kills Today

Before pixel detection, three architectures dominated — and all three share the same dependency: the game must cooperate. (For the full tool-by-tool landscape, see our guide to tools that auto clip kills in a VOD.)

Game API and replay hooks (Medal)

Medal's automatic event detection listens to the game's own data. Its support documentation is candid about the mechanism: "most of the Auto Clipping games on Medal use the game's Replay system as a base" — several titles require the in-game replay feature enabled or auto-clipping simply doesn't function. The result is high-accuracy detection on a short list: the same support article enumerates 15 supported games as of late 2025. Marketing pages cite clipping for 1,000+ games, but that larger number is manual hotkey clipping — the automatic detection list is the 15.

Overwolf game events (Outplayed)

Outplayed runs on Overwolf's game-events platform: for each supported title, Overwolf maintains an event hook that reports kills, deaths, and victories to apps built on it. Where a hook exists, capture is automatic. Where it doesn't, nothing happens — and someone at Overwolf has to build and maintain every hook, per game, through every patch.

Driver-level SDKs (NVIDIA Highlights)

NVIDIA Highlights inverted the responsibility: the game developer integrates NVIDIA's SDK, and the game itself triggers a highlight save on kills or multikills. Free, elegant — and entirely dependent on developers adopting and maintaining the integration, which is why NVIDIA Highlights not working after a patch is such a common search. More on where that SDK stands today in a moment.

Why the Supported-Games List Model Is a Dead End

Don't take our word for it — take the vendors'. Overwolf's own Outplayed support article spells out what happens with games outside its list: unsupported games "can only be set to record manually and can not record automatic highlights & display game events." That's the official answer for every title without an event hook: you're back to pressing a hotkey.

NVIDIA is even more final. The Highlights developer page now carries this notice: "This is a legacy SDK. Developers may download and continue to use, but it is no longer supported." The SDK that powered per-game automatic highlights is not being carried forward — existing integrations linger, new ones have effectively stopped.

And Medal, the biggest name in the category, maintains automatic detection for 15 games. Line those three facts up and the pattern is hard to unsee: every list-based architecture leaves the long tail behind. Squad, Hell Let Loose, Arma Reforger, Delta Force, Escape from Tarkov — huge, clip-worthy communities with no kill-event support anywhere (Overwolf's Tarkov hook, for instance, exposes a death event but no kill event). And the list model fails hardest exactly when you want clips most: launch week. A day-one release has no event hook, no replay integration, no SDK — list-based tools historically take weeks or months to add a new title, if they ever do. Pixel detection has no such lag, because it never asked the game for permission in the first place.

How Pixel + OCR Kill Feed Detection Works

The vision-based approach usually gets described in marketing shorthand — "GPU-accelerated computer vision" and little else — so here is the actual pipeline, stage by stage. This is how our scanner works, and broadly how any competent kill-feed detector must work.

Region-of-interest cropping

Analyzing the full 1080p or 1440p frame would waste almost all the compute on sky, gun model, and minimap. So step one is a region of interest (ROI): you tell the software where the kill feed lives by drawing a box around it once. From then on, the scanner crops every frame down to that small rectangle — cutting the pixels to examine per frame by an order of magnitude or more and, just as importantly, eliminating false positives from text elsewhere on screen (chat, objective banners, damage numbers).

Frame-by-frame vision matching

Inside the ROI, the scanner looks for the visual signature of a kill row — the layout, iconography, and color accents that distinguish an elimination line from an empty corner of sky. Hobbyists attempt the same thing with raw template matching — one OpenCV forum thread crops each frame down precisely because "the kill in the game shows up on the top right corner" — but production detection has to be more tolerant, using matching modes that survive compression artifacts, changing backgrounds behind a semi-transparent feed, and varied row content. GameClipper ships multiple matching modes so you can trade strictness for recall per game.

OCR name confirmation: whose kill is it?

Here is the failure that fills feedback boards. A detector that only recognizes "a kill row appeared" will fire on every elimination in the feed — including your squad's. Even Medal has had to ship CS2 fixes so users would stop getting kill events from players they were spectating. The fix is reading, not just recognizing: run OCR on the killer-name portion of each detected row and keep only rows matching your in-game name. That single step drops false positives to near zero and is the difference between a highlight reel and a folder of other people's frags. It matters enough that we wrote a dedicated guide to clipping only your kills, not your teammates'.

Confidence thresholds and de-duplication

Raw detections need two post-processing passes. First, a confidence threshold: each candidate match gets a score, and you decide the cutoff — stricter to eliminate stray matches, looser to catch kills half-hidden behind muzzle flash. Second, merging: a kill row stays on screen for several seconds, and consecutive kills overlap, so naive software cuts one clip per detection — four files for one 4k. The failure is common enough that Medal's own CS2 fixes included consolidating consecutive kills into a single clip. Correct de-duplication collapses detections of the same row, then merges kills that fall within your lead-in/lead-out window into a single clip, so a 4k becomes one clip with all four eliminations in sequence.

VOD scanning vs real-time capture

Every list-based tool is live-capture: it must be running before the play happens, and yesterday's footage is unrescuable. Pixel detection has no such constraint — a VOD is just frames, and frames can be read at any time, far faster than real time since the scanner never has to render at watch speed and can sample at a tunable scan rate. That inverts the workflow: record with whatever you already use (NVIDIA App/ShadowPlay, OBS, Game Bar, a capture card), play with zero clipping software running, and scan the file afterward. Last week's recordings work. A friend's VOD works. If you've been finding kills in VODs by hand, this is the step that automates it.

Worked Example: Setting Up Kill Feed Detection in GameClipper

Theory to practice. Here's the complete calibration in GameClipper Advanced — a one-time job per game, about two minutes, saved as a reusable profile.

1. Load a VOD frame. Import any recording of the game and pause on a frame where the kill feed is visible with at least one kill row on it.
2. Draw a box around the kill feed. Drag a rectangle over the feed region — top-right corner in most shooters. This becomes the ROI for every future scan.
3. Capture your in-game name. Mark your name as it appears in a feed row, so OCR confirmation clips your kills and nobody else's.
4. Save the game profile. The ROI, name, and matching settings are stored as a profile for that game.
5. Scan any VOD. Point the scanner at any recording of that game — tonight's or last month's. The same profile works on every future video until the game visually redesigns its feed.

After the scan, every knob is live: match sensitivity, lead-in and lead-out per clip, scan rate, minimum clip length — results recompute instantly with no re-scan. Want three more seconds before each kill so the flick reads on screen? Drag a slider; the whole clip set updates. From there GameClipper auto-assembles a montage with hard cuts, fades, or crossfades on a hand-editable timeline — preview, nudge, trim, drop, restore — and exports via GPU NVENC at 1080p 16:9 or vertical 9:16 for Shorts and TikTok with a blurred pillarbox, so the HUD (including that kill feed) is never cropped.

Which Games Does Kill Feed Detection Work With?

Any game that draws an on-screen kill feed. That's the whole answer, and it's the point: there is no list to check, because the detector reads pixels, not game memory. Warzone, Fortnite, Apex, Valorant, CS2, Battlefield, PUBG — obviously. But the games that make pixel detection necessary are the ones every list forgot:

• Auto clip kills in Delta Force — a huge extraction-shooter audience with no Medal event support.
• Squad and Hell Let Loose — milsim communities that have never appeared on an auto-clip list and likely never will.
• Tarkov auto clip — where the kill feed is your after-raid record and clip-worthy kills are rare enough to be unmissable.
• Arma Reforger — same story: visible feed, zero event-hook support.
• Battlefield 6 auto clipping from day one — the day-one-release case in action: calibrate at launch, no waiting for anyone's integration.

The only genuine limitation is the inverse: no visible kill feed, no detection. Games or modes that hide the feed (some hardcore modes, some cinematic settings) give the scanner nothing to read. If the feed is on screen in your recording, you're in.

Kill Feed Detection vs Game-Event Hooks vs Replay APIs

The architectures, side by side:

Read the last row twice, because it's the sleeper argument. Every architecture breaks eventually — games patch. The difference is who fixes it. With event hooks and SDKs, you wait for a vendor or a developer. With pixel detection, the fix is a two-minute recalibration you do yourself, the day the patch lands.

Scan Your First VOD

The supported-games list had a good run, but its own vendors have written its ending: manual recording for unsupported titles, a legacy SDK, a 15-game ceiling. If your game draws a kill feed, you don't need anyone's list — you need software that can read your screen.

Download GameClipper Advanced free, calibrate your game in two minutes, and scan last night's VOD. The free version includes full detection, scanning, editing, and export forever, with a small watermark on exports; $19 one-time removes it — sign in with Google to activate, no subscription, and your footage never leaves your machine. Worst case: you spend two minutes drawing a box. Best case: you never scrub a three-hour VOD for your own 4k again.