Population
Choose which objects appear, where they appear, how densely, and which of them belong together. Crowds around a vehicle, crates against a wall, workers where work happens.
- classes
- count / density
- spawn zones
- groups
- relative anchors
Synthetic data studio for Unreal Engine
Turn Unreal worlds into training data.
NameFrame generates synthetic computer vision datasets inside Unreal Engine: deterministic, validated, and derived from the scene rather than guessed at.
Frame the world.Name the frames.
Commercial Preview · UE 5.8 verified
Where ground truth comes from
The world already knows what is in it.
In Unreal Engine, objects already have identities, transforms, geometry and camera relationships. NameFrame turns that scene knowledge into structured ground truth instead of asking a human to reconstruct it afterward.
- 01StaticMeshActor_596
3D Actor
The object already exists in the level, with a class, a transform and geometry.
- 02car / 050
Logical Instance
NameFrame gives it a stable identity that survives weather, time and camera changes.
- 0326,339 px
Pixels
The engine writes an ID buffer, so the instance owns an exact set of pixels.
- 0488, 52, 12, 18
Annotation
The box is measured from those pixels. Occluded instances shrink; hidden ones drop out.
- 0561 m from cam_0
Metadata
Distance, class and instance id ship with the frame, not in a separate spreadsheet.
Traced through one real instance from frame 000004 of the Map_Airbase_Demo capture. Nothing on this list was typed in by hand.
One frame, start to finish
From a scene you built to a dataset you can check.
frame_idplugin_000004
cameracam_0
instances105
classesbarrel, car, container, crate, person, tank
depth_m24.8 – 194.7
resolution1920 × 1080
- SCENE
It starts as a scene, not a photo
Every object in the level is already a known thing with a known position. That is the raw material, and it exists before a single pixel is rendered.
- RGB
The camera renders the frame
A calibrated camera writes the image. Lens, sensor, exposure and weather are all part of the recipe, so the same recipe renders the same frame again.
- INSTANCE IDS
Every instance owns its pixels
Alongside the render, the engine writes a per-instance ID buffer. Two identical crates side by side are still two different instances, because the buffer says so.
- SEGMENTATION
Instances collapse into classes
Ask the same buffer a different question and it answers with classes. No second pass, no model, no guessing which pixel belongs to what.
- BOUNDING BOXES
Boxes are measured, not drawn
Each box comes from the pixels the instance actually holds. An object half behind a hangar gets the smaller box it deserves, and one fully hidden is dropped.
- METADATA
The frame carries its own record
Class, instance id, distance, camera, seed and the full configuration travel with the frame. When a label looks wrong you can go back and see exactly what produced it.
- DATASET
Then it happens a few thousand more times
Change the camera, the population, the weather or the time of day, and the identities hold. That is the difference between a render and a dataset.
Control the world
Don’t collect whatever happens. Generate what you need.
A capture recipe is a description of the conditions you want, not a recording of the conditions you got. Four things are yours to set.
Camera
Set distance, altitude and orientation, or hand over a zone and let it sample within it. Viewpoints that would produce nothing usable are rejected before they cost a render.
- camera zones
- focal length
- sensor size
- altitude band
- look-at bearing
Environment
Move the sun, roll in weather, switch to night. The pixels change completely and the annotation identities do not move at all, which is the whole point.
- time of day
- weather profile
- Ultra Dynamic Sky
- precipitation
- exposure
Appearance
Vary materials, animation state and pose from a seed, so a rerun of the same recipe produces the same variation rather than a new one.
- material sets
- animation state
- pose seed
- lens profile
Spawner
Build distributions, not just scenes.
Placing a hundred objects by hand gives you one scene. Describing how they should be distributed gives you every scene you were going to need after that.
SURFACEPlan view · diagram
Actors are placed across a region and settle on the surface they land on, so nothing floats and nothing sinks into the ground.
54 placements
One frame, more than one image
A generated frame is a structured observation, not just a PNG.
Every capture writes these together. They are aligned by construction, because they come out of the same render rather than being reconciled afterwards.
RGBINSTANCE
DEPTHBBOXTrust
Synthetic data is only useful if you can trust it.
A generated dataset is a claim about a world that never existed. The only thing that makes it worth training on is the evidence that it was produced the way it says it was, and that the labels match the pixels.
- 01seed 67
Deterministic seeds
One master seed drives every placement decision. It is written into the capture and into each frame's own spawn manifest, so a frame can be traced back to the number that produced it.
- 02e940fe63a119
Configuration snapshots
The complete configuration is hashed and stored beside the frames. If the scene, the classes or the camera policy changed, the hash changes with them.
- 037 gates
Fail-closed validation
Gates run against the finished capture and have to pass before it becomes a dataset. A run that fails one stops there rather than exporting something that looks fine.
- 04pixels vs transforms
Annotation verification
Labels are checked against the geometry that produced them: every blob is matched to the actor position it should have come from, and identity colours are checked for collisions.
- 0540 manifests
Reproducible run evidence
Each frame keeps its own manifest, and the manifests are checked against the run index. What was asked for, what was placed and what was refused all stay on disk.
Frame evidence
FRAMEplugin_000004
MAPMap_Airbase_Demo
CONFIGe940fe63a119
MANIFESTf0c3ecffaa0c
SEED67
CAMERAsunlit_far · 8 attempts
STATUSACCEPTED
Verification recorded when this capture was labelled. Quoted as written.
- determinism2 frames labelled twice, byte-identical
- configuration-snapshot-integrityconfiguration snapshot verified (e940fe63a1198cb9abc634330de558b19de566e60ec4c6fa0043b71001110f9e)
- spawn-manifest-integrity40 frame manifests and index agree; 3360 candidates, 0 rejected with reasons
- color-collisions289 colours across 289 classes, no collisions
- pixels-vs-transforms197 blobs match their recorded actor positions
- missing-visible-people3/90 visible people have NO box (3.3% false negatives, likely cross-paint victims): 41, 35, 24
One check did not pass on this run, and the report says so. Three of ninety visible people lost their box to a neighbouring instance’s colour. That is a 3.3% false-negative rate on the person class in this capture, and it is the kind of thing you only find by checking the pixels against the geometry.
Preview
See the dataset before you commit to the run.
A generation run is the expensive part. Everything that can go wrong in one can be found before it starts, so NameFrame puts three cheap steps in front of it instead of a single button that either works or wastes an afternoon.
The preview is a different, smaller run than the Map_Airbase_Demo capture the rest of this page uses. It reports its own seed, health grade and gate result on the same line as the frames, because a preview you cannot judge is only a picture.
Quality
More data is not the same as better data.
Ten thousand frames of the same view from the same distance is one frame, repeated. These are the real distributions of the 40-frame airbase capture this page has been showing, computed from its own buffers and manifests.
- Measured
- 4,402
- Min
- 33.19m
- Median
- 78.87m
- 90th
- 108.06m
- Max
- 187.81m
Every annotated instance, measured from the camera position to the actor's own recorded position. The run's cameras sit in four authored zones, which is why the mass falls between 40 and 120 metres rather than spreading evenly.
Target, actual, gap
Only constraints this run actually declared appear here. A target nobody configured would be a number invented for a table.
| Constraint | Target | Actual | Gap |
|---|---|---|---|
| Minimum spacing between placements | ≥ 1.00 m | 1.00 m | met |
| Viewpoint retries per frame | ≤ 32 | 9 | met |
| Targets visible per accepted frame | ≥ 18 | 73 | met |
| Frames with no annotation | 0 | 0 | met |
Output
Unreal goes in. A dataset comes out.
The engine writes a raw dump and nothing else. Everything a trainer consumes is derived from that dump afterwards, which is why the same run can be re-exported into a different format without going back to the editor.
SourceUNREAL
Map_Airbase_Demo · 40 frames · 1920×1080
On disk
- raw/rgb.png, seg.png, depth.npy per frame
- labels/boxes and masks derived from the ID buffer
- metadata/frame.json, spawn_manifest.json, capture.json
- reports/report.json, validation.json, previews
- dataset.yamlclass names and split paths
Exported
COCOYOLORAW
| Split | Images | Labels | Masks |
|---|---|---|---|
| train | 31 | 31 | 31 |
| val | 9 | 9 | 9 |
| test | 0 | 0 | 0 |
Only the formats this build genuinely writes are listed. The test split is empty on this run because it was exported with a train and validation split only, and an empty split is shown as empty rather than quietly dropped.
Proof
What we can show you, and what we cannot.
Every number on this page came from a run that happened. Each one is followed by what it does not cover, because a claim without its limits is not evidence, and you would find the limits yourself within a week anyway.
590Python regression tests, plus 102 subtests
- What this proves
- The derivation, export, validation, CLI and MCP layers are covered by a suite that runs on every change, on Python 3.11 and 3.12, on Linux and Windows. The run behind this number took 75 seconds and reported no failures.
- What this does not prove
- That the capture itself is correct. These tests run without an engine, against recorded dumps, so they cannot tell you what Unreal renders on your machine.
27/27Unreal Automation tests, UE 5.8
- What this proves
- The native plugin loads in UE 5.8 and its complete NameFrame Automation filter passes headlessly inside a real editor, including Studio, preflight and the spawner's spatial rules. The latest run failed nothing and reported no warnings.
- What this does not prove
- That every map, asset pack and engine build behaves the same. The latest run was on 12 August 2026 against the Golden Pilot project, on one Windows machine; visual D3D12 evidence is documented separately.
50,000Frames in one monitored unattended run
- What this proves
- Capture survives a long run without supervision. Fifty batches, no failed attempts, 600 of 600 raw verification checks passed, resumed cleanly after an interruption, and the combined export validated at grade A.
- What this does not prove
- That you will see the same throughput. That soak ran at 320×240 with depth writing disabled, and peaked at 8.58 GiB of engine memory; a cinematic 1080p scene is a different machine problem.
UE 5.8The engine version this is built and tested against
- What this proves
- The plugin installs into a UE 5.8 project, builds its editor target, and runs. The compatibility record is regenerated from the current source rather than asserted once.
- What this does not prove
- Support for other engine versions. Earlier and later engines are not currently tested, and nothing here claims they work.
PreviewCommercial Preview, not general availability
- What this proves
- NameFrame is being used for real work by a small number of teams, with direct support and a short path from a problem to a fix.
- What this does not prove
- A published price, a support agreement, or a stable public API. Those come later, and pretending otherwise would waste your time and ours.
Have a perception problem that is hard to collect data for?
We are working with a small number of teams during the NameFrame Commercial Preview. If the data you need is dangerous, rare, or simply does not exist yet, that is the conversation we want to have.