Appendix: Command-Line Options

Options go after the program name when Vertexix is started from a command prompt or a shortcut, for example vertexix.exe model.fbx --create-log. Any argument that is not an option is taken as the model to open on startup, so a model path needs no flag of its own (quote it if it contains spaces). Most options exist so that testing and automation can drive the app without anyone clicking; ordinary use needs none of them. Options that set something apply to that run only and never change your saved settings.

Useful for everyone

These are the options worth knowing about even if you never automate anything. --create-log is the one to use when reporting a problem — see Logs & Crash Reports. The CPU options are fallbacks for graphics cards that misbehave. The --poisson-* options tune how point-cloud scans are turned into a surface — see Point-Cloud Scans.

Option	What it does
--create-log	Start logging immediately. Logs are written to the logs folder next to vertexix.exe, flushed after every line. Without this flag no log is written at all.
--no-gpu-paint	Paint on the CPU for this run, whatever Settings > Performance > GPU painting says.
--gpu-paint	Force GPU painting on for this run (it is on by default). Brushes the GPU path does not cover yet still paint on the CPU automatically, and the status bar says so.
--cpu-sculpt	Sculpt on the CPU for this run instead of the GPU.
--gpu-sculpt	Sculpt on the GPU for this run.
--cpu-vertex-paint	Do vertex-colour painting on the CPU for this run.
--cpu-blur	Keep the Blur Brush on the CPU. The GPU blur is the default wherever the graphics card supports it.
--poisson-depth <n>	Octree depth used to reconstruct a surface from a point-cloud .ply (a scan with no faces) on import. Higher keeps more detail and takes longer. There is no UI for this yet.
--poisson-trim <f>	Density-trim quantile (0–1) for the same reconstruction: how much of the least-supported, lowest-density surface is cut away.
--sidebar-right	Start with the sidebar on the right edge, overriding Settings > Interface for this run.
--hdr <path>	Load an HDR environment file for PBR Preview’s image-based lighting (edition-gated).

General

Option	What it does
--settings	Open the Settings window on startup.
--settings-interface	Open the Settings window on its Interface tab.
--settings-keyboard	Open the Settings window on its Keyboard tab.
--sidebar <tab>	Open a sidebar tab once the model has loaded: paint, sculpt or voxel (anything else means Retopology).
--panel <names>	Open dockable panels at startup, comma-separated: selection, material, seams, animation, camera, scratchpad.
--layers	Open the Layers panel on startup.
--layers-material <n>	Make material n the Layers window’s active material and log which Paint channel rows are live.
--edit-material <n>	Open the Edit Material window on material n.
--grid-settings	Open the Grid window on startup.
--open-color-windows	Hold both colour windows open for the run.
--image-info	Open the Image Info window for the image currently selected.
--open-accordion <n>	Force sidebar accordion section n open every frame.
--modal-accordion <n>	Force accordion section n of the PBR/OpenGL Settings windows open every frame (combine with --display pbr-settings or gl-settings).
--open-dropdown <id>	Hold the dropdown with this exact ImGui id (for example ##units) open. Its list is a separate OS window, so --dump-frame does not capture it.
--mode-sequence <modes>	Switch to each listed mode in turn, one every 30 frames, once the model has settled.
--ignore-caps-lock	Temporary. Caps Lock no longer toggles MatCap for this run, so a capture shows the shading it asked for.
--start-mode <tab>	Open in that tab: retopology, paint, sculpt or voxel. Without it the app opens in Retopology, as always.
--gui-preset <name>	Start with an interface theme applied for this run — a built-in one (Default Slate, Midnight Purple, Forest, Sunset Amber, Crimson Flat, Paper Light) or one of yours. Not saved unless you save Settings.
--refresh-gui-presets	Load every interface theme in your user folder and write it back in the current format (any setting its file lacked filled in at its default, so it looks the same), list them in refresh_gui_presets.txt in the user folder, and exit.
--split-packed <image> <dir>	Split a packed ARM / ORM image’s three channels into separate grey PNGs in that folder, without dialogs.
--head-track-sim <x,y,z>	Head Tracking with no camera: the head held at that position, in metres from straight ahead.
--head-track-test <seconds>	Run Head Tracking with the real webcam for that long, logging what it sees, then close.
--3dmouse-trace	Log a line every frame while a 3Dconnexion device moves the view (with --create-log).

Display / view

Option	What it does
--display <mode> --display=<mode>	Set a view mode on startup; may be repeated. Modes: solid (texture and normal-map display off), uv (show the model’s texture), normal (normal-map overlay), pbr (PBR Preview), wireframe / no-wireframe, vertexcolors, world-normals, depth-map, pbr-settings (PBR Preview plus the PBR Settings window) and gl-settings (the OpenGL Settings window, plain view). The wireframe, uv and normal modes override the saved startup view defaults.
--pbr-preview	Turn PBR Preview on with the standard shader.
--material-variant <n>	Select KHR_materials_variants variant n on load (0-based; out of range keeps the default materials).
--model-texture <n>	Select entry n of the Source Model Textures list on load and switch the UV image source to the model’s textures.
--uvview	Open the flat UV view.
--uv-isolate	Turn on the UV view’s Isolate Selection.
--uvimage-model	Use the model’s own texture as the UV image.
--uv-image-source <n>	UV image source: 0 checker, 1 model texture, 2 grey, 3 generated.
--uv-channel <n>	Use UV channel n (used with --layer-mask-bake).
--vertex-colors	Turn vertex-colour display on.
--show-pbr-layer-row	Open the Layer View row along the bottom of the viewport.
--gl-layer-role <n>	Show the OpenGL view’s raw-texture Layer View for texture role n (-1 = off).
--force-gl-view	Keep the plain OpenGL view for a --dump-frame capture, which otherwise switches PBR Preview on.
--force-shadows <softness>	Temporary. Force OpenGL and PBR shadows on at that softness.
--force-fill-shadows	Temporary. Turn the OpenGL view’s three fill lights on, casting shadows.
--gl-env-reflections <f>	Temporary. The OpenGL view’s HDRI Reflections at that strength (0 turns them off).
--show-bones	Turn the skeleton overlay on.
--show-weights	Turn the bone-weight overlay on.
--show-layer-row	Turn the PBR / OpenGL Layer View row on, as --show-pbr-layer-row does (for captures).

Camera, panes and model orientation

Option	What it does
--orbit-degrees <n>	Swing the camera n degrees around the model before anything else runs.
--zoom <n>	Dolly the camera n mouse-wheel steps after framing (negative zooms out).
--camera <ortho|persp[,fov]>	Projection mode, optionally with the vertical field of view in degrees.
--view-all	Press A (frame everything) once the app has settled.
--view-layout <layout>	Open in a pane layout: single, side, stacked or quad.
--pane-mode <N:mode,...>	Give individual panes their own display mode, for example 1:pbr,2:normals.
--view-split <fx,fy>	Move the pane splitters to those window fractions.
--hover <fx,fy>	Park the cursor at that fraction of the window and hold it there, so a capture shows hover states.
--rotate-quarter <axis>	One Ctrl+arrow quarter turn of the model: x+, x-, y+ or y-.
--stand-up	Press the Animation window’s Stand Up button once the model has settled.
--flip-normals	Flip normals exactly as the F key does.
--resize-mesh <spec>	Rescale the loaded mesh through the same path as the mesh-scale control.
--ctrl-rmb-aim <fx,fy,mode>	Temporary. Replay a real Ctrl+Right-click aim on the mesh in retopo, paint or sculpt.

Verification / automation

Option	What it does
--dump-frame <path>	Write one PNG of the 3D viewport (before the UI is drawn over it) once the model settles, then keep running. Implies PBR Preview unless --force-gl-view is given.
--exit-after-frame	Exit once --dump-frame has written its file. Does nothing without a frame dump.
--export <path>	Export once every job and queue is quiet, without a save dialog; the format comes from the extension. Works after a bare load as a format converter, or after the pipeline options, for example --uvmap-direct --select-materials 0 --transfer-texture-direct --export out.fbx.
--exit-after-export	Close once --export has written its file (and any --dump-frame / --dump-mesh-stats has written its own).
--dump-mesh-stats <path>	Write a deterministic snapshot of the displayed mesh’s counts and array sizes once every startup hook has settled.
--export-rigged-loaded <path>	Write the Loaded Mesh as a skinned glTF, without a save dialog.
--pbr-debug-layer <n>	Start PBR Preview in a Layer View debug channel: 1 albedo, 2 normal, 3 metallic, 4 roughness, 5 ambient occlusion, 6 emissive, 7 bump, 8 opacity, 9 specular F0, 10 anisotropic. Not supported in OpenPBR mode.
--openpbr-shading	Turn on PBR Preview’s OpenPBR shading mode (Ultra only). Implies PBR Preview.
--openpbr-material <path>	Apply a flat open_pbr_surface MaterialX document after import (Ultra only). Node graphs and texture connections are not evaluated. Turn MatCap off first, as it bypasses material lighting.
--openpbr-material-index <n>	The material --openpbr-material targets (default 0).
--reveal-capture <phase,progress[,replay]>	Hold --dump-frame until the Generated Mesh reveal effect reaches that phase and progress (0–1); with replay 1 the effect is replayed.
--material-thumbnails <dir>	Render every Loaded Mesh material on the shader ball and write each one to a PNG in that folder.
--save-project <path>	Save a project file at the end of the Voxel startup flow.
--save-project-after <path>	Save a project file once the vertex-paint, vertex-layers or sculpt stroke hook finishes.
--save-sculpt <path>	Write a .vxs once the model has settled.
--then-open <path>	Open a second file once the first chain of hooks has finished.
--autosave-now	Autosave at the first chance.
--revert-after-load	Run Revert Mesh once the Generated Mesh exists (implies --extract).
--undo-steps <u[,r]>	Once the paint and layer hooks are done, press Undo u times and then Redo r times.
--drop-files <paths>	Temporary. Treat the comma-separated files as dragged onto the window once the model has settled.
--test-displacement-file <path>	Temporary. Assign the image as material 0’s Displacement once the model has settled.
--ui-capture-after <frames> <path>	Capture the whole window, UI included, on that frame after start — for a flow whose last step no other hook waits on.
--recover-autosave <path>	Run crash recovery as if its question had been answered Yes, from that autosave file.
--auto-confirm-promote	Answer Yes when a scripted run asks whether the sculpt on screen should replace the Loaded Mesh.
--workmesh-after-sculpt	Once a sculpt lands in the Generated slot, rebuild the work mesh as a Target Vertex Count change does.

Pipeline (chained)

Each of these implies the ones above it in the chain solve → extract → uvmap → transfer-texture.

Option	What it does
--solve	Run the orientation solve after load.
--solve-position	…then the position solve.
--extract	…then create the new topology.
--uvmap	…then generate a UV map over every material.
--transfer-texture	…then transfer the texture.

Pipeline (direct, no chain)

Option	What it does
--uvmap-direct	Generate a UV map straight after load, without remeshing.
--transfer-texture-direct	Run Transfer Texture against an existing UV map, without the solve/extract chain.
--uv-algorithm <n>	Force the Create UV Map algorithm: 0 Artist (UVAtlas), 1 Lightmap (xatlas), 2 Vertexix (field-guided), 3 Grid Unwrap, 4 Keep Original UVs (the model’s own layout, its textures copied across). Clamped to what the edition allows. Give it before --uvmap / --uvmap-direct.
--make-quads	Run Tris-to-Quads.
--make-quads-repair	Run Tris-to-Quads with the edge-flow repair pass.
--normal-bake	Run Create Normal Map on the created topology once a UV map exists. Runs before --ao-bake when both are given.
--ao-bake	Run Make Ambient Occlusion map once a UV map exists, on whichever mesh is displayed.
--curvature-bake	Run Cavity, Curvature and Edge Maps once a UV map exists, with all three outputs on.
--bake-vertex-colors	Run Bake Vertex Colors on the created topology once a UV map and a baked layer exist (for example after --transfer-texture-direct).
--transfer-vertex-colors	Press Transfer Vertex Colors once a Generated Mesh exists.
--vertex-to-image	Bake the vertex colours into an image once a Generated Mesh with a UV map exists.
--bake-all [levels]	Run Bake All; the optional number sets the height-map subdivision levels.
--select-connected	Run Select Connected.
--revert-after-extract	Revert immediately after extracting.
--assign-image-to-texture	Give material 0 the currently viewed image as its Albedo layer, creating the layer if needed.
--realtime-subdiv <n>	Turn Realtime Subdividing on at level n once the model has loaded.
--realtime-subdiv-style <n>	Realtime subdivision style: 0 Faceted (default), 1 Smooth (Catmull-Clark).
--freeze-subdiv	Freeze the realtime subdivision once it has settled.
--material-factors <mat,metallic,roughness>	Set a material’s metallic and roughness factors (used with --export).
--create-image <mat,role[,grey]>	Create an image for a material role: albedo, normal, metallic, roughness, height, displacement, occlusion, emissive or specular; grey (0–1) sets the fill. May be repeated.
--auto-create-images	Answer yes every time Vertexix asks whether to create a missing channel map.
--keep-original-uvs	Tick 4. Create Topology > Keep original UVs for this run: the topology --extract makes comes out with the model’s own UV layout and its textures, without Create UV Map.
--uv-from-selection <n>	After --uvmap-direct: select the Generated Mesh’s first n faces, run Create UV Map’s from-selection path, check the result, then run Transfer Texture over it.

Selection and parameters

Option	What it does
--select <n>	Select the first n polygons.
--select-material <n>	Select material n in Selection Tools.
--select-materials <a,b,c>	Comma-separated material list for Selection Tools, needed by the selection-driven UV and bake actions.
--uv-material-filter <n>	UV view material filter.
--target-quads <n>	Target quad count.
--texture-bake-resolution <n>	Bake resolution (still clamped by edition).
--method <n>	0 Manual Remesh (AutoRemesher), 1 Auto Remesh (field solver).
--manual-remesh	Manual Remesh’s Create New Topology once the model has settled (after any --density-stroke). Unlike --extract, no solve runs.
--adaptivity <f>	Manual Remesh adaptivity (0–1).
--anisotropy <f>	Manual Remesh anisotropy (0 = square quads, up to 2).
--edge-scaling <f>	Manual Remesh edge scaling (0.1–4).
--preprocess-optimize <0|1>	Manual Remesh Preprocess Optimization (edition-clamped).
--pole-cleanup <0|1>	Manual Remesh pole cleanup.
--pole-cleanup-distance <n>	Maximum pole-pair distance in faces (1–32).
--show-poles	Show poles on the Generated Mesh (and add Poles to the stats line).
--remesh-diagnostics	Capture the Manual Remesh run’s intermediate stages.
--remesh-diagnostics-stage <stage>	When the run finishes, show decimated, isotropic, param or final in place of the Generated Mesh. Implies --remesh-diagnostics.
--remesh-diagnostics-overlays <list>	Comma-separated singular, connections; any other word turns both off.
--cancel-remesh-after-ms <n>	Press Manual Remesh’s Cancel n ms after the run starts and log how quickly it stopped.
--axis-align <f>	World-axis alignment strength (0–1) on steep surfaces.
--flat-axis-align <f>	The same for surfaces facing along the axis (floors, ceilings).
--align-axis <y|x|z>	Which world axis both alignments measure against (default y).
--density-stroke <x0,y0,x1,y1>	Replay one Vertex Density Paint stroke once the model has settled.
--topology-op <name>	Run one Topology Tools action once the model has settled: hide-selected, isolate, unhide or invert-hidden.
--topology-select-brush <x,y[,radiusPx]>	One Select Brush dab at that viewport position, optionally at a given radius.
--arm-select-tool <n>	Arm Selection Tools tool n (0 brush, 1 lasso, …) just before --vertex-paint-stroke, which must then paint nothing.
--align-to-boundaries	Tick Auto Remesh > Advanced > Align to boundaries for this run.
--keep-border	Tick Auto Remesh > Advanced > Keep border for this run (the solve aligns to the boundaries as well).

Painting test hooks

Stroke coordinates are fractions of the viewport (0–1), not pixels; a radius, where given, is in pixels.

Option	What it does
--paint-stroke <x0,y0,x1,y1[,radiusPx]>	One real Paint Brush stroke through the full live-dab and commit lifecycle.
--paint-tool <n>	Which tool --paint-stroke uses: 0 Paint Brush (default), 1 Blur, 9 Smudge.
--paint-third-brush	Append a third Paint Brush stroke after the --paint-tool one.
--paint-normal-mode <n>	Normal-channel mode for --paint-stroke: 0 Additive, 1 Replace, 2 Blur, 3 Normalize.
--paint-blur-strength <percent>	Blur strength as the slider shows it (100 classic, 500 maximum).
--paint-brush-mode <n>	The brush tip’s blend (Brush Mode) for the run.
--paint-live-test <channels> <x0,y0,x1,y1,radiusPx> <frames>	A stroke spread over that many frames with a per-frame cost breakdown; channels is albedo, greyN or normal.
--paint-live-undo	Check that --paint-live-test’s stroke undoes exactly.
--paint-spacing <percent>	Force the brush spacing, for example 500 for 500%.
--paint-select-brush <path>	Select an image brush.
--paint-dynamics <index=value,...>	Force Brush Dynamics fields by numeric index.
--paint-mask-stroke <x0,y0,x1,y1>	Paint a Paint Mask stroke, then a red test stroke across it.
--paint-drag "fx,fy>fx,fy[,sculpt]"	One real left-button drag in the Paint tab; ,sculpt turns on Paint while sculpting.
--paint-drag-dump <dir>	Where --paint-drag writes the painted layer and slot images.
--paint-dense-capture	Dense stroke-capture mode for headless paint hooks.
--paint-curve-fit [amount]	Turn Brush Shape’s Curve Fit on, optionally at a Curve amount (0–1).
--paint-screen-preview	Turn Screen Stroke Preview on.
--paint-target <auto|texture|vertex>	What Paint paints into.
--paint-gradient <x0,y0,x1,y1[,shape,wrap,reverse,preset]>	One Gradient tool drag.
--paint-bucket <x,y[,tolerance,contiguous]>	One Bucket click.
--paint-shape <x,y/x,y/...>	Draw a shape through those points.
--paint-path-test <x0,y0,x1,y1,...>	The Stroke Tool end to end: lay the points, stroke, move a point, grow one.
--paint-smudge <wet,rate,strength>	Temporary. Smudge’s wet mix, colour rate and strength (0–1).
--levels-layer <mat,inBlack,gamma,inWhite[,...]>	Add a Levels layer to that material’s Albedo and open it in the Levels window.
--layers-delete <mat>	Delete the selected layer of that material’s Albedo stack once the fill/gradient hooks are done.
--add-paint-layer <n[,folder]>	Give every material’s paintable roles n Paint layers before a paint hook runs.
--create-layer-picker <0|1>	Press the Paint palette’s + button for a new layer.
--stencil-armed [path]	Switch to Painting with the Stencil on, optionally loading an image. Put the model path before this option or it is taken as the stencil.
--clone-stroke <ax,ay,x0,y0,x1,y1>	A real Clone Brush episode: Alt+click at (ax,ay), then a stroke.
--clone-stroke-channels <list>	Which channels --clone-stroke clones: albedo, normal, greyN.
--clone-aligned <0|1>	The Clone Brush’s Aligned pattern.
--clone-surface-normal	Turn on the Clone Brush’s Surface Normal projection.
--vertex-paint-stroke <x0,y0,x1,y1[,radiusPx[,tool]]>	One vertex-colour stroke, logged and undone to check the undo.
--vertex-paint-channels <spec>	Temporary. Which channels --vertex-paint-stroke lays down.
--vertex-layers-test <x0,y0,x1,y1[,radiusPx]>	Vertex paint layers end to end through the Layers window.
--material-layers-test <x0,y0,x1,y1[,radiusPx]>	Texture material layers end to end on the first material with an Albedo image.
--vertex-material-test	Paint a known pattern into the PBR vertex channels.
--image-viewer-stroke <u0,v0,u1,v1>	One Image Viewer brush stroke in UV space, then an undo check.
--mask-shape <owner:shape>	Arm the screen-space shape capture for a mask, for example paint:lasso.
--layer-mask-bake <type[,material[,invert[,asLayer]]]>	Bake a layer mask: occlusion, cavity, curvature or edge.
--layer-mask-race	Layer-mask race-condition test.
--layer-mask-window <spec>	Open the layer-mask window after any mask bake in the same run.
--vertex-layer-mask <type[,invert[,samples[,distance[,smooth]]]]>	Bake a vertex-layer mask of that type.
--vertex-probe-bake <type[,samples[,distance[,smooth[,mask]]]]>	Run a vertex probe bake of that type.
--auto-mask <key=value,...>	The brush’s Auto-Masking for the run (cavity, edges, sens, blur, normal, …).
--color-pick-test	Colour-picker test.
--brush-drag-test	Brush drag test in the Paint tab.
--pbr-key-test	Press P for real, twice, and check the mode switch.
--normal-flip-test	Normal-flip test once the load settles.
--wrap-continuity	After the curve hook, count mesh edges whose ends land far apart in the wrapped pattern.
--wrap-probe <x0,y0,x1,y1,n>	After --vertex-paint-stroke, sweep the cursor and log the wrap’s tile box at n points.
--wrap-project <0|1>	The aligned wrap’s Project setting.
--curve-bend-follow <percent>	The aligned curve’s bend-follow amount.
--curve-centre-point <i>	After the stroke hook lays its curve, select point i and centre it in four directions.
--curve-drawing	Arm curve drawing after the vertex paint stroke.
--stroke-twice	Run the vertex paint stroke hook’s stroke a second time and log what changed.
--surface-cords-demo	An isolated verification fixture for surface cords; never enabled by settings.
--paint-path-input <ops>	The Stroke Tool driven by real mouse input.

Brushes and pen

Option	What it does
--brush-tip <angle,roundness,flipX,flipY[,...]>	Temporary. The tip’s shape, re-applied after every brush pick.
--brush-tip-roundtrip <dir>	Write a brush tip to a .vbr in that folder and read it back.
--brush-falloff-curve <in,out>	The brush’s Ease in / Ease out (-1–1 each; 1,1 is the default Smooth).
--brush-airbrush <rate>	Airbrush on at that many dabs a second.
--brush-wet-edges	Wet Edges on.
--brush-noise	Noise on.
--brush-dual <mode:size:spacing:scatter:count:tip>	Dual Brush settings.
--brush-texture <mode:depth:scale:name>	Brush texture settings, for example multiply:100:100:paper.
--brush-control <spec>	Brush control settings, checked against the first dabs.
--brush-new-folder <name>	Create a brush folder.
--brush-move-to <folder>	Move the current brush to that folder.
--save-brush-as <name>	Confirm Save Brush with that name.
--brush-export <path>	Export brushes to that path without a dialog.
--import-brush <path>	Temporary. Import a brush file as the picker’s + button would.
--pen-sim <pressure[,tiltX,tiltY[,rotation]]>	A simulated pen held down for the whole run; turns Enable Pen Pressure on.
--pen-curve <in,out>	The pen pressure curve.
--pen-turns <tilt|rotation|both>	Which pen inputs turn the brush.

GPU painting diagnostics

Option	What it does
--gpu-paint-shadow	GPU painting plus a CPU copy of every operation, diffed per texel at stroke end.
--gpu-paint-compare	Paint on the CPU unchanged, then replay the same dab on the GPU and diff.
--gpu-paint-verify	Paint the same stroke on the GPU and the CPU and diff. Needs a model path.
--gpu-blend-verify	Check whether a shader reproduces the CPU blend byte for byte.
--gpu-blend-mode-verify	Check every GPU Brush Mode against the CPU over a value grid; logs and exits.
--gpu-filter-verify	Check the GPU Filter Brush against the CPU on every 8-bit colour; logs and exits.
--gpu-dab-bench	Time one GPU dab on the loaded model, then quit. Needs a model path.
--gpu-paint-shader-copy	Patch display textures with a shader pass instead of a copy (measurement switch).
--gpu-paint-eager-baseline	Control run for the per-dab freeze.
--gpu-paint-mip-refresh	Turn the GPU paint mip refresh pass on.
--gpu-paint-no-mip-refresh	Turn the GPU paint mip refresh pass off.
--gpu-paint-leak-units	Diagnostic: do not restore every texture unit after a GPU dab.
--gpu-paint-direct	Paint straight into the renderer’s own textures.
--gpu-paint-indirect	Paint through a working copy (the control for --gpu-paint-direct).
--gpu-blur	Accepted and ignored; the GPU Blur Brush is already the default.
--gpu-blur-plain	The GPU blur without its warp aggregation.
--blur-serial	Run the CPU blur’s gather single-threaded.
--mip-regional	Opt in to the regional mip patch (off by default).
--mip-verify	Check that the app’s box filter matches the driver’s mipmap generation.
--mip-no-view-filter	Turn off the mip flush’s view filter (A/B test).

Sculpting test hooks

Stroke coordinates are fractions of the viewport (0–1). Strokes target the Loaded Mesh unless --sculpt-target generated is given.

Option	What it does
--sculpt-tool <n>	0 Brush, 1 Inflate, 2 Smooth, 3 Flatten, 4 Pinch, 5 Crease, 6 Fill, 7 Scrape, 8 Grab, 9 Rotate, 10 Layer, 11 Mask.
--sculpt-radius <f>	Brush radius.
--sculpt-intensity <f>	Brush intensity.
--sculpt-negative	Invert the brush.
--sculpt-stroke <x0,y0,x1,y1>	Replay one full sculpt stroke once the model has settled.
--sculpt-mask-stroke <x0,y0,x1,y1>	Paint a mask stroke before --sculpt-stroke runs.
--sculpt-target generated	Aim the sculpt strokes at the Generated Mesh. Only the word generated is accepted; anything else is read as a file to open.
--sculpt-stroke-repeat <n>	Replay the stroke n times, 40 frames apart.
--sculpt-stroke-steps <n>	Re-aim the stroke onto the surface at n points along its path, as a real drag does.
--sculpt-symmetry <axes[,origin]>	Symmetry on any of x, y, z, and log how well mirrored vertices match.
--symmetry-radial <n[,x|y|z]>	Radial symmetry with n copies around an axis (default y).
--sculpt-mask-op <op>	clear, fill, invert, blur, sharpen, grow, shrink or selection.
--sculpt-mask-opacity <f>	Mask overlay opacity.
--sculpt-front-faces <0|1>	Temporary. Front Faces Only.
--sculpt-rake <0|1>	Temporary. Rake.
--sculpt-drop <0|1>	Temporary. Drop.
--sculpt-alpha <path>	Temporary. Brush alpha image.
--sculpt-alpha-orient <turns,mirrored>	Temporary. The alpha’s turn and flip.
--sculpt-alpha-reverse	Temporary. Invert the alpha.
--sculpt-dyn <key=value,...>	Brush Shape Dynamics and Scattering (sizeJitter, angleJitter, scatter, …).
--sculpt-accumulate <0|1>	Accumulate.
--sculpt-aligned <0|1>	Aligned Brush.
--sculpt-align-target <x,y>	Place the Aligned Brush target at that viewport position before the stroke.
--sculpt-align-gizmo <move|rotate|scale>	Select the target and show its handles.
--sculpt-align-aim <x,y,z>	Turn the target to face that world direction.
--sculpt-align-roll <degrees>	Roll the target, as the Left/Right arrows do.
--sculpt-align-wrap <0|1>	Wrap the aligned pattern.
--sculpt-align-keys <keys>	Temporary. Press those keys for real once the target is placed, for example Up,Right,PageUp.
--sculpt-align-aspect <x,y>	Temporary. The tile’s aspect from the start.
--sculpt-wrap-taper <0|1>	Temporary. Taper with Limb.
--sculpt-follow-curve <x,y;x,y;...>	Temporary. Lay a Follow Curve through those points before the stroke.
--sculpt-target-mouse <axis>	Temporary. Target Mouse on, wrapping round world axis 0 X, 1 Y or 2 Z.
--sculpt-rotate-arc <f>	Sweep the Rotate stroke’s mouse round the click by that arc.
--sculpt-max-intensity <f>	Maximum Intensity on, at that fraction of the radius.
--sculpt-undo-restroke	Temporary. Undo the stroke and make it again in the same frame.
--sculpt-undo-all	Undo every replayed stroke afterwards.
--sculpt-layer-test	Add a sculpt layer before the stroke and check hiding it restores the mesh.
--sculpt-paint	Paint while sculpting on for --sculpt-stroke.
--sculpt-paint-checks	The same, plus undo and order checks.
--sculpt-paint-bg <r,g,b[,a]>	Background paint colour on, with Paint while sculpting.
--sculpt-paint-layers <channels>	A new paint layer on each named vertex channel before the --sculpt-paint stroke.
--sculpt-then-leave [voxel]	After the strokes, switch to Retopology (or to the Voxel tab).
--sculpt-merge-test	Check the sculpt once it has become a node in the Voxel scene.
--dyntopo <px>	Dynamic topology on at that detail size.
--multires-test <n>	Subdivide, push a bump into the top level and step down.
--multires-show <k>	Show multiresolution level k once the levels exist.
--rebuild-subdivide [smooth|linear]	Run the palette’s Rebuild by subdivision, optionally choosing the style.
--rebuild-level <n>	Rebuild detail, 1–5.
--rebuild-ui <show|press|raise>	Open the Sculpt tab and optionally press Rebuild through the memory check.
--rebuild-keep-separate <0|1>	Rebuild’s Keep Separate.
--revoxelize [size]	Rebuild by voxels, optionally at a voxel size.
--repaint	Run the palette’s Repaint (albedo into vertex colours).
--gpu-sculpt-shadow	Run GPU sculpting with a CPU shadow for comparison.
--gpu-sculpt-check	Compare the GPU’s copy of the mesh against the CPU’s.
--gpu-vertex-paint-shadow	Run GPU vertex painting with a CPU shadow for comparison.
--gpu-pick-shadow	Run GPU picking and the BVH pick side by side and compare.
--gpu-resident-selftest	Self-test of the GPU-resident mesh once the model settles.
--sculpt-move-mode <n>	The Move brush’s reach: 0 Volume, 1 Surface, 2 Whole piece.
--pose-test	Sculpt, the Pose tool, then lay, bend and measure a joint set.
--pose-test-gizmo	--pose-test, then a second joint set started on the elbow and the elbow’s move and turn handles up, for a capture.
--pose-from-bones	Sculpt, the Pose tool, then Joints from Bones on the loaded model, its weights measured against the file’s own.
--accordion-click-test	Real clicks on Sculpt’s Modify and Transform bars and Modify’s pin — open, pin, open another, unpin — each checked and logged.
--mesh-slice-test <style>	Once a Generated Mesh is up (chain it after --revoxelize), Sculpt with the Mesh Tree open and the largest mesh sliced down the middle of the view: 0 even, 1 on the voxel grid. Add 10 to leave the tool off and nothing selected afterwards; add 20 to also leave the new half where the cut made it.
--mesh-cut-tool <11–15>	The cut tool --mesh-slice-test uses: 15 Slice (the default), 11–14 a circle outline as Lasso, Box, Circle or Poly.
--mesh-cut-repeat <n>	--mesh-slice-test cuts n times, one after another.
--mesh-cut-density <f>	The slice face’s density for the cut hooks.
--mesh-cut-inside-new	--mesh-slice-test’s cut opens onto a new inside surface, and its faces are counted.
--mesh-slice-capture <png>	Capture the window, UI included, 30 frames after --mesh-slice-test’s cut has landed and the new part has been turned to show its cut face.
--mesh-cut-arm <11–15>	Once a Generated Mesh is up, Sculpt with the Mesh Tree open and that cut tool armed.
--lmb-drag "x,y>x,y>...[,alt]"	After --mesh-cut-arm, a left-button drag replayed as real input, reporting whether the view turned.
--mesh-move-test	Once a Generated Mesh is up, move its biggest mesh with the GPU pass and check the result.
--mesh-save-selected <path> --mesh-load-into-sculpt <path>	Where the bottom panel’s Selected mesh Save and Load write and read, instead of asking.
--send-cap-test <n>	Send to Sculpt on the first shape with the dialog’s limit set to n and a real Enter pressed; the polygons that land are counted.

Voxel mode test hooks

Positions are fractions of a pane (0–1); @pane picks which pane.

Option	What it does
--voxel-mode	Enter Voxel mode.
--voxel-add <shapes>	Seed the scene with primitives.
--voxel-array <n[,size,gap,radius]>	An n×n×n grid of rounded boxes, for timing.
--voxel-create	Run Create Mesh once the shapes are in.
--voxel-leave-to <sculpt|paint|retopo>	Leave Voxel mode for that tab.
--voxel-save <path>	Save the scene to a .vxv.
--voxel-load <path>	Load a .vxv.
--voxel-resolution <size>	Voxel size, with an optional unit (0.5mm, 0.02in; bare numbers are metres).
--voxel-resize <i:x,y,z>	Resize shape i (metres), after framing.
--voxel-move <i:x,y,z[;...]>	Move shapes (metres).
--voxel-select <i,j,...>	Select objects: the first plain, the rest added.
--voxel-op <i:add|subtract,...>	Set top-level nodes’ operation by index.
--voxel-outline	Toggle the outline (as Tab does).
--voxel-delete-all	Delete everything.
--voxel-clipboard <ops>	copy, cut, paste or at:fx:fy:pane, comma-separated.
--voxel-undo <n>	Undo n times, spaced out.
--voxel-redo <n>	Redo n times, spaced out.
--voxel-flatten	Group every root.
--voxel-unflatten	Undo the grouping.
--voxel-flatten-nodes	The Voxel Tree’s Flatten on the selection.
--voxel-mirror <x|y|z|none>	Symmetry plane on every object built.
--voxel-mirror-tool <spec>	Run the Mirror tool.
--voxel-tool <tool>	Engage move, rotate, scale, bounds, taper or off.
--voxel-pick <x,y[,pane]>	Select what a click there would hit.
--voxel-aim <x,y[,pane]>	Replay a real Ctrl+Right-click there.
--voxel-radial-drag "fx,fy>fx,fy[@pane]"	The radial falloff’s right-drag as real input.
--rmb-drag "x1,y1>x2,y2[@pane][,plain]"	A real Ctrl+Right-drag box select; plain drops the Ctrl.
--voxel-freeform <x,y;x,y;...[@pane]>	Draw and close a Free Form outline with real clicks.
--voxel-freeform-apply	Press Apply on the Free Form outline.
--voxel-path-edit <steps[@pane]>	Re-edit the Free Form outline with real input.
--voxel-curve <spec>	Set Curve points directly.
--voxel-curve-draw <spec>	Draw a Curve with real mouse events.
--voxel-draw <kind;pane:x0,y0:x1,y1[;...]>	Draw shapes in panes.
--voxel-brush <spec>	Brush dabs at pane positions.
--voxel-gesture <tool;pane;fx,fy;...>	A finished gesture outline.
--voxel-gesture-panel <n>	The sidebar’s Mask (1), Cut (2) or Add (3) button.
--voxel-face-extrude <pane;fx,fy;ex,ey,ez[;apply]>	Face extrude.
--voxel-mask <spec>	Mask spheres, with optional invert/grow/shrink/blur and cut/keep/split.
--mesh-mask-face <fx,fy[,mode]>	Select (Face) on the surface mesh.
--voxel-shear <spec>	Run the Shear tool; apply keeps it.
--voxel-bend <spec>	Run the Bend tool; apply keeps it.
--voxel-twist <spec>	Run the Twist tool; apply keeps it.
--voxel-mod <spec>	Run Offset, Shell or Clone on the selection; apply keeps it.
--voxel-falloff <spec>	Run a falloff move/rotate/scale; apply keeps it.
--voxel-size-edit <dx[;shift][;apply]>	Edit a shape’s size.
--voxel-adapt <f>	Create Mesh adaptivity (0–1).
--voxel-relax <n>	Create Mesh relax iterations.
--voxel-wireframe-only	Wireframe-only view.
--voxel-wire-hide-back	Wireframe-only with the far side hidden.
--voxel-windows	Open the Voxel Tree and Numeric windows.
--voxel-mesh-preview	Use the meshed preview instead of the ray-marched one.
--voxel-sdf-verify	Check the ray-marched and meshed distance fields agree.
--voxel-sdf-nocache	Trace every pane every frame (A/B timing of the pane cache).
--voxel-edit-bench <n>	Nudge one shape n times, waiting for the preview each time.
--voxel-perf <n[:max][:spin][:drag][:still][:cpu]>	Time n frames once the scene settles, log the average and quit.
--voxel-chain "x,y,z,r[@parent];...;sym=x|y|z;blend=b"	A Sphere Chain built from world metres, one ball per entry. A ball’s parent is the entry before unless @index names another; @-1 starts a new chain. Logs what it made.
--voxel-chain-input <ops>	The Sphere Chain tool by real mouse and keys: arm, sym=x|y|z|off, click:P:fx,fy, rclick:P:fx,fy (a new chain), drag:P:fx0,fy0:fx1,fy1 (also shiftdrag, ctrldrag), key:[ / ] / del / esc / enter, wait:N, log, quit. P is the pane.
--voxel-send-test	Once --voxel-add’s shapes are in, group every root after the first, send the first and the group to Sculpt, and report the Mesh Tree when they land.
--voxel-send-test-loaded	The same, onto the loaded model as it is (it waits for the import, not for a sculpt).
--lathe-spin-test	The Lathe button spinning a shape.

Node editor and presets

Option	What it does
--node-editor	Open the Node Editor.
--node-editor-test	Open the Node Editor and log positions and state for a real-input test.
--node-layer-test	Apply a test graph to the albedo material as a Node Layer.
--node-preview-flat	Show every graph’s previews on a flat square.
--node-face-normals	With --apply-preset, switch the applied layer to Face Normals.
--node-vxn-test <path>	Export the test graph to a .vxn, import it back and compare.
--node-presets-test	Save the test graph as a preset, list it and apply it.
--node-presets-probe	Open the Node Presets window and log each tile’s screen position.
--node-nav-test	Drive the Node Editor with synthetic pan and zoom input.
--node-export-test <dir>	Node export test, written to that folder.
--node-group-ui-test	Group, enter, exit, ungroup and undo through the Node Editor, capturing each stage.
--graph-brush-test	Paint the test graph with the graph brush and check it against the graph’s bake.
--texel-raster-probe	Score the CPU rasteriser variants against this GPU’s coverage.
--apply-preset <name>	Apply a node preset.
--apply-preset-editor	With --apply-preset, open the Node Editor on the applied graph and capture it.
--apply-preset-editor-flat	The same, with flat previews.
--preview-scene-test <png>	Render a sample graph on the Preview Scene and write it as a PNG.
--write-sample-presets <dir>	Write the shipped sample presets to that folder.
--dump-node-types <file>	Write every node type’s sockets and parameters as text, then exit before any window opens.
--manual-node "op|op|..."	The Node Texturing manual’s captures, one op a frame: graph:, file:, apply:, settle:, editor, panel:, open:, group:, pan:, wait:, shot:, quit.
--apply-preset-material <name|index>	With --apply-preset, the material the preset goes onto (otherwise the first one with a base-colour texture).
--graph-brush-preset <vxn>	Use a node preset as the brush for one stroke on the mesh on screen; every texel or point it changed is checked to have moved toward the graph’s value.
--graph-brush-stroke <x0,y0,x1,y1,radiusPx>	The stroke --graph-brush-preset draws (default 0.4,0.5,0.6,0.5,60).
--layers-scale-probe	With --graph-brush-preset: keep the Layers window open and log the node brush layer’s Scale field and how many re-bakes ran, once a second.
--node-wait-generated	--vertex-node-test and --apply-preset wait for a Generated Mesh on screen (chain --extract or --uvmap-direct before them).
--vertex-node-test <dir>	Every .vxn in that folder evaluated over the Loaded Mesh’s vertices on the GPU and the CPU, compared and timed; then one applied as a vertex Node Layer and checked.
--vertex-node-apply <name>	Which preset --vertex-node-test applies (otherwise the first).
--vertex-node-supersample	After --vertex-node-test’s apply, turn per-corner supersampling on and refill the layer on the GPU and on the CPU, which must agree.
--node-mesh-query-cpu	The Generated Mesh’s texel mesh queries take their CPU fallback, so it can be seen working on a GPU that never declines.
--node-preset-ui-test	With --node-layer-test --node-editor: the Node Editor’s Save as Preset into a new folder, then Load .vxn back, through the buttons’ own requests.
--smart-import <kind> <paths>	Smart Import without dialogs. Kind is files, folder, gltf, zip, blend or arm; separate several paths with |.
--smart-import-dry	Log what Smart Import would make, and write nothing.
--smart-import-requester	Open the Smart Import requester (for a capture).

Surfaces and Scratch Pad

Option	What it does
--apply-surface <name>	Click a Surface Presets tile by name.
--edit-surface <name>	The tile’s right-click Edit Surface.
--surface-missing-answer <all|each|cancel[,viewer]>	Answer the “this surface needs more layers” prompt; ,viewer ticks Open Image Viewer first.
--preview-wrap <x,y>	The Material Preview’s Wrap X/Y.
--pad-load <path>	Load an image or .vsp onto the Scratch Pad.
--pad-save <path>	Save the Scratch Pad to a .vsp.
--pad-map <idx[,out.png]>	Generate one of the pad’s maps, optionally writing it as a PNG.
--pad-clone <cx,cy,pu,pv,x0,y0,x1,y1>	The Scratch Pad round trip: capture the view, Alt+click the pad, stroke.
--pad-hold-assign	Leave the --pad-load assign popup open so it can be captured.

Op-by-op drivers

Each takes one quoted list of operations and runs one a frame, with real mouse and key events where the tool is driven by hand. Points are fractions of the 3D view (0–1). Separate the operations with semicolons (;) — the Mesh Tree’s take commas — and end the list with quit, or the window stays open when it is done.

Option	What it does
--alpha-drag-ops <ops>	Alpha Drag in Paint and Sculpt, Paint Shapes and the Text tool — and Auto Remesh’s field tools: otool=N (0 none, 1 Comb, 2 Scare, 3 Magnet), osolve / psolve (Solve Orientation / Position Field), waitsolve (hold while a solve runs), strokelog[:label] (each field stroke and how far the field is off it; hidden strokes are marked), tvc=N (commit a Target Vertex Count as the slider does). Common ops: tab=, drag:, click:, key:, undo, wait:N, shot:path, quit.
--uv-edit-ops <ops>	The UV Editor through its own requests (it opens the editor): selection, moves and turns, the UV tools, measures and views. checkermodel and texturedmodel put the checker or the generated textures on the model; shot: / shot3d: capture.
--uv-editor	Open the UV Editor once the model has loaded.
--uv-input-test	The UV Editor’s canvas driven with real mouse and key events.
--quad-patcher-ops <ops>	The Quad-Patcher by real mouse and keys: open, tool=N, click:, drag:, key:, finish, undo, shot:, …
--stitch-ops <ops>	The Stitch Creator, op by op.
--split-ops <ops>	The Model Splitter, op by op.
--model-check-ops <ops>	The Model Check window, op by op.
--keypad-ops <ops>	The keypad’s functions, keys pressed for real.
--mesh-tree-ops <op:index,...>	Mesh Tree actions through its window’s request queue — hide / show, lock / unlock, dup, del, sel, add (Shift-select), under — the tree logged after each. An empty op lets it run with nothing loaded.

Performance and rendering diagnostics

Option	What it does
--frame-perf <n[:spin][:hover][:zoom]>	Once the model is loaded, time n frames, optionally while orbiting, hovering or zooming.
--no-vsync	VSync off for this run, for timed runs.
--gl-debug	Create an OpenGL debug context and log every driver message.
--coarse-preview	Hold the navigating state on so the coarse draw can be seen.
--spatial-order <on|off>	A/B switch for the spatial face order a Rebuild lands in.
--facing-cull <on|off>	A/B switch for culling chunks that face away.
--pbr-roundtrip	Temporary. PBR Preview on for a while, then back to the OpenGL view, logging whether it re-rendered.

Crash-handler self-tests

Option	What it does
--crash-test	Crash deliberately to prove the crash handler writes a dump.
--crash-test-stack	Overflow the stack deliberately, the case only the separate dump thread can survive.
--crash-test-worker	Crash on a worker thread rather than the main one, to check that a fault there still writes a dump and its sidecar.