Turn a level you already have into a labelled computer-vision dataset, without leaving the editor and without writing a converter. Draw the zones, assign the classes, press generate, and get frames with bounding boxes, instance masks, keypoints and metric depth, written as YOLO and COCO alongside the raw capture.

What it writes

• Bounding boxes, computed from the per-instance identity buffer and the camera transform that drew the frame, not estimated from a projected 3D box.

• Instance segmentation masks, one identity per object, from the same render pass, so an object split behind a railing stays one object.

• Keypoints with occlusion state, per joint: visible, occluded, or off-frame, told apart rather than lumped together.

• Metric depth, float, in metres, not a normalised buffer.

• Per-frame metadata: camera intrinsics and extrinsics, the spawn manifest of what was asked for and what was actually placed, and the environment as it was resolved.

• YOLO and COCO, both written from the same derived annotations, plus the raw dump if you want to derive your own.

What you control

• Population: counts, densities, spacing, slope limits, exclusion zones, groups and minimum distances between classes. Every frame ships a manifest of what was refused and why.

• Cameras: orbit, drone, random, grid, fixed and spline, bounded by camera zones and altitude bands. Viewpoints that would render nothing usable are rejected before they cost a render.

• Determinism: seed, scene, classes and camera policy are hashed into a configuration snapshot. The same job gives the same dataset, and if anything changed the hash says so.

• Sensors beyond RGB: LiDAR with a configurable ring layout, and a thermal derivation with its modelling limits written down rather than implied.

• Conditions: time of day swept per frame or across a run, and post-process rain and snow overlays, so one scene yields many lightings and weathers. The environment each frame was rendered under is written into its metadata.

What it checks

Quality gates run over the finished dataset and grade it, and the report ships with the data including the checks that failed, not only the ones that passed. Published failure rates for each modality are part of the documentation, because a dataset you cannot audit is a dataset you cannot trust.

What it needs

Unreal Engine 5.8 on Windows 10 or 11 x64, and Visual Studio 2022 or Build Tools 2022 with the C++ workload, because the plugin compiles in your project. Nothing else: the Python runtime the labelling steps need ships inside the plugin and unpacks itself into your project's Intermediate folder on first use, using the interpreter Unreal already carries. No pip, no Git, no internet, and your system Python is untouched.

Who it is for

• Computer-vision engineers who need training data for cases real footage cannot reach: rare events, dangerous scenes, or a camera that does not exist yet.

• Robotics and autonomous-systems teams prototyping perception against repeatable ground truth.

• Researchers who need a corpus they can regenerate exactly, months later, from a seed.

• Anyone whose annotation budget is the bottleneck rather than the modelling.

What it is not

It renders your scenes; it does not ship any. It is not a substitute for real data, and the one published end-to-end experiment we ran trained a detector on synthetic frames alone and lost recall on real drone footage, which is written up with the failure pictures rather than left out. What it is good for is the ground truth annotation cannot produce: exhaustive, machine-checkable labels, including for objects a human annotator cannot see.

Documentation, sample datasets and license terms: getnameframe.com