Command reference

Every nameframe subcommand, with every flag, its default and its allowed values. This page is generated from the CLI's own argument parser, so it always matches the version you have installed.

Calling convention#

nameframe <command> [arguments]
python -m nameframe.cli <command> [arguments]

Both forms are identical. The second works without installing the console script.

Any command's own help is authoritative:

nameframe generate --help

Reading the tables

Arguments without leading dashes are positional and go in the order shown. Default is what happens when you omit the flag, and a blank default means the flag has no effect unless you pass it. Flags marked required have to be supplied. <value> just means the flag takes a value.

110 commands are available in this build.

Everyday pipeline#

The commands you use on almost every run. generate is the one-liner; the rest are the same stages exposed individually.

Command	Purpose
`generate`	headless one-command dump -> report/dataset/validate
`run`	resumable offline pipeline over a dump (verify/label/report/dataset/validate) with autosave and --resume
`demo-dump`	generate a self-contained synthetic dump (no Unreal)
`verify`	run pre-flight checks on a dump
`label`	derive YOLO labels from a raw dump
`report`	write a JSON summary and lightweight HTML viewer for a dump
`dataset`	assemble labelled dumps into a YOLO train/val/test dataset
`validate`	validate an assembled YOLO/COCO dataset and score it
`dataset-inspect`	write a dataset inspector and sample browser
`info`	summarise a dump
`compare`	compare derived labels against a reference capture

nameframe generate

headless one-command dump -> report/dataset/validate

nameframe generate [-h] (--demo | --dump DUMP | --job JOB | --scenario SCENARIO) [--scene-manifest SCENE_MANIFEST] [--target-samples TARGET_SAMPLES] [--job-id JOB_ID] [--capture-width CAPTURE_WIDTH] [--capture-height CAPTURE_HEIGHT] --output OUTPUT [--samples SAMPLES] [--seed SEED] [--avatars AVATARS] [--resume] [--no-verify] [--report-preview-limit REPORT_PREVIEW_LIMIT] [--lens-profile LENS_PROFILE] [--lens-intensity LENS_INTENSITY] [--lens-profile-weights LENS_PROFILE_WEIGHTS] [--report-show-clean-images] [--report-show-segmentation] [--dataset-task {box,pose}] [--dataset-format DATASET_FORMAT] [--dataset-val-frac DATASET_VAL_FRAC] [--dataset-test-frac DATASET_TEST_FRAC] [--dataset-split-strategy {hash,by_dump,sequential}] [--dataset-coco-exports DATASET_COCO_EXPORTS] [--dataset-filter-min-instances DATASET_FILTER_MIN_INSTANCES] [--dataset-filter-max-instances DATASET_FILTER_MAX_INSTANCES] [--dataset-filter-include-classes DATASET_FILTER_INCLUDE_CLASSES] [--dataset-filter-require-classes DATASET_FILTER_REQUIRE_CLASSES] [--dataset-filter-exclude-classes DATASET_FILTER_EXCLUDE_CLASSES] [--include-clean-images] [--include-segmentation] [--fail-under FAIL_UNDER] [--inspect] [--inspect-sample-limit INSPECT_SAMPLE_LIMIT] [--remote-url REMOTE_URL] [--world-context WORLD_CONTEXT] [--timeout TIMEOUT] [--compile]

Argument	What it does	Default
`--demo`	generate a local procedural demo dump first	off
`--dump <value>`	use an existing raw dump
`--job <value>`	capture an Unreal job through Remote Control first
`--scenario <value>`	compile ScenarioConfig JSON and capture it through Remote Control
`--scene-manifest <value>`	SceneManifest JSON required with --scenario
`--target-samples <value>`	override ScenarioConfig generation sample count
`--job-id <value>`	safe execution ID for a compiled ScenarioConfig
`--capture-width <value>`		`320`
`--capture-height <value>`		`240`
`--output <value>` required	output root for dump/report/dataset/validation/inspector
`--samples <value>`	number of demo frames for --demo	`200`
`--seed <value>`	demo seed for --demo	`7`
`--avatars <value>`	number of demo avatars for --demo	`6`
`--resume`	resume capture/pipeline when existing artifacts match	off
`--no-verify`		off
`--report-preview-limit <value>`		`12`
`--lens-profile <value>`		`none`
`--lens-intensity <value>`		`1.0`
`--lens-profile-weights <value>`
`--report-show-clean-images`		off
`--report-show-segmentation`		off
`--dataset-task <value>` choices: `box`, `pose`		`box`
`--dataset-format <value>`	comma-separated: yolo,coco	`yolo,coco`
`--dataset-val-frac <value>`		`0.2`
`--dataset-test-frac <value>`		`0.0`
`--dataset-split-strategy <value>` choices: `hash`, `by_dump`, `sequential`		`hash`
`--dataset-coco-exports <value>`
`--dataset-filter-min-instances <value>`
`--dataset-filter-max-instances <value>`
`--dataset-filter-include-classes <value>`
`--dataset-filter-require-classes <value>`
`--dataset-filter-exclude-classes <value>`
`--include-clean-images`		off
`--include-segmentation`		off
`--fail-under <value>`
`--inspect`	write dataset inspector/sample browser after validation	off
`--inspect-sample-limit <value>`		`12`
`--remote-url <value>`		`http://127.0.0.1:30010`
`--world-context <value>`		empty
`--timeout <value>`		`600.0`
`--compile`		off

nameframe run

resumable offline pipeline over a dump (verify/label/report/dataset/validate) with autosave and --resume

nameframe run [-h] [--state STATE] [--resume] [--verify] [--label-out LABEL_OUT] [--label-kinds LABEL_KINDS] [--report-out REPORT_OUT] [--report-preview-limit REPORT_PREVIEW_LIMIT] [--lens-profile LENS_PROFILE] [--lens-intensity LENS_INTENSITY] [--lens-profile-weights LENS_PROFILE_WEIGHTS] [--report-show-clean-images] [--report-show-segmentation] [--dataset-out DATASET_OUT] [--dataset-task {box,pose}] [--dataset-format DATASET_FORMAT] [--dataset-val-frac DATASET_VAL_FRAC] [--dataset-test-frac DATASET_TEST_FRAC] [--dataset-split-strategy {hash,by_dump,sequential}] [--dataset-coco-exports DATASET_COCO_EXPORTS] [--dataset-filter-min-instances DATASET_FILTER_MIN_INSTANCES] [--dataset-filter-max-instances DATASET_FILTER_MAX_INSTANCES] [--dataset-filter-include-classes DATASET_FILTER_INCLUDE_CLASSES] [--dataset-filter-require-classes DATASET_FILTER_REQUIRE_CLASSES] [--dataset-filter-exclude-classes DATASET_FILTER_EXCLUDE_CLASSES] [--include-clean-images] [--include-segmentation] [--validate-out VALIDATE_OUT] [--fail-under FAIL_UNDER] dump

Argument	What it does	Default
`dump`required
`--state <value>`	state file (default <dump>/job_state.json)
`--resume`	skip steps already done unchanged	off
`--verify`		off
`--label-out <value>`
`--label-kinds <value>`	comma list of box,seg,pose
`--report-out <value>`
`--report-preview-limit <value>`		`12`
`--lens-profile <value>`		`none`
`--lens-intensity <value>`		`1.0`
`--lens-profile-weights <value>`	for --lens-profile random: profile:weight,profile:weight
`--report-show-clean-images`		off
`--report-show-segmentation`		off
`--dataset-out <value>`
`--dataset-task <value>` choices: `box`, `pose`		`box`
`--dataset-format <value>`	comma-separated: yolo, coco	`yolo`
`--dataset-val-frac <value>`		`0.2`
`--dataset-test-frac <value>`		`0.0`
`--dataset-split-strategy <value>` choices: `hash`, `by_dump`, `sequential`		`hash`
`--dataset-coco-exports <value>`	for --dataset-format coco: instances, person_keypoints, or all
`--dataset-filter-min-instances <value>`
`--dataset-filter-max-instances <value>`
`--dataset-filter-include-classes <value>`
`--dataset-filter-require-classes <value>`
`--dataset-filter-exclude-classes <value>`
`--include-clean-images`		off
`--include-segmentation`		off
`--validate-out <value>`
`--fail-under <value>`

nameframe demo-dump

generate a self-contained synthetic dump (no Unreal)

nameframe demo-dump [-h] [--frames FRAMES] [--seed SEED] [--avatars AVATARS] out

Argument	What it does	Default
`out`required
`--frames <value>`		`16`
`--seed <value>`		`7`
`--avatars <value>`		`6`

nameframe verify

run pre-flight checks on a dump

nameframe verify [-h] dump

Argument	What it does	Default
`dump`required

nameframe label

derive YOLO labels from a raw dump

nameframe label [-h] [--kinds KINDS] dump out

Argument	What it does	Default
`dump`required
`out`required
`--kinds <value>`	comma list of box,seg,pose (default all)

nameframe report

write a JSON summary and lightweight HTML viewer for a dump

nameframe report [-h] [--preview-limit PREVIEW_LIMIT] [--no-verify] [--lens-profile LENS_PROFILE] [--lens-intensity LENS_INTENSITY] [--lens-profile-weights LENS_PROFILE_WEIGHTS] [--show-clean-images] [--show-segmentation] [--precipitation] [--precipitation-strength PRECIPITATION_STRENGTH] [--fail-on-quality] dump out

Argument	What it does	Default
`dump`required
`out`required
`--preview-limit <value>`		`12`
`--no-verify`	skip verify checks in the report	off
`--lens-profile <value>`	render preview with a camera lens profile	`none`
`--lens-intensity <value>`		`1.0`
`--lens-profile-weights <value>`	for --lens-profile random: profile:weight,profile:weight
`--show-clean-images, --show-clean`	include clean RGB images as a toggleable report layer	off
`--show-segmentation, --show-seg`	include segmentation masks as a toggleable report layer	off
`--precipitation, --precip`	composite rain/snow particles for weather frames (UDS/UDW GPU particles do not render in editor scene captures)	off
`--precipitation-strength, --precip-strength <value>`	scale the rain/snow overlay density (default 1.0)	`1.0`
`--fail-on-quality`	return non-zero if report quality gates fail	off

nameframe dataset

assemble labelled dumps into a YOLO train/val/test dataset

nameframe dataset [-h] [--task {box,pose}] [--format FORMAT] [--val-frac VAL_FRAC] [--test-frac TEST_FRAC] [--split-strategy {hash,by_dump,sequential}] [--coco-exports COCO_EXPORTS] [--lens-profile LENS_PROFILE] [--lens-intensity LENS_INTENSITY] [--lens-profile-weights LENS_PROFILE_WEIGHTS] [--include-clean-images] [--include-segmentation] [--precipitation] [--precipitation-strength PRECIPITATION_STRENGTH] [--filter-min-instances FILTER_MIN_INSTANCES] [--filter-max-instances FILTER_MAX_INSTANCES] [--filter-include-classes FILTER_INCLUDE_CLASSES] [--filter-require-classes FILTER_REQUIRE_CLASSES] [--filter-exclude-classes FILTER_EXCLUDE_CLASSES] dumps out

Argument	What it does	Default
`dumps`required	comma-separated dump dirs
`out`required
`--task <value>` choices: `box`, `pose`		`box`
`--format <value>`	comma-separated: yolo, coco, or both (e.g. yolo,coco)	`yolo`
`--val-frac <value>`		`0.2`
`--test-frac <value>`		`0.0`
`--split-strategy <value>` choices: `hash`, `by_dump`, `sequential`	hash per frame, hold out whole dumps, or ordered sequential blocks	`hash`
`--coco-exports <value>`	for --format coco: instances, person_keypoints, or all
`--lens-profile <value>`	camera look for images/: none, random (weighted mix), or a named profile e.g. realistic_drone, dashcam, cctv, bodycam, phone_camera, rainy_lens, golden_hour, harsh_noon, night_street, night_vision, thermal_white_hot, sepia_vintage, cold_cine, action_cam, vhs_analog, cheap_webcam, underexposed_noise	`none`
`--lens-intensity <value>`	lens strength; 0 keeps images clean, 1 is normal, up to 2 is strong	`1.0`
`--lens-profile-weights <value>`	for --lens-profile random: profile:weight,profile:weight
`--include-clean-images`	also write clean_images/{train,val,test} from the original RGB	off
`--include-segmentation`	also write segmentation/{train,val,test} masks	off
`--precipitation, --precip`	composite rain/snow particles for weather frames (UDS/UDW GPU particles do not render in editor scene captures)	off
`--precipitation-strength, --precip-strength <value>`	scale the rain/snow overlay density (default 1.0)	`1.0`
`--filter-min-instances <value>`	skip frames with fewer kept instances after labelling QA
`--filter-max-instances <value>`	skip frames with more kept instances after labelling QA
`--filter-include-classes <value>`	comma-separated classes; keep frames with at least one of them
`--filter-require-classes <value>`	comma-separated classes; keep only frames containing all of them
`--filter-exclude-classes <value>`	comma-separated classes; skip frames containing any of them

nameframe validate

validate an assembled YOLO/COCO dataset and score it

nameframe validate [-h] [--out OUT] [--format FORMAT] [--fail-under FAIL_UNDER] [--near-duplicate-hamming 0..16] dataset

Argument	What it does	Default
`dataset`required	assembled dataset dir (has data.yaml and/or annotations/)
`--out <value>`	write validation.json + validation.html here
`--format <value>`	comma-separated: yolo, coco (default: auto-detect)
`--fail-under <value>`	exit non-zero if the quality score is below this
`--near-duplicate-hamming 0..16` choices: `0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `10`, `11`, `12`, `13`, `14`, `15`, `16`	perceptual dHash distance for near-duplicate/leakage checks	`4`

nameframe dataset-inspect

write a dataset inspector and sample browser

nameframe dataset-inspect [-h] [--sample-limit SAMPLE_LIMIT] [--format FORMAT] [--no-validate] dataset out

Argument	What it does	Default
`dataset`required	assembled dataset dir
`out`required	output folder for inspector.json and index.html
`--sample-limit <value>`		`80`
`--format <value>`	comma-separated: yolo, coco
`--no-validate`	skip validation and only browse manifest/samples	off

nameframe info

summarise a dump

nameframe info [-h] dump

Argument	What it does	Default
`dump`required

nameframe compare

compare derived labels against a reference capture

nameframe compare [-h] [--kinds KINDS] derived reference

Argument	What it does	Default
`derived`required
`reference`required
`--kinds <value>`		`box,seg`

Unreal capture and live control#

These talk to an open Unreal editor over Remote Control (default http://127.0.0.1:30010). Unreal must be running with the NameFrameCapture plugin and the Remote Control API enabled.

Command	Purpose
`capture-unreal`	run an NameFrameCapture job in an open Unreal editor
`scene-unreal`	scan the active Unreal world and emit SceneManifest v1 JSON
`scene-validate`	validate SceneManifest v1 JSON and derive class registry
`generation-plan`	validate scenario+scene and write deterministic sample plan
`live-smoke`	author and test a small live scene in an open Unreal editor
`live-soak`	run a large live Unreal proof in resumable capture batches
`viewpoint-calibrate`	recommend Smart Viewpoint thresholds from captured frame metadata
`dump-fresh-start`	archive prior raw artifacts before a new capture run
`spawn-manifests`	finalize native placement outcomes into per-frame spawn manifests
`import-airsim`	convert a legacy AirSim capture into a raw dump

nameframe capture-unreal

run an NameFrameCapture job in an open Unreal editor

nameframe capture-unreal [-h] [--remote-url REMOTE_URL] [--world-context WORLD_CONTEXT] [--timeout TIMEOUT] [--no-wait] [--resume] [--compile] [--verify] [--label-out LABEL_OUT] [--label-kinds LABEL_KINDS] [--report-out REPORT_OUT] [--report-preview-limit REPORT_PREVIEW_LIMIT] [--lens-profile LENS_PROFILE] [--lens-intensity LENS_INTENSITY] [--lens-profile-weights LENS_PROFILE_WEIGHTS] [--report-show-clean-images] [--report-show-segmentation] [--precipitation] [--precipitation-strength PRECIPITATION_STRENGTH] [--fail-on-quality] [--dataset-out DATASET_OUT] [--dataset-task {box,pose}] [--dataset-format DATASET_FORMAT] [--dataset-val-frac DATASET_VAL_FRAC] [--dataset-test-frac DATASET_TEST_FRAC] [--dataset-split-strategy {hash,by_dump,sequential}] [--dataset-coco-exports DATASET_COCO_EXPORTS] [--dataset-filter-min-instances DATASET_FILTER_MIN_INSTANCES] [--dataset-filter-max-instances DATASET_FILTER_MAX_INSTANCES] [--dataset-filter-include-classes DATASET_FILTER_INCLUDE_CLASSES] [--dataset-filter-require-classes DATASET_FILTER_REQUIRE_CLASSES] [--dataset-filter-exclude-classes DATASET_FILTER_EXCLUDE_CLASSES] [--include-clean-images] [--include-segmentation] [--validate-out VALIDATE_OUT] [--fail-under FAIL_UNDER] job

Argument	What it does	Default
`job`required
`--remote-url <value>`		`http://127.0.0.1:30010`
`--world-context <value>`	optional actor path; needed only for --compile or legacy console fallback	empty
`--timeout <value>`		`600.0`
`--no-wait`		off
`--resume`	skip capture if the dump already has all frames	off
`--compile`	run LiveCoding.CompileSync before capture	off
`--verify`	run verify after capture finishes	off
`--label-out <value>`	derive labels into this directory after capture
`--label-kinds <value>`	comma list of box,seg,pose for --label-out
`--report-out <value>`	write a dataset report after capture
`--report-preview-limit <value>`		`12`
`--lens-profile <value>`		`none`
`--lens-intensity <value>`		`1.0`
`--lens-profile-weights <value>`	for --lens-profile random: profile:weight,profile:weight
`--report-show-clean-images`		off
`--report-show-segmentation`		off
`--precipitation, --precip`	composite rain/snow particles into report + dataset images for weather frames (UDS/UDW GPU particles do not render in captures)	off
`--precipitation-strength, --precip-strength <value>`	scale the rain/snow overlay density (default 1.0)	`1.0`
`--fail-on-quality`	return non-zero if report quality gates fail	off
`--dataset-out <value>`	assemble a dataset after capture
`--dataset-task <value>` choices: `box`, `pose`		`box`
`--dataset-format <value>`	comma-separated: yolo, coco, or both	`yolo`
`--dataset-val-frac <value>`		`0.2`
`--dataset-test-frac <value>`		`0.0`
`--dataset-split-strategy <value>` choices: `hash`, `by_dump`, `sequential`		`hash`
`--dataset-coco-exports <value>`	for --dataset-format coco: instances, person_keypoints, or all
`--dataset-filter-min-instances <value>`	dataset export: skip frames with fewer kept instances
`--dataset-filter-max-instances <value>`	dataset export: skip frames with more kept instances
`--dataset-filter-include-classes <value>`	dataset export: keep frames with at least one listed class
`--dataset-filter-require-classes <value>`	dataset export: keep only frames containing every listed class
`--dataset-filter-exclude-classes <value>`	dataset export: skip frames containing any listed class
`--include-clean-images`		off
`--include-segmentation`		off
`--validate-out <value>`	validate the assembled dataset and write a quality report here
`--fail-under <value>`	return non-zero if the dataset quality score is below this

nameframe scene-unreal

scan the active Unreal world and emit SceneManifest v1 JSON

nameframe scene-unreal [-h] [--remote-url REMOTE_URL] [--timeout TIMEOUT] [--out OUT]

Argument	What it does	Default
`--remote-url <value>`		`http://127.0.0.1:30010`
`--timeout <value>`		`30.0`
`--out <value>`	write manifest JSON to this path instead of stdout

nameframe scene-validate

validate SceneManifest v1 JSON and derive class registry

nameframe scene-validate [-h] [--out OUT] [--generation-ready] scene

Argument	What it does	Default
`scene`required	scene_manifest.json
`--out <value>`	write validation JSON to this path
`--generation-ready`	fail if the scene lacks classes, spawn zones, camera zones, or cameras	off

nameframe generation-plan

validate scenario+scene and write deterministic sample plan

nameframe generation-plan [-h] [--samples SAMPLES] [--start-index START_INDEX] [--out OUT] scenario scene

Argument	What it does	Default
`scenario`required	ScenarioConfig v1 JSON
`scene`required	SceneManifest v1 JSON
`--samples <value>`	override sample count from scenario generation/output settings
`--start-index <value>`		`0`
`--out <value>`	write plan JSON to this path instead of stdout

nameframe live-smoke

author and test a small live scene in an open Unreal editor

nameframe live-smoke [-h] [--remote-url REMOTE_URL] [--out-root OUT_ROOT] [--timeout TIMEOUT] [--no-author] [--frames FRAMES] [--samples SAMPLES] [--width WIDTH] [--height HEIGHT] [--no-dataset]

Argument	What it does	Default
`--remote-url <value>`		`http://127.0.0.1:30010`
`--out-root <value>`	directory for manifest, capture, labels, report, and dataset artifacts	`_local/smoke/live_smoke`
`--timeout <value>`		`180.0`
`--no-author`	skip Unreal Python scene authoring and test the active scene as-is	off
`--frames <value>`		`1`
`--samples <value>`	number of deterministic planning rows to write	`5`
`--width <value>`		`320`
`--height <value>`		`240`
`--no-dataset`	skip report-to-dataset export/validation after capture	off

nameframe live-soak

run a large live Unreal proof in resumable capture batches

nameframe live-soak [-h] [--remote-url REMOTE_URL] [--out-root OUT_ROOT] [--frames FRAMES] [--batch-frames BATCH_FRAMES] [--seed SEED] [--width WIDTH] [--height HEIGHT] [--depth | --no-depth] [--timeout TIMEOUT] [--resume] [--stop-after-batches STOP_AFTER_BATCHES] [--unreal-pid UNREAL_PID] [--telemetry-interval TELEMETRY_INTERVAL] [--no-author]

Argument	What it does	Default
`--remote-url <value>`		`http://127.0.0.1:30010`
`--out-root <value>`		`_local/live_soak`
`--frames <value>`	total frame count across all batches	`10000`
`--batch-frames <value>`	maximum frames sent to Unreal in one capture request	`1000`
`--seed <value>`		`30010`
`--width <value>`		`320`
`--height <value>`		`240`
`--depth, --no-depth <value>`	write depth.npy for each frame (disable for lower-storage resource soaks)	on
`--timeout <value>`	timeout in seconds for each Unreal batch	`3600.0`
`--resume`	reuse completed batches from live_soak_state.json	off
`--stop-after-batches <value>`	stop cleanly after this many newly completed batches
`--unreal-pid <value>`	sample this Unreal process working set (required for 50k release soak)
`--telemetry-interval <value>`	seconds between process-memory samples (default: 0.25)	`0.25`
`--no-author`	do not rebuild the native smoke scene before scanning	off

nameframe viewpoint-calibrate

recommend Smart Viewpoint thresholds from captured frame metadata

nameframe viewpoint-calibrate [-h] --out OUT [--lower-percentile LOWER_PERCENTILE] [--upper-percentile UPPER_PERCENTILE] [--safety-margin SAFETY_MARGIN] [--include-rejected] dumps [dumps ...]

Argument	What it does	Default
`dumps`required	one or more NameFrame raw dump directories
`--out <value>` required	calibration JSON output path
`--lower-percentile <value>`		`5.0`
`--upper-percentile <value>`		`95.0`
`--safety-margin <value>`	fractional margin applied outside observed percentile thresholds	`0.05`
`--include-rejected`		off

nameframe dump-fresh-start

archive prior raw artifacts before a new capture run

nameframe dump-fresh-start [-h] out_dir

Argument	What it does	Default
`out_dir`required

nameframe spawn-manifests

finalize native placement outcomes into per-frame spawn manifests

nameframe spawn-manifests [-h] [--seed SEED] dump

Argument	What it does	Default
`dump`required
`--seed <value>`	master seed (defaults to capture spawn-manifest metadata or zero)

nameframe import-airsim

convert a legacy AirSim capture into a raw dump

nameframe import-airsim [-h] src dst

Argument	What it does	Default
`src`required
`dst`required

Studio recipes and presets#

Compile, validate, preview and template the user-facing Studio YAML recipe before spending render time.

Command	Purpose
`studio-compile`	compile a user-facing studio job to a plugin capture job
`studio-validate`	validate a Studio recipe before running Unreal
`studio-dry-run`	write a planned frame table without running Unreal
`studio-ui-state`	emit JSON values for hydrating the Unreal Studio panel
`studio-postprocess`	run Studio verify/report/dataset stages with progress
`prepare-job`	compile/copy a job and apply runtime capture overrides
`presets`	write a JSON/HTML gallery for Studio preset YAML files
`preset-new`	create an editable Studio YAML preset
`distribution-preview`	sample a distribution spec and write JSON+SVG preview

nameframe studio-compile

compile a user-facing studio job to a plugin capture job

nameframe studio-compile [-h] [--scene-manifest SCENE_MANIFEST] [--output-root OUTPUT_ROOT] [--result RESULT] [--job-id JOB_ID] [--target-samples TARGET_SAMPLES] [--width WIDTH] [--height HEIGHT] src dst

Argument	What it does	Default
`src`required
`dst`required
`--scene-manifest <value>`	treat src as ScenarioConfig and compile through the canonical path
`--output-root <value>`
`--result <value>`	canonical compilation evidence JSON
`--job-id <value>`
`--target-samples <value>`
`--width <value>`		`320`
`--height <value>`		`240`

nameframe studio-validate

validate a Studio recipe before running Unreal

nameframe studio-validate [-h] [--out OUT] [--valid-viewpoints-only | --no-valid-viewpoints-only] [--viewpoint-min-targets VIEWPOINT_MIN_TARGETS] [--viewpoint-max-targets VIEWPOINT_MAX_TARGETS] [--viewpoint-min-visible-percent VIEWPOINT_MIN_VISIBLE_PERCENT] [--viewpoint-min-bbox-width VIEWPOINT_MIN_BBOX_WIDTH] [--viewpoint-min-bbox-height VIEWPOINT_MIN_BBOX_HEIGHT] [--viewpoint-min-camera-distance VIEWPOINT_MIN_CAMERA_DISTANCE] [--viewpoint-max-camera-distance VIEWPOINT_MAX_CAMERA_DISTANCE] [--viewpoint-max-retries VIEWPOINT_MAX_RETRIES] [--viewpoint-require-fully-visible | --no-viewpoint-require-fully-visible] [--viewpoint-reject-camera-collision | --no-viewpoint-reject-camera-collision] [--viewpoint-reject-under-landscape | --no-viewpoint-reject-under-landscape] [--viewpoint-reject-empty-segmentation | --no-viewpoint-reject-empty-segmentation] [--viewpoint-min-segmentation-coverage-percent VIEWPOINT_MIN_SEGMENTATION_COVERAGE_PERCENT] [--viewpoint-reject-invalid-depth | --no-viewpoint-reject-invalid-depth] [--viewpoint-reject-blur | --no-viewpoint-reject-blur] [--viewpoint-reject-exposure | --no-viewpoint-reject-exposure] [--viewpoint-min-depth-valid-percent VIEWPOINT_MIN_DEPTH_VALID_PERCENT] [--viewpoint-min-focus-score VIEWPOINT_MIN_FOCUS_SCORE] [--viewpoint-min-mean-luma VIEWPOINT_MIN_MEAN_LUMA] [--viewpoint-max-mean-luma VIEWPOINT_MAX_MEAN_LUMA] [--viewpoint-fallback {continue,skip_frame,stop_job,relax_constraints}] [--performance-profile {safe,balanced,fast,custom}] [--render-quality {standard,cinematic}] [--write-depth | --no-write-depth] [--use-ray-tracing-if-enabled | --no-use-ray-tracing-if-enabled] [--precompile-assets | --no-precompile-assets] [--warm-target-shaders | --no-warm-target-shaders] [--stream-all-resources | --no-stream-all-resources] [--force-target-textures-resident | --no-force-target-textures-resident] [--settle-weather-on-change-only | --no-settle-weather-on-change-only] [--dynamic-weather-replay | --no-dynamic-weather-replay] [--cull-id-targets-outside-view | --no-cull-id-targets-outside-view] [--group-id-targets | --no-group-id-targets] [--declare-camera-cut | --no-declare-camera-cut] [--collect-frame-timings | --no-collect-frame-timings] [--rgb-antialiasing | --no-rgb-antialiasing] [--rgb-bloom | --no-rgb-bloom] [--rgb-global-illumination | --no-rgb-global-illumination] [--rgb-lumen | --no-rgb-lumen] [--rgb-shadows | --no-rgb-shadows] [--rgb-reflections | --no-rgb-reflections] [--rgb-volumetrics | --no-rgb-volumetrics] [--rgb-particles | --no-rgb-particles] [--rgb-translucency | --no-rgb-translucency] [--streaming-timeout-seconds STREAMING_TIMEOUT_SECONDS] [--initial-warmup-frames INITIAL_WARMUP_FRAMES] [--weather-batch-frames WEATHER_BATCH_FRAMES] [--weather-warmup-frames WEATHER_WARMUP_FRAMES] [--camera-warmup-frames CAMERA_WARMUP_FRAMES] [--progress-interval-frames PROGRESS_INTERVAL_FRAMES] [--frames FRAMES] [--seed SEED] [--out-dir OUT_DIR] [--width WIDTH] [--height HEIGHT] [--camera-mode {orbit,drone,random,fixed,spline}] [--look-at {target,random_point,free}] [--camera-distance CAMERA_DISTANCE] [--camera-altitude CAMERA_ALTITUDE] [--fov FOV] [--pitch PITCH] [--yaw YAW] [--roll ROLL] [--near-clip-cm NEAR_CLIP_CM] [--far-clip-cm FAR_CLIP_CM] [--export-intrinsics] [--fixed-camera-position FIXED_CAMERA_POSITION] [--fixed-camera-rotation FIXED_CAMERA_ROTATION] [--fixed-camera-actor FIXED_CAMERA_ACTOR] [--flight-path FLIGHT_PATH] [--scatter-existing-targets | --no-scatter-existing-targets] [--shuffle-per-frame | --no-shuffle-per-frame] [--weather WEATHER] [--weather-driver {builtin,ultra_dynamic}] [--weather-weights WEATHER_WEIGHTS] [--uds-actor UDS_ACTOR] [--uds-params UDS_PARAMS] [--udw-actor UDW_ACTOR] [--udw-params UDW_PARAMS] [--weather-settle-seconds WEATHER_SETTLE_SECONDS] src

Argument	What it does	Default
`src`required	Studio YAML or compiled capture JSON
`--out <value>`	optional validation JSON path
`--valid-viewpoints-only, --no-valid-viewpoints-only <value>`
`--viewpoint-min-targets <value>`
`--viewpoint-max-targets <value>`
`--viewpoint-min-visible-percent <value>`
`--viewpoint-min-bbox-width <value>`
`--viewpoint-min-bbox-height <value>`
`--viewpoint-min-camera-distance <value>`
`--viewpoint-max-camera-distance <value>`
`--viewpoint-max-retries <value>`
`--viewpoint-require-fully-visible, --no-viewpoint-require-fully-visible <value>`
`--viewpoint-reject-camera-collision, --no-viewpoint-reject-camera-collision <value>`
`--viewpoint-reject-under-landscape, --no-viewpoint-reject-under-landscape <value>`
`--viewpoint-reject-empty-segmentation, --no-viewpoint-reject-empty-segmentation <value>`
`--viewpoint-min-segmentation-coverage-percent <value>`
`--viewpoint-reject-invalid-depth, --no-viewpoint-reject-invalid-depth <value>`
`--viewpoint-reject-blur, --no-viewpoint-reject-blur <value>`
`--viewpoint-reject-exposure, --no-viewpoint-reject-exposure <value>`
`--viewpoint-min-depth-valid-percent <value>`
`--viewpoint-min-focus-score <value>`
`--viewpoint-min-mean-luma <value>`
`--viewpoint-max-mean-luma <value>`
`--viewpoint-fallback <value>` choices: `continue`, `skip_frame`, `stop_job`, `relax_constraints`
`--performance-profile <value>` choices: `safe`, `balanced`, `fast`, `custom`
`--render-quality <value>` choices: `standard`, `cinematic`
`--write-depth, --no-write-depth <value>`
`--use-ray-tracing-if-enabled, --no-use-ray-tracing-if-enabled <value>`
`--precompile-assets, --no-precompile-assets <value>`
`--warm-target-shaders, --no-warm-target-shaders <value>`
`--stream-all-resources, --no-stream-all-resources <value>`
`--force-target-textures-resident, --no-force-target-textures-resident <value>`
`--settle-weather-on-change-only, --no-settle-weather-on-change-only <value>`
`--dynamic-weather-replay, --no-dynamic-weather-replay <value>`
`--cull-id-targets-outside-view, --no-cull-id-targets-outside-view <value>`
`--group-id-targets, --no-group-id-targets <value>`
`--declare-camera-cut, --no-declare-camera-cut <value>`
`--collect-frame-timings, --no-collect-frame-timings <value>`
`--rgb-antialiasing, --no-rgb-antialiasing <value>`
`--rgb-bloom, --no-rgb-bloom <value>`
`--rgb-global-illumination, --no-rgb-global-illumination <value>`
`--rgb-lumen, --no-rgb-lumen <value>`
`--rgb-shadows, --no-rgb-shadows <value>`
`--rgb-reflections, --no-rgb-reflections <value>`
`--rgb-volumetrics, --no-rgb-volumetrics <value>`
`--rgb-particles, --no-rgb-particles <value>`
`--rgb-translucency, --no-rgb-translucency <value>`
`--streaming-timeout-seconds <value>`
`--initial-warmup-frames <value>`
`--weather-batch-frames <value>`
`--weather-warmup-frames <value>`
`--camera-warmup-frames <value>`
`--progress-interval-frames <value>`
`--frames <value>`
`--seed <value>`
`--out-dir <value>`
`--width <value>`
`--height <value>`
`--camera-mode <value>` choices: `orbit`, `drone`, `random`, `fixed`, `spline`
`--look-at <value>` choices: `target`, `random_point`, `free`
`--camera-distance <value>`
`--camera-altitude <value>`
`--fov <value>`
`--pitch <value>`
`--yaw <value>`
`--roll <value>`
`--near-clip-cm <value>`
`--far-clip-cm <value>`
`--export-intrinsics`		off
`--fixed-camera-position <value>`
`--fixed-camera-rotation <value>`
`--fixed-camera-actor <value>`
`--flight-path <value>`
`--scatter-existing-targets, --no-scatter-existing-targets <value>`
`--shuffle-per-frame, --no-shuffle-per-frame <value>`
`--weather <value>`
`--weather-driver <value>` choices: `builtin`, `ultra_dynamic`
`--weather-weights <value>`
`--uds-actor <value>`
`--uds-params <value>`
`--udw-actor <value>`
`--udw-params <value>`
`--weather-settle-seconds <value>`

nameframe studio-dry-run

write a planned frame table without running Unreal

nameframe studio-dry-run [-h] [--valid-viewpoints-only | --no-valid-viewpoints-only] [--viewpoint-min-targets VIEWPOINT_MIN_TARGETS] [--viewpoint-max-targets VIEWPOINT_MAX_TARGETS] [--viewpoint-min-visible-percent VIEWPOINT_MIN_VISIBLE_PERCENT] [--viewpoint-min-bbox-width VIEWPOINT_MIN_BBOX_WIDTH] [--viewpoint-min-bbox-height VIEWPOINT_MIN_BBOX_HEIGHT] [--viewpoint-min-camera-distance VIEWPOINT_MIN_CAMERA_DISTANCE] [--viewpoint-max-camera-distance VIEWPOINT_MAX_CAMERA_DISTANCE] [--viewpoint-max-retries VIEWPOINT_MAX_RETRIES] [--viewpoint-require-fully-visible | --no-viewpoint-require-fully-visible] [--viewpoint-reject-camera-collision | --no-viewpoint-reject-camera-collision] [--viewpoint-reject-under-landscape | --no-viewpoint-reject-under-landscape] [--viewpoint-reject-empty-segmentation | --no-viewpoint-reject-empty-segmentation] [--viewpoint-min-segmentation-coverage-percent VIEWPOINT_MIN_SEGMENTATION_COVERAGE_PERCENT] [--viewpoint-reject-invalid-depth | --no-viewpoint-reject-invalid-depth] [--viewpoint-reject-blur | --no-viewpoint-reject-blur] [--viewpoint-reject-exposure | --no-viewpoint-reject-exposure] [--viewpoint-min-depth-valid-percent VIEWPOINT_MIN_DEPTH_VALID_PERCENT] [--viewpoint-min-focus-score VIEWPOINT_MIN_FOCUS_SCORE] [--viewpoint-min-mean-luma VIEWPOINT_MIN_MEAN_LUMA] [--viewpoint-max-mean-luma VIEWPOINT_MAX_MEAN_LUMA] [--viewpoint-fallback {continue,skip_frame,stop_job,relax_constraints}] [--performance-profile {safe,balanced,fast,custom}] [--render-quality {standard,cinematic}] [--write-depth | --no-write-depth] [--use-ray-tracing-if-enabled | --no-use-ray-tracing-if-enabled] [--precompile-assets | --no-precompile-assets] [--warm-target-shaders | --no-warm-target-shaders] [--stream-all-resources | --no-stream-all-resources] [--force-target-textures-resident | --no-force-target-textures-resident] [--settle-weather-on-change-only | --no-settle-weather-on-change-only] [--dynamic-weather-replay | --no-dynamic-weather-replay] [--cull-id-targets-outside-view | --no-cull-id-targets-outside-view] [--group-id-targets | --no-group-id-targets] [--declare-camera-cut | --no-declare-camera-cut] [--collect-frame-timings | --no-collect-frame-timings] [--rgb-antialiasing | --no-rgb-antialiasing] [--rgb-bloom | --no-rgb-bloom] [--rgb-global-illumination | --no-rgb-global-illumination] [--rgb-lumen | --no-rgb-lumen] [--rgb-shadows | --no-rgb-shadows] [--rgb-reflections | --no-rgb-reflections] [--rgb-volumetrics | --no-rgb-volumetrics] [--rgb-particles | --no-rgb-particles] [--rgb-translucency | --no-rgb-translucency] [--streaming-timeout-seconds STREAMING_TIMEOUT_SECONDS] [--initial-warmup-frames INITIAL_WARMUP_FRAMES] [--weather-batch-frames WEATHER_BATCH_FRAMES] [--weather-warmup-frames WEATHER_WARMUP_FRAMES] [--camera-warmup-frames CAMERA_WARMUP_FRAMES] [--progress-interval-frames PROGRESS_INTERVAL_FRAMES] [--frames FRAMES] [--seed SEED] [--out-dir OUT_DIR] [--width WIDTH] [--height HEIGHT] [--camera-mode {orbit,drone,random,fixed,spline}] [--look-at {target,random_point,free}] [--camera-distance CAMERA_DISTANCE] [--camera-altitude CAMERA_ALTITUDE] [--fov FOV] [--pitch PITCH] [--yaw YAW] [--roll ROLL] [--near-clip-cm NEAR_CLIP_CM] [--far-clip-cm FAR_CLIP_CM] [--export-intrinsics] [--fixed-camera-position FIXED_CAMERA_POSITION] [--fixed-camera-rotation FIXED_CAMERA_ROTATION] [--fixed-camera-actor FIXED_CAMERA_ACTOR] [--flight-path FLIGHT_PATH] [--scatter-existing-targets | --no-scatter-existing-targets] [--shuffle-per-frame | --no-shuffle-per-frame] [--weather WEATHER] [--weather-driver {builtin,ultra_dynamic}] [--weather-weights WEATHER_WEIGHTS] [--uds-actor UDS_ACTOR] [--uds-params UDS_PARAMS] [--udw-actor UDW_ACTOR] [--udw-params UDW_PARAMS] [--weather-settle-seconds WEATHER_SETTLE_SECONDS] src out

Argument	What it does	Default
`src`required	Studio YAML or compiled capture JSON
`out`required	output folder for dry_run.json and dry_run.csv
`--valid-viewpoints-only, --no-valid-viewpoints-only <value>`
`--viewpoint-min-targets <value>`
`--viewpoint-max-targets <value>`
`--viewpoint-min-visible-percent <value>`
`--viewpoint-min-bbox-width <value>`
`--viewpoint-min-bbox-height <value>`
`--viewpoint-min-camera-distance <value>`
`--viewpoint-max-camera-distance <value>`
`--viewpoint-max-retries <value>`
`--viewpoint-require-fully-visible, --no-viewpoint-require-fully-visible <value>`
`--viewpoint-reject-camera-collision, --no-viewpoint-reject-camera-collision <value>`
`--viewpoint-reject-under-landscape, --no-viewpoint-reject-under-landscape <value>`
`--viewpoint-reject-empty-segmentation, --no-viewpoint-reject-empty-segmentation <value>`
`--viewpoint-min-segmentation-coverage-percent <value>`
`--viewpoint-reject-invalid-depth, --no-viewpoint-reject-invalid-depth <value>`
`--viewpoint-reject-blur, --no-viewpoint-reject-blur <value>`
`--viewpoint-reject-exposure, --no-viewpoint-reject-exposure <value>`
`--viewpoint-min-depth-valid-percent <value>`
`--viewpoint-min-focus-score <value>`
`--viewpoint-min-mean-luma <value>`
`--viewpoint-max-mean-luma <value>`
`--viewpoint-fallback <value>` choices: `continue`, `skip_frame`, `stop_job`, `relax_constraints`
`--performance-profile <value>` choices: `safe`, `balanced`, `fast`, `custom`
`--render-quality <value>` choices: `standard`, `cinematic`
`--write-depth, --no-write-depth <value>`
`--use-ray-tracing-if-enabled, --no-use-ray-tracing-if-enabled <value>`
`--precompile-assets, --no-precompile-assets <value>`
`--warm-target-shaders, --no-warm-target-shaders <value>`
`--stream-all-resources, --no-stream-all-resources <value>`
`--force-target-textures-resident, --no-force-target-textures-resident <value>`
`--settle-weather-on-change-only, --no-settle-weather-on-change-only <value>`
`--dynamic-weather-replay, --no-dynamic-weather-replay <value>`
`--cull-id-targets-outside-view, --no-cull-id-targets-outside-view <value>`
`--group-id-targets, --no-group-id-targets <value>`
`--declare-camera-cut, --no-declare-camera-cut <value>`
`--collect-frame-timings, --no-collect-frame-timings <value>`
`--rgb-antialiasing, --no-rgb-antialiasing <value>`
`--rgb-bloom, --no-rgb-bloom <value>`
`--rgb-global-illumination, --no-rgb-global-illumination <value>`
`--rgb-lumen, --no-rgb-lumen <value>`
`--rgb-shadows, --no-rgb-shadows <value>`
`--rgb-reflections, --no-rgb-reflections <value>`
`--rgb-volumetrics, --no-rgb-volumetrics <value>`
`--rgb-particles, --no-rgb-particles <value>`
`--rgb-translucency, --no-rgb-translucency <value>`
`--streaming-timeout-seconds <value>`
`--initial-warmup-frames <value>`
`--weather-batch-frames <value>`
`--weather-warmup-frames <value>`
`--camera-warmup-frames <value>`
`--progress-interval-frames <value>`
`--frames <value>`
`--seed <value>`
`--out-dir <value>`
`--width <value>`
`--height <value>`
`--camera-mode <value>` choices: `orbit`, `drone`, `random`, `fixed`, `spline`
`--look-at <value>` choices: `target`, `random_point`, `free`
`--camera-distance <value>`
`--camera-altitude <value>`
`--fov <value>`
`--pitch <value>`
`--yaw <value>`
`--roll <value>`
`--near-clip-cm <value>`
`--far-clip-cm <value>`
`--export-intrinsics`		off
`--fixed-camera-position <value>`
`--fixed-camera-rotation <value>`
`--fixed-camera-actor <value>`
`--flight-path <value>`
`--scatter-existing-targets, --no-scatter-existing-targets <value>`
`--shuffle-per-frame, --no-shuffle-per-frame <value>`
`--weather <value>`
`--weather-driver <value>` choices: `builtin`, `ultra_dynamic`
`--weather-weights <value>`
`--uds-actor <value>`
`--uds-params <value>`
`--udw-actor <value>`
`--udw-params <value>`
`--weather-settle-seconds <value>`

nameframe studio-ui-state

emit JSON values for hydrating the Unreal Studio panel

nameframe studio-ui-state [-h] src

Argument	What it does	Default
`src`required

nameframe studio-postprocess

run Studio verify/report/dataset stages with progress

nameframe studio-postprocess [-h] [--dump DUMP] [--progress-file PROGRESS_FILE] [--verify | --no-verify] [--report | --no-report] [--dataset | --no-dataset] [--report-out REPORT_OUT] [--dataset-out DATASET_OUT] [--dataset-task {box,pose}] [--val-frac VAL_FRAC] [--test-frac TEST_FRAC] [--preview-limit PREVIEW_LIMIT] [--lens-profile LENS_PROFILE] [--lens-intensity LENS_INTENSITY] [--lens-profile-weights LENS_PROFILE_WEIGHTS] [--report-show-clean-images | --no-report-show-clean-images] [--report-show-segmentation | --no-report-show-segmentation] [--include-clean-images | --no-include-clean-images] [--include-segmentation | --no-include-segmentation] [--precipitation | --no-precipitation] [--extra-report-args EXTRA_REPORT_ARGS] [--extra-dataset-args EXTRA_DATASET_ARGS] job

Argument	What it does	Default
`job`required	prepared capture job JSON
`--dump <value>`
`--progress-file <value>`
`--verify, --no-verify <value>`		on
`--report, --no-report <value>`		on
`--dataset, --no-dataset <value>`		on
`--report-out <value>`		empty
`--dataset-out <value>`		empty
`--dataset-task <value>` choices: `box`, `pose`		`box`
`--val-frac <value>`		`0.2`
`--test-frac <value>`		`0.1`
`--preview-limit <value>`		`12`
`--lens-profile <value>`		empty
`--lens-intensity <value>`		`1.0`
`--lens-profile-weights <value>`		empty
`--report-show-clean-images, --no-report-show-clean-images <value>`		on
`--report-show-segmentation, --no-report-show-segmentation <value>`		on
`--include-clean-images, --no-include-clean-images <value>`		off
`--include-segmentation, --no-include-segmentation <value>`		off
`--precipitation, --no-precipitation <value>`		on
`--extra-report-args <value>`		empty
`--extra-dataset-args <value>`		empty

nameframe prepare-job

compile/copy a job and apply runtime capture overrides

nameframe prepare-job [-h] [--frames FRAMES] [--seed SEED] [--out-dir OUT_DIR] [--width WIDTH] [--height HEIGHT] [--valid-viewpoints-only | --no-valid-viewpoints-only] [--viewpoint-min-targets VIEWPOINT_MIN_TARGETS] [--viewpoint-max-targets VIEWPOINT_MAX_TARGETS] [--viewpoint-min-visible-percent VIEWPOINT_MIN_VISIBLE_PERCENT] [--viewpoint-min-bbox-width VIEWPOINT_MIN_BBOX_WIDTH] [--viewpoint-min-bbox-height VIEWPOINT_MIN_BBOX_HEIGHT] [--viewpoint-min-camera-distance VIEWPOINT_MIN_CAMERA_DISTANCE] [--viewpoint-max-camera-distance VIEWPOINT_MAX_CAMERA_DISTANCE] [--viewpoint-max-retries VIEWPOINT_MAX_RETRIES] [--viewpoint-require-fully-visible | --no-viewpoint-require-fully-visible] [--viewpoint-reject-camera-collision | --no-viewpoint-reject-camera-collision] [--viewpoint-reject-under-landscape | --no-viewpoint-reject-under-landscape] [--viewpoint-reject-empty-segmentation | --no-viewpoint-reject-empty-segmentation] [--viewpoint-min-segmentation-coverage-percent VIEWPOINT_MIN_SEGMENTATION_COVERAGE_PERCENT] [--viewpoint-reject-invalid-depth | --no-viewpoint-reject-invalid-depth] [--viewpoint-reject-blur | --no-viewpoint-reject-blur] [--viewpoint-reject-exposure | --no-viewpoint-reject-exposure] [--viewpoint-min-depth-valid-percent VIEWPOINT_MIN_DEPTH_VALID_PERCENT] [--viewpoint-min-focus-score VIEWPOINT_MIN_FOCUS_SCORE] [--viewpoint-min-mean-luma VIEWPOINT_MIN_MEAN_LUMA] [--viewpoint-max-mean-luma VIEWPOINT_MAX_MEAN_LUMA] [--viewpoint-fallback {continue,skip_frame,stop_job,relax_constraints}] [--performance-profile {safe,balanced,fast,custom}] [--render-quality {standard,cinematic}] [--write-depth | --no-write-depth] [--use-ray-tracing-if-enabled | --no-use-ray-tracing-if-enabled] [--precompile-assets | --no-precompile-assets] [--warm-target-shaders | --no-warm-target-shaders] [--stream-all-resources | --no-stream-all-resources] [--force-target-textures-resident | --no-force-target-textures-resident] [--settle-weather-on-change-only | --no-settle-weather-on-change-only] [--dynamic-weather-replay | --no-dynamic-weather-replay] [--cull-id-targets-outside-view | --no-cull-id-targets-outside-view] [--group-id-targets | --no-group-id-targets] [--declare-camera-cut | --no-declare-camera-cut] [--collect-frame-timings | --no-collect-frame-timings] [--rgb-antialiasing | --no-rgb-antialiasing] [--rgb-bloom | --no-rgb-bloom] [--rgb-global-illumination | --no-rgb-global-illumination] [--rgb-lumen | --no-rgb-lumen] [--rgb-shadows | --no-rgb-shadows] [--rgb-reflections | --no-rgb-reflections] [--rgb-volumetrics | --no-rgb-volumetrics] [--rgb-particles | --no-rgb-particles] [--rgb-translucency | --no-rgb-translucency] [--streaming-timeout-seconds STREAMING_TIMEOUT_SECONDS] [--initial-warmup-frames INITIAL_WARMUP_FRAMES] [--weather-batch-frames WEATHER_BATCH_FRAMES] [--weather-warmup-frames WEATHER_WARMUP_FRAMES] [--camera-warmup-frames CAMERA_WARMUP_FRAMES] [--progress-interval-frames PROGRESS_INTERVAL_FRAMES] [--camera-mode {orbit,drone,random,fixed,spline}] [--look-at {target,random_point,free}] [--camera-distance CAMERA_DISTANCE] [--camera-altitude CAMERA_ALTITUDE] [--fov FOV] [--pitch PITCH] [--yaw YAW] [--roll ROLL] [--near-clip-cm NEAR_CLIP_CM] [--far-clip-cm FAR_CLIP_CM] [--export-intrinsics] [--fixed-camera-position FIXED_CAMERA_POSITION] [--fixed-camera-rotation FIXED_CAMERA_ROTATION] [--fixed-camera-actor FIXED_CAMERA_ACTOR] [--flight-path FLIGHT_PATH] [--scatter-existing-targets | --no-scatter-existing-targets] [--shuffle-per-frame | --no-shuffle-per-frame] [--weather WEATHER] [--weather-driver {builtin,ultra_dynamic}] [--weather-weights WEATHER_WEIGHTS] [--uds-actor UDS_ACTOR] [--uds-params UDS_PARAMS] [--udw-actor UDW_ACTOR] [--udw-params UDW_PARAMS] [--weather-settle-seconds WEATHER_SETTLE_SECONDS] src dst

Argument	What it does	Default
`src`required
`dst`required
`--frames <value>`
`--seed <value>`
`--out-dir <value>`
`--width <value>`
`--height <value>`
`--valid-viewpoints-only, --no-valid-viewpoints-only <value>`
`--viewpoint-min-targets <value>`
`--viewpoint-max-targets <value>`
`--viewpoint-min-visible-percent <value>`
`--viewpoint-min-bbox-width <value>`
`--viewpoint-min-bbox-height <value>`
`--viewpoint-min-camera-distance <value>`
`--viewpoint-max-camera-distance <value>`
`--viewpoint-max-retries <value>`
`--viewpoint-require-fully-visible, --no-viewpoint-require-fully-visible <value>`
`--viewpoint-reject-camera-collision, --no-viewpoint-reject-camera-collision <value>`
`--viewpoint-reject-under-landscape, --no-viewpoint-reject-under-landscape <value>`
`--viewpoint-reject-empty-segmentation, --no-viewpoint-reject-empty-segmentation <value>`
`--viewpoint-min-segmentation-coverage-percent <value>`
`--viewpoint-reject-invalid-depth, --no-viewpoint-reject-invalid-depth <value>`
`--viewpoint-reject-blur, --no-viewpoint-reject-blur <value>`
`--viewpoint-reject-exposure, --no-viewpoint-reject-exposure <value>`
`--viewpoint-min-depth-valid-percent <value>`
`--viewpoint-min-focus-score <value>`
`--viewpoint-min-mean-luma <value>`
`--viewpoint-max-mean-luma <value>`
`--viewpoint-fallback <value>` choices: `continue`, `skip_frame`, `stop_job`, `relax_constraints`
`--performance-profile <value>` choices: `safe`, `balanced`, `fast`, `custom`
`--render-quality <value>` choices: `standard`, `cinematic`
`--write-depth, --no-write-depth <value>`
`--use-ray-tracing-if-enabled, --no-use-ray-tracing-if-enabled <value>`
`--precompile-assets, --no-precompile-assets <value>`
`--warm-target-shaders, --no-warm-target-shaders <value>`
`--stream-all-resources, --no-stream-all-resources <value>`
`--force-target-textures-resident, --no-force-target-textures-resident <value>`
`--settle-weather-on-change-only, --no-settle-weather-on-change-only <value>`
`--dynamic-weather-replay, --no-dynamic-weather-replay <value>`
`--cull-id-targets-outside-view, --no-cull-id-targets-outside-view <value>`
`--group-id-targets, --no-group-id-targets <value>`
`--declare-camera-cut, --no-declare-camera-cut <value>`
`--collect-frame-timings, --no-collect-frame-timings <value>`
`--rgb-antialiasing, --no-rgb-antialiasing <value>`
`--rgb-bloom, --no-rgb-bloom <value>`
`--rgb-global-illumination, --no-rgb-global-illumination <value>`
`--rgb-lumen, --no-rgb-lumen <value>`
`--rgb-shadows, --no-rgb-shadows <value>`
`--rgb-reflections, --no-rgb-reflections <value>`
`--rgb-volumetrics, --no-rgb-volumetrics <value>`
`--rgb-particles, --no-rgb-particles <value>`
`--rgb-translucency, --no-rgb-translucency <value>`
`--streaming-timeout-seconds <value>`
`--initial-warmup-frames <value>`
`--weather-batch-frames <value>`
`--weather-warmup-frames <value>`
`--camera-warmup-frames <value>`
`--progress-interval-frames <value>`
`--camera-mode <value>` choices: `orbit`, `drone`, `random`, `fixed`, `spline`
`--look-at <value>` choices: `target`, `random_point`, `free`
`--camera-distance <value>`	target-orbit distance/radius in metres, fixed '12' or range '4,24'
`--camera-altitude <value>`	camera height above target/zone in metres, fixed '18' or range '10,28'
`--fov <value>`	degrees, fixed '70' or range '50,95'
`--pitch <value>`	degrees, fixed or 'min,max'
`--yaw <value>`	degrees, fixed or 'min,max'
`--roll <value>`	degrees, fixed or 'min,max'
`--near-clip-cm <value>`
`--far-clip-cm <value>`
`--export-intrinsics`		off
`--fixed-camera-position <value>`	fixed camera world position in metres: x,y,z
`--fixed-camera-rotation <value>`	fixed camera rotation in degrees: pitch,yaw,roll
`--fixed-camera-actor <value>`	CameraActor name or label used by camera mode fixed
`--flight-path <value>`	NameFrameFlightPath name used by camera mode spline
`--scatter-existing-targets, --no-scatter-existing-targets <value>`
`--shuffle-per-frame, --no-shuffle-per-frame <value>`
`--weather <value>`	clear_sun, fog, overcast, rain, storm, snow, random
`--weather-driver <value>` choices: `builtin`, `ultra_dynamic`	builtin drives NameFrame sun/fog/weather; ultra_dynamic leaves weather to UDS/UDW
`--weather-weights <value>`	for --weather random: clear_sun:20,fog:20,overcast:20,rain:20,storm:10,snow:10
`--uds-actor <value>`	Ultra Dynamic Sky actor name/label to drive
`--uds-params <value>`	Ultra Dynamic Sky params: Property=number or min,max;Other=true
`--udw-actor <value>`	Ultra Dynamic Weather actor name/label to drive
`--udw-params <value>`	Ultra Dynamic Weather params: Rain Amount=0,1;Snow Amount=0,1
`--weather-settle-seconds <value>`	advance the world after weather changes before each capture frame

nameframe presets

write a JSON/HTML gallery for Studio preset YAML files

nameframe presets [-h] root out

Argument	What it does	Default
`root`required	directory containing studio_*.yml preset files
`out`required	output folder for presets.json and index.html

nameframe preset-new

create an editable Studio YAML preset

nameframe preset-new [-h] --name NAME --preset PRESET --map MAP --out-dir OUT_DIR [--frames FRAMES] [--seed SEED] [--class CLASSES] [--camera-center CAMERA_CENTER] [--camera-radius CAMERA_RADIUS] [--camera-altitude CAMERA_ALTITUDE] [--camera-size CAMERA_SIZE] [--camera-yaw CAMERA_YAW] [--camera-weight CAMERA_WEIGHT] [--spawn-center SPAWN_CENTER] [--spawn-radius SPAWN_RADIUS] [--spawn-size SPAWN_SIZE] [--spawn-yaw SPAWN_YAW] [--spawn-weight SPAWN_WEIGHT] [--spawn-actor-yaw SPAWN_ACTOR_YAW] [--no-shuffle-per-frame] [--use-level-spawn-zones] [--ground-actor-prefix GROUND_ACTOR_PREFIX] [--render-profile RENDER_PROFILE] dst

Argument	What it does	Default
`dst`required	output studio_*.yml path
`--name <value>` required
`--preset <value>` required	stable preset id
`--map <value>` required	expected Unreal map package
`--out-dir <value>` required	default raw dump output folder
`--frames <value>`		`100`
`--seed <value>`		`42`
`--class <value>`	class spec: label,prefix=BP_,keypoints=coco or car,actor_tag=DatasetTargetCar
`--camera-center <value>`	camera zone center as x,y,z metres
`--camera-radius <value>`	camera zone radius range as min,max metres
`--camera-altitude <value>`	camera altitude range as min,max metres
`--camera-size <value>`	rectangle camera zone size as length,width metres
`--camera-yaw <value>`	rectangle camera zone yaw in degrees
`--camera-weight <value>`	relative shuffle weight for the camera zone
`--spawn-center <value>`	spawn zone center as x,y,z metres
`--spawn-radius <value>`	spawn zone radius range as min,max metres
`--spawn-size <value>`	rectangle spawn zone size as length,width metres
`--spawn-yaw <value>`	rectangle spawn zone yaw in degrees
`--spawn-weight <value>`	relative shuffle weight for the spawn zone
`--spawn-actor-yaw <value>`	actor yaw range inside spawn zone as min,max degrees
`--no-shuffle-per-frame`	keep scattered actors fixed across frames	on
`--use-level-spawn-zones`	import NameFrameSpawnZone actors from the level at capture time	off
`--ground-actor-prefix <value>`		`Landscape`
`--render-profile <value>`		`beach_sunny_drone`

nameframe distribution-preview

sample a distribution spec and write JSON+SVG preview

nameframe distribution-preview [-h] [--samples SAMPLES] [--seed SEED] [--bins BINS] spec out

Argument	What it does	Default
`spec`required	JSON string or path to JSON distribution spec
`out`required	output directory for distribution_preview.json/svg
`--samples <value>`		`1000`
`--seed <value>`		`42`
`--bins <value>`		`20`

Scenario manager#

Promotes loose YAML files into versioned scenarios with stable ids, immutable versions, config hashes and field-level comparison.

Command	Purpose
`scenario-init`	create a local Scenario Manager store
`scenario-create`	create a managed scenario from a Studio YAML/JSON file
`scenario-list`	list managed scenarios
`scenario-show`	show scenario metadata and a saved version
`scenario-version`	add a new immutable version from a Studio YAML/JSON file
`scenario-duplicate`	duplicate a managed scenario under a new id
`scenario-rename`	rename a managed scenario
`scenario-archive`	archive or unarchive a managed scenario
`scenario-compare`	compare two saved scenario versions

nameframe scenario-init

create a local Scenario Manager store

nameframe scenario-init [-h] root

Argument	What it does	Default
`root`required

nameframe scenario-create

create a managed scenario from a Studio YAML/JSON file

nameframe scenario-create [-h] [--id ID] [--name NAME] [--description DESCRIPTION] [--author AUTHOR] [--note NOTE] root src

Argument	What it does	Default
`root`required
`src`required
`--id <value>`	stable scenario id; defaults to preset/name
`--name <value>`
`--description <value>`		empty
`--author <value>`		empty
`--note <value>`		`initial version`

nameframe scenario-list

list managed scenarios

nameframe scenario-list [-h] [--all] [--json] root

Argument	What it does	Default
`root`required
`--all`	include archived scenarios	off
`--json`		off

nameframe scenario-show

show scenario metadata and a saved version

nameframe scenario-show [-h] [--version VERSION] root id

Argument	What it does	Default
`root`required
`id`required
`--version <value>`	version id such as v001; defaults to current

nameframe scenario-version

add a new immutable version from a Studio YAML/JSON file

nameframe scenario-version [-h] [--author AUTHOR] [--note NOTE] root id src

Argument	What it does	Default
`root`required
`id`required
`src`required
`--author <value>`		empty
`--note <value>`		empty

nameframe scenario-duplicate

duplicate a managed scenario under a new id

nameframe scenario-duplicate [-h] [--name NAME] [--author AUTHOR] [--note NOTE] root source_id new_id

Argument	What it does	Default
`root`required
`source_id`required
`new_id`required
`--name <value>`
`--author <value>`		empty
`--note <value>`		`duplicated scenario`

nameframe scenario-rename

rename a managed scenario

nameframe scenario-rename [-h] root id name

Argument	What it does	Default
`root`required
`id`required
`name`required

nameframe scenario-archive

archive or unarchive a managed scenario

nameframe scenario-archive [-h] [--unarchive] root id

Argument	What it does	Default
`root`required
`id`required
`--unarchive`		off

nameframe scenario-compare

compare two saved scenario versions

nameframe scenario-compare [-h] --from FROM_VERSION --to TO_VERSION [--json] root id

Argument	What it does	Default
`root`required
`id`required
`--from <value>` required
`--to <value>` required
`--json`		off

Metadata, analytics and reports#

Metadata v1 sidecars are the queryable record of a run. Build them, index them into local SQLite, then query, compare and report.

Command	Purpose
`metadata-build`	materialize a deterministic Metadata v1 sidecar from a raw dump
`metadata-index`	idempotently index one or more Metadata v1 sidecars into local SQLite
`metadata-index-summary`	show local Metadata v1 index counts
`metadata-report`	write a reproducible run-level KPI report from the local metadata index
`metadata-compare`	compare stable metrics and frozen configuration for two indexed runs
`metadata-query`	query indexed runs with typed Analytics filters
`metadata-view-save`	create or update a deterministic saved local Analytics view
`metadata-views`	list saved local Analytics views
`metadata-view-report`	regenerate stable KPI records selected by a saved local view
`metadata-link-version`	link an immutable assembled-dataset version to source Metadata v1 frames
`metadata-backup`	backup local metadata stores without raw blobs or secrets
`metadata-restore`	restore a metadata backup into a target directory

nameframe metadata-build

materialize a deterministic Metadata v1 sidecar from a raw dump

nameframe metadata-build [-h] [--out OUT] [--dataset-id DATASET_ID] [--dataset-name DATASET_NAME] [--run-id RUN_ID] [--created-at CREATED_AT] [--checksums] dump

Argument	What it does	Default
`dump`required	NameFrame raw dump directory
`--out <value>`	dataset sidecar root (default: raw dump root)
`--dataset-id <value>`
`--dataset-name <value>`
`--run-id <value>`
`--created-at <value>`	ISO 8601 UTC creation time; otherwise use authoritative capture metadata
`--checksums`	calculate SHA-256 for every referenced frame artifact	off

nameframe metadata-index

idempotently index one or more Metadata v1 sidecars into local SQLite

nameframe metadata-index [-h] index sidecars [sidecars ...]

Argument	What it does	Default
`index`required	SQLite index path
`sidecars`required	one or more Metadata v1 sidecar roots

nameframe metadata-index-summary

show local Metadata v1 index counts

nameframe metadata-index-summary [-h] [--json] index

Argument	What it does	Default
`index`required	SQLite index path
`--json`		off

nameframe metadata-report

write a reproducible run-level KPI report from the local metadata index

nameframe metadata-report [-h] --out OUT [--html-out HTML_OUT] [--run-id RUN_ID] index

Argument	What it does	Default
`index`required	SQLite metadata index path
`--out <value>` required	output JSON report
`--html-out <value>`	optional deterministic HTML report
`--run-id <value>`	limit to an indexed run; repeatable	`[]`

nameframe metadata-compare

compare stable metrics and frozen configuration for two indexed runs

nameframe metadata-compare [-h] --out OUT [--html-out HTML_OUT] [--representative-limit REPRESENTATIVE_LIMIT] index baseline_run_id candidate_run_id

Argument	What it does	Default
`index`required	SQLite metadata index path
`baseline_run_id`required
`candidate_run_id`required
`--out <value>` required	output JSON comparison
`--html-out <value>`	optional deterministic HTML comparison
`--representative-limit <value>`	maximum paired sample references per split (default: 12)	`12`

nameframe metadata-query

query indexed runs with typed Analytics filters

nameframe metadata-query [-h] [--out OUT] [--run-id RUN_ID] [--scenario SCENARIO] [--seed SEED] [--map MAP] [--status STATUS] [--class-name CLASS_NAME] [--quality-grade QUALITY_GRADE] [--min-quality-score MIN_QUALITY_SCORE] [--max-quality-score MAX_QUALITY_SCORE] [--split {train,val,test}] index

Argument	What it does	Default
`index`required	SQLite metadata index path
`--out <value>`	optional deterministic JSON query output
`--run-id <value>`	match an indexed run ID; repeatable	`[]`
`--scenario <value>`	match a scenario ID; repeatable	`[]`
`--seed <value>`	match a global seed; repeatable	`[]`
`--map <value>`	match a map ID; repeatable	`[]`
`--status <value>`	match a run status; repeatable	`[]`
`--class-name <value>`	require a semantic class name; repeatable	`[]`
`--quality-grade <value>`	match an assembled dataset quality grade; repeatable	`[]`
`--min-quality-score <value>`
`--max-quality-score <value>`
`--split <value>` choices: `train`, `val`, `test`	require sample membership in a split; repeatable	`[]`

nameframe metadata-view-save

create or update a deterministic saved local Analytics view

nameframe metadata-view-save [-h] [--description DESCRIPTION] [--run-id RUN_ID] [--scenario SCENARIO] [--seed SEED] [--map MAP] [--status STATUS] [--class-name CLASS_NAME] [--quality-grade QUALITY_GRADE] [--min-quality-score MIN_QUALITY_SCORE] [--max-quality-score MAX_QUALITY_SCORE] [--split {train,val,test}] store name

Argument	What it does	Default
`store`required	local JSON view store
`name`required	stable, user-facing view name
`--description <value>`		empty
`--run-id <value>`	match an indexed run ID; repeatable	`[]`
`--scenario <value>`	match a scenario ID; repeatable	`[]`
`--seed <value>`	match a global seed; repeatable	`[]`
`--map <value>`	match a map ID; repeatable	`[]`
`--status <value>`	match a run status; repeatable	`[]`
`--class-name <value>`	require a semantic class name; repeatable	`[]`
`--quality-grade <value>`	match an assembled dataset quality grade; repeatable	`[]`
`--min-quality-score <value>`
`--max-quality-score <value>`
`--split <value>` choices: `train`, `val`, `test`	require sample membership in a split; repeatable	`[]`

nameframe metadata-views

list saved local Analytics views

nameframe metadata-views [-h] [--json] store

Argument	What it does	Default
`store`required	local JSON view store
`--json`		off

nameframe metadata-view-report

regenerate stable KPI records selected by a saved local view

nameframe metadata-view-report [-h] --out OUT [--html-out HTML_OUT] store view index

Argument	What it does	Default
`store`required	local JSON view store
`view`required	saved view ID or name
`index`required	SQLite metadata index path
`--out <value>` required	output JSON report
`--html-out <value>`	optional deterministic HTML report

nameframe metadata-link-version

link an immutable assembled-dataset version to source Metadata v1 frames

nameframe metadata-link-version [-h] sidecar store version_id

Argument	What it does	Default
`sidecar`required	Metadata v1 sidecar root produced by metadata-build
`store`required	control-plane JSON containing the published dataset version
`version_id`required	immutable dataset version identifier

nameframe metadata-backup

backup local metadata stores without raw blobs or secrets

nameframe metadata-backup [-h] [--root ROOT] --source SOURCE [--max-file-bytes MAX_FILE_BYTES] [--name NAME] out

Argument	What it does	Default
`out`required
`--root <value>`		`.`
`--source <value>` required	metadata file or directory to include
`--max-file-bytes <value>`		`5000000`
`--name <value>`		`nameframe-metadata`

nameframe metadata-restore

restore a metadata backup into a target directory

nameframe metadata-restore [-h] [--overwrite] [--dry-run] archive dst

Argument	What it does	Default
`archive`required
`dst`required
`--overwrite`		off
`--dry-run`		off

Dataset versions, lineage and storage#

Immutable published dataset versions, per-sample lineage, and local content-addressed object storage.

Command	Purpose
`dataset-version-publish`	publish an immutable dataset version into the control plane
`dataset-versions`	list dataset versions
`lineage-samples`	list sample lineage for a dataset version
`object-put`	store a file in local content-addressed storage
`object-list`	list local object-store entries
`object-get`	materialize an object by sha256 or URI

nameframe dataset-version-publish

publish an immutable dataset version into the control plane

nameframe dataset-version-publish [-h] [--project-id PROJECT_ID] [--source-job SOURCE_JOB] [--source-scenario SOURCE_SCENARIO] [--created-by CREATED_BY] [--object-store OBJECT_STORE] [--validation VALIDATION] store dataset

Argument	What it does	Default
`store`required	control-plane JSON path
`dataset`required	assembled dataset root
`--project-id <value>`		empty
`--source-job <value>`		`[]`
`--source-scenario <value>`		`[]`
`--created-by <value>`		`system`
`--object-store <value>`	optional object store root for dataset manifests
`--validation <value>`	optional validation.json to preserve with the immutable version

nameframe dataset-versions

list dataset versions

nameframe dataset-versions [-h] [--dataset-id DATASET_ID] [--json] store

Argument	What it does	Default
`store`required	control-plane JSON path
`--dataset-id <value>`
`--json`		off

nameframe lineage-samples

list sample lineage for a dataset version

nameframe lineage-samples [-h] [--limit LIMIT] [--json] store version_id

Argument	What it does	Default
`store`required	control-plane JSON path
`version_id`required
`--limit <value>`		`20`
`--json`		off

nameframe object-put

store a file in local content-addressed storage

nameframe object-put [-h] [--namespace NAMESPACE] [--metadata METADATA] store path

Argument	What it does	Default
`store`required	object store root
`path`required	file to store
`--namespace <value>`		empty
`--metadata <value>`	object metadata key=value; repeatable	`[]`

nameframe object-list

list local object-store entries

nameframe object-list [-h] [--namespace NAMESPACE] [--json] store

Argument	What it does	Default
`store`required	object store root
`--namespace <value>`		empty
`--json`		off

nameframe object-get

materialize an object by sha256 or URI

nameframe object-get [-h] store sha256 out

Argument	What it does	Default
`store`required	object store root
`sha256`required	object sha256 or nameframe-object URI
`out`required	output file

Queue, control plane and workers#

Run long or many jobs without babysitting them: a local persistent queue, a local control plane with job sharding, and machine-local workers.

Command	Purpose
`queue-submit`	append a command to a local persistent queue
`queue-list`	list a local persistent queue
`queue-run`	run queued commands sequentially
`control-init`	create a local enterprise control-plane store
`control-worker-register`	register or heartbeat a worker
`control-job-submit`	submit a command to the control plane
`control-shard-submit`	split a large control-plane job into deterministic shards
`control-jobs`	list control-plane jobs
`control-audit`	list structured control-plane audit events
`control-metrics`	summarise control-plane operational metrics
`control-logs`	read structured control-plane JSONL logs
`worker-run`	run compatible control-plane jobs on this machine

nameframe queue-submit

append a command to a local persistent queue

nameframe queue-submit [-h] [--name NAME] [--cwd CWD] [--max-retries MAX_RETRIES] queue command [command ...]

Argument	What it does	Default
`queue`required	queue JSON path
`command`required	command argv to run; use -- before commands with options
`--name <value>`		empty
`--cwd <value>`
`--max-retries <value>`		`0`

nameframe queue-list

list a local persistent queue

nameframe queue-list [-h] [--status STATUS] [--json] queue

Argument	What it does	Default
`queue`required	queue JSON path
`--status <value>`
`--json`		off

nameframe queue-run

run queued commands sequentially

nameframe queue-run [-h] [--limit LIMIT] [--timeout TIMEOUT] [--continue-on-failure] queue

Argument	What it does	Default
`queue`required	queue JSON path
`--limit <value>`
`--timeout <value>`
`--continue-on-failure`		off

nameframe control-init

create a local enterprise control-plane store

nameframe control-init [-h] --org ORG --project PROJECT store

Argument	What it does	Default
`store`required	control-plane JSON path
`--org <value>` required
`--project <value>` required

nameframe control-worker-register

nameframe control-worker-register [-h] [--worker-id WORKER_ID] [--status {online,busy,draining,offline,unhealthy}] [--capability CAPABILITY] store

Argument	What it does	Default
`store`required	control-plane JSON path
`--worker-id <value>`
`--status <value>` choices: `online`, `busy`, `draining`, `offline`, `unhealthy`		`online`
`--capability <value>`	worker capability key=value; repeatable	`[]`

nameframe control-job-submit

submit a command to the control plane

nameframe control-job-submit [-h] [--project-id PROJECT_ID] [--scenario-id SCENARIO_ID] [--name NAME] [--priority PRIORITY] [--cwd CWD] [--max-retries MAX_RETRIES] [--require REQUIRE] store command [command ...]

Argument	What it does	Default
`store`required	control-plane JSON path
`command`required	command argv to run; use -- before commands with options
`--project-id <value>`
`--scenario-id <value>`
`--name <value>`		empty
`--priority <value>`		`0`
`--cwd <value>`
`--max-retries <value>`		`0`
`--require <value>`	worker requirement key=value; repeatable	`[]`

nameframe control-shard-submit

split a large control-plane job into deterministic shards

nameframe control-shard-submit [-h] [--project-id PROJECT_ID] [--scenario-id SCENARIO_ID] [--name NAME] --samples SAMPLES --shard-size SHARD_SIZE [--seed SEED] [--priority PRIORITY] [--cwd CWD] [--max-retries MAX_RETRIES] [--require REQUIRE] store command [command ...]

Argument	What it does	Default
`store`required	control-plane JSON path
`command`required	command template; supports {shard_id}, {sample_start}, {sample_end}, {seed_start}, {seed_end}
`--project-id <value>`
`--scenario-id <value>`
`--name <value>`		empty
`--samples <value>` required
`--shard-size <value>` required
`--seed <value>`		`0`
`--priority <value>`		`0`
`--cwd <value>`
`--max-retries <value>`		`0`
`--require <value>`	worker requirement key=value; repeatable	`[]`

nameframe control-jobs

list control-plane jobs

nameframe control-jobs [-h] [--status STATUS] [--json] store

Argument	What it does	Default
`store`required	control-plane JSON path
`--status <value>`
`--json`		off

nameframe control-audit

list structured control-plane audit events

nameframe control-audit [-h] [--event EVENT] [--object-kind OBJECT_KIND] [--object-id OBJECT_ID] [--json] store

Argument	What it does	Default
`store`required	control-plane JSON path
`--event <value>`
`--object-kind <value>`
`--object-id <value>`
`--json`		off

nameframe control-metrics

summarise control-plane operational metrics

nameframe control-metrics [-h] [--json] store

Argument	What it does	Default
`store`required	control-plane JSON path
`--json`		off

nameframe control-logs

read structured control-plane JSONL logs

nameframe control-logs [-h] [--limit LIMIT] [--json] store

Argument	What it does	Default
`store`required	control-plane JSON path
`--limit <value>`
`--json`		off

nameframe worker-run

run compatible control-plane jobs on this machine

nameframe worker-run [-h] [--worker-id WORKER_ID] [--capability CAPABILITY] [--limit LIMIT] [--timeout TIMEOUT] store

Argument	What it does	Default
`store`required	control-plane JSON path
`--worker-id <value>`
`--capability <value>`	worker capability key=value; repeatable	`[]`
`--limit <value>`
`--timeout <value>`

AI assistants (MCP) and API#

Serve NameFrame to an AI client over MCP, or serve API v1 for the Python SDK and Studio Results.

Command	Purpose
`api-serve`	serve API v1 discovery endpoints on localhost
`mcp-serve`	serve NameFrame MCP over STDIO or authenticated HTTP
`mcp-doctor`	diagnose MCP and NameFrame connectivity read-only
`mcp-approval-list`	list sanitized durable MCP generation approvals
`mcp-approval-decide`	approve or deny one durable MCP generation request

nameframe api-serve

serve API v1 discovery endpoints on localhost

nameframe api-serve [-h] [--host HOST] [--port PORT] [--scene-manifest SCENE_MANIFEST] [--remote-url REMOTE_URL] [--timeout TIMEOUT] [--studio-dir STUDIO_DIR] [--metadata-index METADATA_INDEX] [--metadata-view-store METADATA_VIEW_STORE] [--analytics-output-dir ANALYTICS_OUTPUT_DIR] [--task-store TASK_STORE] [--task-output-root TASK_OUTPUT_ROOT] [--max-active-tasks MAX_ACTIVE_TASKS]

Argument	What it does	Default
`--host <value>`		`127.0.0.1`
`--port <value>`		`8010`
`--scene-manifest <value>`	serve this saved SceneManifest v1 instead of querying Unreal
`--remote-url <value>`	Unreal Remote Control URL used when --scene-manifest is absent	`http://127.0.0.1:30010`
`--timeout <value>`		`30.0`
`--studio-dir <value>`	serve a static external studio UI at /studio/
`--metadata-index <value>`	enable Studio Results with this local Metadata v1 SQLite index
`--metadata-view-store <value>`	saved-view JSON path (default: nameframe_views.json beside index)
`--analytics-output-dir <value>`	report output directory (default: nameframe_reports beside index)
`--task-store <value>`	durable JSON task store path	`_local/nameframe_tasks.json`
`--task-output-root <value>`	allowed generation output root; repeat to add roots	`['_local']`
`--max-active-tasks <value>`	bounded concurrent API tasks (1..16)	`2`

nameframe mcp-serve

serve NameFrame MCP over STDIO or authenticated HTTP

nameframe mcp-serve [-h] [--transport {stdio,streamable-http}] [--api-url API_URL] [--timeout TIMEOUT] [--scope SCOPE] [--disable-writes] [--actor ACTOR] [--output-root OUTPUT_ROOT] [--structured-log STRUCTURED_LOG] [--structured-log-max-bytes STRUCTURED_LOG_MAX_BYTES] [--approval-store APPROVAL_STORE] [--host HOST] [--port PORT] [--path PATH] [--control-store CONTROL_STORE] [--project-id PROJECT_ID] [--issuer-url ISSUER_URL] [--resource-server-url RESOURCE_SERVER_URL] [--max-generation-tasks-per-day MAX_GENERATION_TASKS_PER_DAY] [--max-requests-per-minute MAX_REQUESTS_PER_MINUTE] [--token-verifier {control-store,oauth-introspection}] [--oauth-introspection-url OAUTH_INTROSPECTION_URL] [--oauth-client-id OAUTH_CLIENT_ID] [--oauth-timeout OAUTH_TIMEOUT]

Argument	What it does	Default
`--transport <value>` choices: `stdio`, `streamable-http`	MCP transport (HTTP requires a control-plane project and bearer token)	`stdio`
`--api-url <value>`	local NameFrame API base URL	`http://127.0.0.1:8010`
`--timeout <value>`	NameFrame API read timeout in seconds	`5.0`
`--scope <value>`	grant an MCP scope; repeat for each explicit write scope	`[]`
`--disable-writes`	force the server to safe read-only scopes, ignoring write grants	off
`--actor <value>`	bounded actor identity recorded in the MCP audit	`local-stdio`
`--output-root <value>`	allowed generation output root; repeat to grant more roots	`[]`
`--structured-log <value>`	optional bounded JSONL request log path	empty
`--structured-log-max-bytes <value>`	maximum JSONL bytes before file events are dropped	`5000000`
`--approval-store <value>`	optional absolute durable operator-approval JSON store	empty
`--host <value>`	HTTP bind host; loopback by default	`127.0.0.1`
`--port <value>`	HTTP bind port	`8020`
`--path <value>`	Streamable HTTP endpoint path	`/mcp`
`--control-store <value>`	control-plane JSON store containing projects, users, and token hashes	`_local/control.json`
`--project-id <value>`	project isolated by this HTTP server	empty
`--issuer-url <value>`	HTTPS authorization issuer URL (loopback HTTP allowed for development)	empty
`--resource-server-url <value>`	canonical HTTPS URL of this MCP resource server	empty
`--max-generation-tasks-per-day <value>`	per-project daily accepted generation-request quota	`100`
`--max-requests-per-minute <value>`	per-authenticated-client tool-call limit in a 60-second window	`600`
`--token-verifier <value>` choices: `control-store`, `oauth-introspection`	bearer-token verifier; local control store or RFC 7662 introspection	`control-store`
`--oauth-introspection-url <value>`	RFC 7662 token introspection endpoint	empty
`--oauth-client-id <value>`	confidential resource-server client ID	empty
`--oauth-timeout <value>`	OAuth introspection timeout in seconds	`5.0`

nameframe mcp-doctor

diagnose MCP and NameFrame connectivity read-only

nameframe mcp-doctor [-h] [--transport {stdio,streamable-http}] [--api-url API_URL] [--timeout TIMEOUT] [--scope SCOPE] [--actor ACTOR] [--output-root OUTPUT_ROOT] [--host HOST] [--port PORT] [--path PATH] [--control-store CONTROL_STORE] [--project-id PROJECT_ID] [--issuer-url ISSUER_URL] [--resource-server-url RESOURCE_SERVER_URL] [--max-generation-tasks-per-day MAX_GENERATION_TASKS_PER_DAY] [--token-verifier {control-store,oauth-introspection}] [--oauth-introspection-url OAUTH_INTROSPECTION_URL] [--oauth-client-id OAUTH_CLIENT_ID] [--oauth-timeout OAUTH_TIMEOUT] [--json]

Argument	What it does	Default
`--transport <value>` choices: `stdio`, `streamable-http`		`stdio`
`--api-url <value>`		`http://127.0.0.1:8010`
`--timeout <value>`		`5.0`
`--scope <value>`		`[]`
`--actor <value>`		`local-stdio`
`--output-root <value>`		`[]`
`--host <value>`		`127.0.0.1`
`--port <value>`		`8020`
`--path <value>`		`/mcp`
`--control-store <value>`		`_local/control.json`
`--project-id <value>`		empty
`--issuer-url <value>`		empty
`--resource-server-url <value>`		empty
`--max-generation-tasks-per-day <value>`		`100`
`--token-verifier <value>` choices: `control-store`, `oauth-introspection`		`control-store`
`--oauth-introspection-url <value>`		empty
`--oauth-client-id <value>`		empty
`--oauth-timeout <value>`		`5.0`
`--json`	emit the bounded JSON report	off

nameframe mcp-approval-list

list sanitized durable MCP generation approvals

nameframe mcp-approval-list [-h] [--status {pending,approved,denied,consumed}] [--limit LIMIT] store

Argument	What it does	Default
`store`required	approval JSON store
`--status <value>` choices: `pending`, `approved`, `denied`, `consumed`		empty
`--limit <value>`		`50`

nameframe mcp-approval-decide

approve or deny one durable MCP generation request

nameframe mcp-approval-decide [-h] --decision {approved,denied} [--actor ACTOR] store approval_id

Argument	What it does	Default
`store`required	approval JSON store
`approval_id`required
`--decision <value>` choices: `approved`, `denied` required
`--actor <value>`		`unreal-studio`

Experiments and model feedback#

Close the loop between a trained model and the next dataset: measure coverage, compare synthetic against real, mine failures, and plan hard cases.

Command	Purpose
`experiment-create`	create a local experiment record
`experiment-add-variant`	add a variant dataset to an experiment
`experiments`	list local experiments
`paired-plan`	build a paired generation freeze/vary plan
`coverage-eval`	evaluate a required coverage matrix
`goal-plan`	plan sampling weights from target distributions
`adaptive-update`	bounded adaptive sampling probability update
`real-dataset-import`	profile/import a real YOLO dataset
`dataset-profile`	write a dataset statistics profile
`compare-profiles`	compare real and synthetic dataset profiles
`domain-gap`	write domain-gap findings and recommendations
`model-eval`	evaluate model metrics by scenario slice
`failure-mine`	mine underperforming evaluation slices
`hard-cases`	plan generation for mined failure slices
`regression-campaign`	combine evaluations into pass/fail campaign

nameframe experiment-create

create a local experiment record

nameframe experiment-create [-h] --name NAME --hypothesis HYPOTHESIS [--baseline-dataset BASELINE_DATASET] [--controlled-variable CONTROLLED_VARIABLE] [--notes NOTES] store

Argument	What it does	Default
`store`required	experiment store JSON path
`--name <value>` required
`--hypothesis <value>` required
`--baseline-dataset <value>`		empty
`--controlled-variable <value>`		`[]`
`--notes <value>`		empty

nameframe experiment-add-variant

add a variant dataset to an experiment

nameframe experiment-add-variant [-h] --label LABEL --dataset-version-id DATASET_VERSION_ID [--variable VARIABLE] [--metric METRIC] store experiment_id

Argument	What it does	Default
`store`required	experiment store JSON path
`experiment_id`required
`--label <value>` required
`--dataset-version-id <value>` required
`--variable <value>`		`[]`
`--metric <value>`		`[]`

nameframe experiments

list local experiments

nameframe experiments [-h] [--json] store

Argument	What it does	Default
`store`required	experiment store JSON path
`--json`		off

nameframe paired-plan

build a paired generation freeze/vary plan

nameframe paired-plan [-h] [--name NAME] [--locked LOCKED] --vary VARY base out

Argument	What it does	Default
`base`required	base scenario/config JSON
`out`required	paired plan JSON output
`--name <value>`		`paired_plan`
`--locked <value>`	locked config path; repeatable	`[]`
`--vary <value>` required	variable path=value,value; repeatable

nameframe coverage-eval

evaluate a required coverage matrix

nameframe coverage-eval [-h] --axis AXIS [--observation OBSERVATION] [--target TARGET] out

Argument	What it does	Default
`out`required	coverage matrix JSON output
`--axis <value>` required	axis=value,value; repeatable
`--observation <value>`	observation as axis=value,axis=value; repeatable	`[]`
`--target <value>`	target observations per cell	`1`

nameframe goal-plan

plan sampling weights from target distributions

nameframe goal-plan [-h] --target TARGET [--current CURRENT] [--candidate CANDIDATE] out

Argument	What it does	Default
`out`required
`--target <value>` required	target key=value; repeatable
`--current <value>`	current count key=value; repeatable	`[]`
`--candidate <value>`	candidate:key=value,value; repeatable	`[]`

nameframe adaptive-update

bounded adaptive sampling probability update

nameframe adaptive-update [-h] --current-weights CURRENT_WEIGHTS --target TARGET --observed OBSERVED [--learning-rate LEARNING_RATE] [--max-delta MAX_DELTA] out

Argument	What it does	Default
`out`required
`--current-weights <value>` required
`--target <value>` required
`--observed <value>` required
`--learning-rate <value>`		`0.5`
`--max-delta <value>`		`0.2`

nameframe real-dataset-import

profile/import a real YOLO dataset

nameframe real-dataset-import [-h] [--format FORMAT] [--copy-files] src out

Argument	What it does	Default
`src`required
`out`required
`--format <value>`		`yolo`
`--copy-files`		off

nameframe dataset-profile

write a dataset statistics profile

nameframe dataset-profile [-h] [--kind {synthetic,real}] dataset out

Argument	What it does	Default
`dataset`required
`out`required
`--kind <value>` choices: `synthetic`, `real`		`synthetic`

nameframe compare-profiles

compare real and synthetic dataset profiles

nameframe compare-profiles [-h] real_profile synthetic_profile out

Argument	What it does	Default
`real_profile`required
`synthetic_profile`required
`out`required

nameframe domain-gap

write domain-gap findings and recommendations

nameframe domain-gap [-h] [--threshold THRESHOLD] comparison out

Argument	What it does	Default
`comparison`required
`out`required
`--threshold <value>`		`0.1`

nameframe model-eval

evaluate model metrics by scenario slice

nameframe model-eval [-h] [--metric METRIC] [--pass-threshold PASS_THRESHOLD] [--slice-key SLICE_KEY] results out

Argument	What it does	Default
`results`required	JSON list or {'results': [...]} file
`out`required
`--metric <value>`		`map50`
`--pass-threshold <value>`		`0.5`
`--slice-key <value>`		`['distance', 'weather', 'object_size', 'occlusion']`

nameframe failure-mine

mine underperforming evaluation slices

nameframe failure-mine [-h] [--max-slices MAX_SLICES] evaluation out

Argument	What it does	Default
`evaluation`required
`out`required
`--max-slices <value>`		`10`

nameframe hard-cases

plan generation for mined failure slices

nameframe hard-cases [-h] [--samples-per-slice SAMPLES_PER_SLICE] failures out

Argument	What it does	Default
`failures`required
`out`required
`--samples-per-slice <value>`		`1000`

nameframe regression-campaign

combine evaluations into pass/fail campaign

nameframe regression-campaign [-h] --name NAME --evaluation EVALUATION [--required-pass-rate REQUIRED_PASS_RATE] out

Argument	What it does	Default
`out`required
`--name <value>` required
`--evaluation <value>` required
`--required-pass-rate <value>`		`1.0`

Access, packaging and release#

Local users, tokens and RBAC, plus the bundles you hand to somebody else.

Command	Purpose
`auth-user-create`	create or update a local control-plane user
`auth-token-create`	create a one-time visible local API token
`auth-check`	check a local RBAC permission
`auth-roles`	list local RBAC roles and permissions
`extension-list`	list registered extension SDK providers
`extension-export`	run an extension exporter
`package-onprem`	build a sanitized on-prem source bundle
`support-bundle`	build a clean pilot/support diagnostics bundle
`release-readiness`	audit release gates against repo evidence and manual blockers
`hardening-smoke`	offline reproducibility/corruption smoke over demo data

nameframe auth-user-create

create or update a local control-plane user

nameframe auth-user-create [-h] --email EMAIL --role {org_admin,project_admin,simulation_engineer,dataset_engineer,ml_engineer,viewer} [--name NAME] [--project-id PROJECT_ID] [--actor ACTOR] store

Argument	What it does	Default
`store`required	control-plane JSON path
`--email <value>` required
`--role <value>` choices: `org_admin`, `project_admin`, `simulation_engineer`, `dataset_engineer`, `ml_engineer`, `viewer` required
`--name <value>`		empty
`--project-id <value>`		empty
`--actor <value>`		`system`

nameframe auth-token-create

create a one-time visible local API token

nameframe auth-token-create [-h] --user-id USER_ID [--actor ACTOR] store

Argument	What it does	Default
`store`required	control-plane JSON path
`--user-id <value>` required
`--actor <value>`		`system`

nameframe auth-check

check a local RBAC permission

nameframe auth-check [-h] [--user-id USER_ID] [--token TOKEN] --permission PERMISSION [--project-id PROJECT_ID] [--json] store

Argument	What it does	Default
`store`required	control-plane JSON path
`--user-id <value>`
`--token <value>`
`--permission <value>` required
`--project-id <value>`		empty
`--json`		off

nameframe auth-roles

list local RBAC roles and permissions

nameframe auth-roles [-h] [--json]

Argument	What it does	Default
`--json`		off

nameframe extension-list

list registered extension SDK providers

nameframe extension-list [-h] [--json]

Argument	What it does	Default
`--json`		off

nameframe extension-export

run an extension exporter

nameframe extension-export [-h] extension_id dataset out

Argument	What it does	Default
`extension_id`required
`dataset`required
`out`required

nameframe package-onprem

build a sanitized on-prem source bundle

nameframe package-onprem [-h] [--repo-root REPO_ROOT] [--name NAME] out

Argument	What it does	Default
`out`required
`--repo-root <value>`		`.`
`--name <value>`		`nameframe-onprem`

nameframe support-bundle

build a clean pilot/support diagnostics bundle

nameframe support-bundle [-h] [--repo-root REPO_ROOT] [--include INCLUDE] [--max-file-bytes MAX_FILE_BYTES] [--name NAME] [--mcp] [--mcp-api-url MCP_API_URL] [--mcp-timeout MCP_TIMEOUT] [--mcp-output-root MCP_OUTPUT_ROOT] out

Argument	What it does	Default
`out`required
`--repo-root <value>`		`.`
`--include <value>`	extra artifact file to include when safe, e.g. report.json	`[]`
`--max-file-bytes <value>`	skip files larger than this and record only hash/metadata	`1000000`
`--name <value>`		`nameframe-support`
`--mcp`	include a sanitized read-only MCP diagnostic snapshot	off
`--mcp-api-url <value>`		`http://127.0.0.1:8010`
`--mcp-timeout <value>`		`5.0`
`--mcp-output-root <value>`		`[]`

nameframe release-readiness

audit release gates against repo evidence and manual blockers

nameframe release-readiness [-h] [--repo-root REPO_ROOT] [--gate-file GATE_FILE] [--fail-on-not-ready] out

Argument	What it does	Default
`out`required	output directory for release_readiness.json/md
`--repo-root <value>`		`.`
`--gate-file <value>`	release gates markdown path relative to repo root
`--fail-on-not-ready`	exit non-zero if any gate has manual or missing evidence	off

nameframe hardening-smoke

offline reproducibility/corruption smoke over demo data

nameframe hardening-smoke [-h] [--out-root OUT_ROOT] [--frames FRAMES] [--seed SEED] [--avatars AVATARS] [--fail-under FAIL_UNDER]

Argument	What it does	Default
`--out-root <value>`	directory for demo dumps, pipeline outputs, and summary JSON	`_local/hardening_smoke`
`--frames <value>`		`8`
`--seed <value>`		`42`
`--avatars <value>`		`6`
`--fail-under <value>`	fail if final dataset quality score is below this	`90.0`

Other commands#

Commands that do not fit the groups above.

nameframe metadata-coverage

compare measured distributions with explicit target bins and categories

nameframe metadata-coverage [-h] --out OUT [--run-id RUN_ID] index targets

Argument	What it does	Default
`index`required	SQLite metadata index path
`targets`required	YAML or JSON target-distribution specification
`--out <value>` required	output JSON coverage report
`--run-id <value>`	limit to an indexed run; repeatable	`[]`

nameframe performance-benchmark-evidence

bind a complete measured matrix to source/binary hashes

nameframe performance-benchmark-evidence [-h] --engine-version ENGINE_VERSION --project PROJECT --runtime-source RUNTIME_SOURCE --runtime-binary RUNTIME_BINARY --editor-binary EDITOR_BINARY [--cpu CPU] [--gpu GPU] report out

Argument	What it does	Default
`report`required	measured benchmark_report.json
`out`required	source-controlled evidence JSON path
`--engine-version <value>` required
`--project <value>` required
`--runtime-source <value>` required
`--runtime-binary <value>` required
`--editor-binary <value>` required
`--cpu <value>`		`not_recorded`
`--gpu <value>`		`not_recorded`

nameframe performance-benchmark-plan

write equivalent target-count and Actor/ISM/HISM Studio recipes

nameframe performance-benchmark-plan [-h] [--target-count TARGET_COUNT] [--representation {actor,ism,hism}] base out

Argument	What it does	Default
`base`required	base Studio YAML with an asset-backed spawn zone
`out`required	benchmark recipe/output directory
`--target-count <value>`
`--representation <value>` choices: `actor`, `ism`, `hism`

nameframe performance-benchmark-report

aggregate measured capture dumps into JSON/CSV/SVG evidence

nameframe performance-benchmark-report [-h] plan out

Argument	What it does	Default
`plan`required	benchmark_plan.json
`out`required	report output directory

nameframe pilot-evidence-init

create an incomplete clean-machine/external-pilot evidence form

nameframe pilot-evidence-init [-h] --session-id SESSION_ID [--role ROLE] [--overwrite] out

Argument	What it does	Default
`out`required
`--session-id <value>` required
`--role <value>`		empty
`--overwrite`		off

nameframe pilot-evidence-report

validate a pilot session and write JSON/Markdown evidence reports

nameframe pilot-evidence-report [-h] [--require-external-pass] session out

Argument	What it does	Default
`session`required
`out`required
`--require-external-pass`		off

nameframe placement-capacity

estimate constrained spawn capacity before Unreal generation

nameframe placement-capacity [-h] --out OUT scenario

Argument	What it does	Default
`scenario`required	Studio YAML or JSON scenario
`--out <value>` required	output JSON feasibility report

nameframe qa-acceptance-report

validate and report the complete T01-T43 QA inventory

nameframe qa-acceptance-report [-h] [--evidence EVIDENCE] matrix out

Argument	What it does	Default
`matrix`required	nameframe.qa-acceptance/v1 YAML
`out`required	JSON/Markdown report directory
`--evidence <value>`	optional JSON object keyed by T01..T43

nameframe scenario-compile

compile ScenarioConfig + SceneManifest to a capture job with parity evidence

nameframe scenario-compile [-h] --output-root OUTPUT_ROOT [--result RESULT] [--job-id JOB_ID] [--target-samples TARGET_SAMPLES] [--width WIDTH] [--height HEIGHT] scenario scene out

Argument	What it does	Default
`scenario`required	ScenarioConfig v1 JSON
`scene`required	SceneManifest v1 JSON
`out`required	compiled CaptureJob JSON
`--output-root <value>` required	execution root used to derive the raw capture destination
`--result <value>`	compilation evidence JSON (default beside CaptureJob)
`--job-id <value>`
`--target-samples <value>`
`--width <value>`		`320`
`--height <value>`		`240`

nameframe spawner-visual-edit

apply one structured Advanced Spawner edit without losing YAML-only fields

nameframe spawner-visual-edit [-h] [--model-out MODEL_OUT] request out

Argument	What it does	Default
`request`required	JSON request containing population_yaml and edit
`out`required	updated population YAML fragment
`--model-out <value>`	optional updated visual model JSON

nameframe spawner-visual-model

build the Advanced Spawner visual model from a population YAML fragment

nameframe spawner-visual-model [-h] [--out OUT] fragment

Argument	What it does	Default
`fragment`required
`--out <value>`	optional JSON model output path

PreviousPython quickstart NextStudio recipe (YAML)