ByteTrack vs TrackTrack

ByteTrack vs TrackTrack: FPS on every GPU

End-to-end detection + tracking throughput (frames per second, higher is better) for ByteTrack and TrackTrack across all 10 GPU tiers. GPUs are ordered flagship-first.

Tip: Bold marks the faster tracker on each GPU. Measured with yolo26n.pt on a 200-frame clip.

ID-stability: the same on every GPU

How well a tracker holds a single, consistent ID on each object is a property of the algorithm, not the GPU, so these numbers barely move across hardware; we report them once (measured on the NVIDIA H100). This clip has no MOT ground truth, so instead of MOTA/IDF1 we report the raw stability signals: how many distinct IDs the tracker created, how many times a track was broken (fragmentations), and the average track length. Fewer IDs and fewer fragmentations mean steadier identities.

Tip: Lower unique-ID and fragmentation counts (and longer average tracks) mean more stable identities on this footage. These are relative signals on one clip, not published MOT17/MOT20 accuracy scores.

How to choose the right tracker

Methodology

• Same input for everyone. Every tracker ran on the identical 200-frame test clip with the same yolo26n.pt detector, so only the tracker changes.
• Speed, per GPU. FPS and ms/frame are the end-to-end detection + tracking rate measured on each of the 10 GPU tiers, so you can match a tracker to the hardware you actually run.
• Stability, measured once. ID-stability is hardware-independent, so unique-ID, fragmentation and track-length figures are reported from a single GPU. We do not publish MOTA/IDF1 because this clip has no MOT ground truth; those belong on a labeled dataset like MOT17.
• Reproducible. All six trackers ship inside Ultralytics; the same run works on your own footage by pointing the code below at a different clip.

Measure it yourself

The exact local recipe behind these numbers: load a YOLO model once, run one tracker frame by frame, and collect FPS, latency and ID-stability. Swap the single tracker line to compare any of the six.

import time
from collections import defaultdict

import cv2
from ultralytics import YOLO

# 1. Load the detector once, then reuse it for every tracker you compare.
model = YOLO("yolo26n.pt")

# swap: botsort / fasttrack / deepocsort / ocsort / tracktrack
tracker = "bytetrack.yaml"

# 2. Read a short clip into memory (128-300 frames is plenty).
cap = cv2.VideoCapture("clip.mp4")
frames = []
while cap.isOpened() and len(frames) < 200:
    ok, frame = cap.read()
    if not ok:
        break
    frames.append(frame)
cap.release()

# 3. Run the tracker frame by frame, timing only the track() call.
unique_ids, last_seen, track_len = set(), {}, defaultdict(int)
fragmentations, total_time = 0, 0.0

for i, frame in enumerate(frames):
    t0 = time.perf_counter()
    preds = model.track(frame,
                        tracker=tracker,
                        persist=True,
                        verbose=False)
    total_time += time.perf_counter() - t0

    boxes = preds[0].boxes
    if boxes is None or boxes.id is None:
        continue

    for tid in boxes.id.int().tolist():
        # A fragmentation = an ID that
        # vanished for >=1 frame, then came back.
        if tid in last_seen and i - last_seen[tid] > 1:
            fragmentations += 1
        last_seen[tid] = i
        unique_ids.add(tid)
        track_len[tid] += 1

# 4. The metrics reported on this page.
print(f"FPS:            {len(frames) / total_time:.1f}")
print(f"ms/frame:       {total_time / len(frames) * 1000:.1f}")
print(f"unique IDs:     {len(unique_ids)}")
print(f"fragmentations: {fragmentations}")
print(f"avg track len:  {sum(track_len.values()) / len(track_len):.1f}")

Install once with pip install ultralytics opencv-python, then run it on your own clip.

Frequently asked questions

Which YOLO tracker is the fastest?

Deep OC-SORT posted the highest FPS on most GPUs in this benchmark, leading on 8 of the 10 tiers, with ByteTrack fastest on the H100 and FastTracker on the T4. All three clear roughly 100 FPS on an H100 with YOLO26n. TrackTrack and BoT-SORT (with Re-ID and camera-motion compensation enabled) were the slowest, often under 15 FPS.

Which tracker keeps object IDs the most stable?

TrackTrack produced the fewest ID fragmentations of any tracker, followed by BoT-SORT, ByteTrack and FastTracker. Motion-only OC-SORT produced by far the most unique IDs and fragmentations on this clip, because without an appearance model it starts a new ID whenever an object is briefly occluded. ID-stability is a property of the algorithm, so it is essentially the same on every GPU.

Does a more expensive GPU make tracking more accurate?

No. A faster GPU only makes tracking run faster; it does not change how accurately the tracker follows objects. Accuracy and ID-stability depend on the tracking algorithm and your detector, not the hardware. That is why this page reports speed per GPU, but ID-stability only once.

How was this YOLO tracker benchmark run?

Every tracker ran on the same 200-frame clip with the same yolo26n.pt detector, on each of the 10 GPU tiers. FPS is the end-to-end detection-plus-tracking rate. All six trackers are built into Ultralytics, so results are reproducible with a single script.

Which tracker should I use for a real-time application?

For real-time or edge deployments, ByteTrack and FastTracker are the safe defaults: they run well past real time (100+ FPS on modern GPUs) and stay lightweight with no Re-ID model to load. Deep OC-SORT actually posted the highest raw FPS on most GPUs here, so test it too if you want its Re-ID for steadier IDs through occlusion. If your camera moves (drones, dashcams), BoT-SORT's motion compensation is worth the extra compute. Reserve TrackTrack for offline analysis where identity correctness matters more than speed.