DeepParallax Studio Help

DeepParallax Studio turns a single deep sky or nightscape image into a stereo 3D result: parallax motion, side-by-side stereo, anaglyph, and flyby video, driven by a depth map assembled from several cues (luminance, structure, narrowband, color, external maps, and an internal sculpting editor).

Getting started

Two minutes to your first parallax motion

Open a deep-sky image: File > Open Image..., or simply drag the file onto the window. The common picture formats all work; XISF is read directly and keeps its astrometric solution.
Let the first render finish - a few seconds. The status bar shows the view and image size when it is done.
Press Play parallax motion in the toolbar (or View > Play parallax motion). The image starts to move: nearer material sweeps, farther material holds back, and the stars ride at their own depths.
While it plays, drag Amplitude amount on the Parallax tab and watch the motion reach further. We can also adjust the Parallax amount to strengthen or ease the parallax motion, although values higher than the default 20 tend to cause noticeable distortions. Every control works like this - adjust, and the playback follows.
When you like it, the Export controls on the Parallax tab write the motion as a video, and File > Export... saves any still view.

Everything else in this manual refines what just happened: better depth (the Depth and Shaping tabs), better stars (the Stars tab), designed camera moves instead of a fixed sweep (the Flyby Editor and 3D flight), and finished output (the Post tab and the export sections).

The window at a glance

File > Open Image...: load a source image. XISF is read directly, keeping its astrometric solution; the common picture formats (PNG, JPEG, TIFF and the rest) are read as pixels.
File > Open Project...: load a .dpproj project file.
The left panel's five tabs (Stars, Depth, Shaping, Parallax, Post) hold every parameter, organized by what they affect. They stay disabled until an image is loaded.
The right side shows a live preview: switch views from the toolbar or the View menu (Original image, Depth map, Anaglyph, Side-by-side stereo, Starless image, Stars only, Starless + synthetic stars).
Start playback from the toolbar or the View menu (Play parallax motion, Play flyby). While it plays, a slim timeline appears under the canvas; drag its handle to scrub to any frame.
Drag and drop a file onto the canvas to open it: an image, a .dpproj project, a .dpsc flyby script, or a .dpcol color depth profile.

Main window

The five settings tabs on the left, the live preview on the right, and the status bar along the bottom.

The views that show no depth (Original image, Starless image, Stars only, Starless plus synthetic stars, and the star overlay) do not rebuild the depth map when you move a depth-related control. Nothing is lost: the rebuild happens the moment you select a view that does show it, and it happens straight away if the Star Distance Distribution chart, the Depth Modelling editor or a flyby depth view is open, since those read the depth too.

Status bar

Right side of the window, updated on every render (blank fields until an image is loaded):

View: ...: The current preview mode and image size, for example View: Anaglyph (1920 x 1080).
Stars: ...: How the star layer was obtained, and (where it applies) which depth model is placing the stars. off: Star separation is unchecked, stars stay flattened into the image. Detected: classical star detection. AI: AI star separation. Starless+stars: the source came from a loaded project or Load stars + starless. Synthetic: stars generated from the real depth star catalog at their real distance. Except for Synthetic (which always uses real distances), the mode is followed by the active depth model, for example Stars: Detected / Scattered; when the model is Real Star depth, the model name is left off since the Real depth indicator already covers it.
● AI: Lit when AI Star separation is on and a model is loaded.
● Real depth: Lit when real catalog distances are driving the star layer (Real Star depth model, or Synthetic mode) and an astrometric solution and catalog are both available. Shows the open catalog's total star count in millions, for example Real depth (33.5M stars).

Status bar

View, Stars, and the AI / Real depth indicators, read left to right.

Stars tab

Star separation

The master switch for the whole tab. Detects or generates stars and treats them as a separate depth layer, so they float in 3D over the structure rather than being flattened into the image. Turns every section below on or off. On by default.

Load stars + starless (Tools group toolbar button) is the third way to get a star layer, besides detection and AI separation: pick a starless image and a matching stars-only image and load them directly as the two separated layers, the same way a PixInsight-exported starless+stars project does. Use it when you would rather separate the stars with a dedicated tool first and bring both results here; the star layer then comes from what you loaded, not from Studio's own detection. The two files are remembered together under File > Open Recent > Recent stars + starless, as a single entry that reopens both.

Star detection

Classical detection parameters, used when Synthetic real depth stars is off.

Threshold: Detection threshold, in sigma above the background. Lower catches fainter stars; higher keeps only the brightest. Default 2.0.
Min brightness: Minimum peak brightness for a detection. Raises the floor so faint noise specks are not counted as stars. Default 0.10.
Max star radius: Reject blobs larger than this radius, in pixels, so nebulosity and extended structure stay out of the star layer. Range 3 to 200, default 50.
Background scale: Scale, in pixels, of the background model subtracted before detection. Larger values follow smoother, broader gradients.
Remove companions: A bright star's glow is wide enough that fainter stars sitting inside it are detected as part of it: one sprite, one depth. Those stars then travel with the bright one through every parallax move and flyby instead of having a parallax of their own.

This erases them. Their light is replaced by the glow that would have been underneath, so the bright star stays smooth and continuous and the faint ones are simply not drawn. 0 (the default) keeps every star and changes nothing. Higher removes progressively brighter companions; at 1 only the brightest star in each clump survives. A blob can never lose more than a quarter of its light to this, so the star you are looking at cannot vanish.

The removed stars are gone from the render, so how far to take this is a judgement call rather than a setting with a right answer. It applies to AI separation and to a loaded starless + stars pair; classical detection does not use it.
Split merged stars: In dense starfields, detection can weld a whole neighbourhood of similar stars into one detected star: one depth and one parallax for the entire group. With this on (the default), such groups are split back into individual stars, each with its own depth and its own catalog match. In a rich field this recovers tens of thousands of stars that would otherwise move as rigid plates.

A few stars may still share a single detection even with this on: pairs or triples so close that their glow merges into one shape offer no clean line to cut along, and splitting them would damage the glow itself. These cases are a vanishingly small fraction of the star population in any real image, and for the ones noticeable enough to matter, the Sprite eraser can reshape the detected star by hand.

It applies to AI separation and to a loaded starless + stars pair; classical detection does not use it. Turn it off to reproduce renders made with earlier versions.

Star depth

How the star layer is placed in depth.

AI Star separation: Use a trained AI model to separate stars from the image for the de-starred base, instead of classical detection. On by default, and the recommended setting: separating stars from a plain starry image by classical detection is the harder problem, and the model handles crowded fields and large stars far better. Requires a model (Edit > Preferences > AI Star Separation model); with none loaded, classical detection is used. When this is on, every separated blob is taken as a star at whatever size it is, so the Star detection section's Max star radius and Background scale do not apply and are greyed out.
Depth model: How each star's depth is assigned. Flat: all stars on one plane. Brightness: brighter stars sit nearer (dramatic, but brightness is not real distance). Scattered: each star gets a random depth (an even volume, no star dominates). Real Star depth: each star is placed at its real catalogued distance, needing the image located in the sky and the real depth star catalog; unmatched stars fall back to Scattered.
Star plane: The depth plane stars are placed at: higher is nearer (pops forward), lower is farther.
Star spread: How much depth the stars span around the star plane, in Brightness or Scattered mode. 0 puts them all on the plane; higher gives a deeper starfield.
Star floatation: How strongly stars are pulled to the star plane. 0 disables the star layer; 1 places stars exactly on the plane.
Foreground pop: Lifts detected stars toward the viewer so they sit in front of the nebula or galaxy structure.
Occultation threshold: Lets the scene hide stars that lie behind it. A star is occulted wherever the structure in front of it is nearer, and only over the pixels actually covered, so it can be partly cut by an edge and emerge again as a flyby moves past. Stars at or nearer than this threshold are always drawn, so 0 disables occultation entirely and higher values expose more stars to it. This needs Star floatation above 0 to do anything: at 0 each star sits exactly on the structure beneath it, so there is nothing for it to be behind. It is most telling with the Real Star depth model, where catalog distances can genuinely place a star behind a nebula.
Max stars: Render only the brightest N detected stars and drop the faintest (leftmost setting is "All"). Useful on very dense fields where thousands of faint stars add clutter without much depth. No effect with the Flat model.

Real depth stars (sub-group, Real Star depth mode)

Unmatched stars: What to do with detected stars that did not match the catalog (too faint, or no reliable parallax). Matched stars always get their real depth. Scattered: random depth; Brightness: brightness-based depth; Omit: do not paint them, so only matched stars appear.
Keep (Omit only): Omit alone would also drop a brilliant star the catalog happens to miss, leaving a hole where the eye expects one. This keeps some unmatched stars anyway - either a count (N stars) or a % (a share of them) - and kept stars are placed by brightness. The first choice on the row is how that set is picked:

brightest keeps the top N by peak - the right pick for its original purpose, exempting a handful of bright stars. But because a kept star's depth follows its brightness, choosing a large N this way selects stars of nearly the same brightness, and they land together in a thin slab at the front, with almost no star depth between them.

balanced spends 30% of the budget on the outright brightest, so nothing brilliant is ever dropped, and fills the remaining 70% with a sample spread across the brightness range in proportion to how the stars actually populate it - so faint (deep) stars are represented in the same measure they exist. The kept set then spans the depth axis the way the full population does. Prefer it whenever you keep many stars, say hundreds or more.

The count or share is relative to the unmatched stars of the image you are working on, and that is deliberate: a star's peak value means different things in a detected image and in a loaded stars-only layer, so a fixed brightness level would be strict in one and let almost everything through in the other. Unticking the checkbox omits every unmatched star, with no exceptions. The row appears only while Unmatched stars is set to Omit.
Distance scale: Relative: the nearest matched star is pinned to the front and the farthest to the back, so the whole spread is used (punchy, per-image). Absolute: distances map onto a fixed scale, so a star keeps the same depth regardless of the frame (faithful, usually subtler, pairs well with Depth exaggeration).
Depth exaggeration: Amplifies each matched star's depth offset. 1.0 is the true relative depths; higher pushes near and far stars further apart for a stronger 3D pop.
Locate in the Sky...: Opens the plate-solve dialog when the image has no astrometric solution yet. Real Star depth and Synthetic stars both need this before they can use real distances. When automatic solving cannot do the field, Manual solve identifies it by hand.

Advanced Star Profiling

Shapes the soft edge of every separated star (detected, AI, or a loaded starless + stars project; not synthetic stars). Collapsed by default. The section's own title checkbox is the on/off switch: turn it off for hard-edged, tightly clipped stars. Most images never need these; reach for them only when stars look too harsh or too soft.

Soft star edges (title checkbox): Master switch for the whole section. On (default) gives each star a soft, feathered rim; off leaves it hard-edged. Unchecking greys out the two sliders below.
Star glow: How far each star's soft halo reaches outward. Higher makes stars wider and glowier.
Star softness: How smoothly each star's rim fades. Higher blurs the edge more for a softer star.

The Defaults button restores the standard soft look (on, both sliders centered); OK keeps the current values and collapses the section, while Cancel reverts to the values it had when you last opened it.

Synthetic real depth stars

Replaces the detected stars with a starfield generated from the real depth star catalog: real colors (BP-RP) and real distances, each star floating at its true depth. Needs the image located in the sky and the star catalog; the stars are drawn over the de-starred base.

Limiting magnitude: Faintest Gaia G magnitude to include. Higher pulls in more (fainter) stars, denser and slower; lower keeps only the brighter stars.
Star brightness: Overall brightness (flux gain) of the synthetic stars. They carry no image flux of their own, so this sets how bright they render.
Star size: Core size (approximate FWHM, in working pixels) of the synthetic stars. Larger is softer and bigger.
Faint star boost: Fidelity versus visualization. At 0 (default), faint stars render at their true physically accurate brightness, which can be nearly invisible even at max Star brightness, since real stellar magnitudes span a huge range. Raising this gamma-compresses the brightness curve so faint stars are pulled up disproportionately more than bright ones, without reordering them, so the faintest catalog stars (and their parallax motion) stay visible.

Star overlay

Marks the detected stars on the source image, so you can see which ones the detector found and, in Real Star depth mode, which ones carry a real catalog distance. Turn it on from View > Star overlay or the toolbar button. Colors: green is a Gaia match, cyan a Hipparcos match, amber a star with no catalog match (given a synthetic depth). Outside Real Star depth mode there is no cross-match, so every detected star is amber.

The drop-down arrow beside the toolbar's Star overlay button chooses which stars are marked: All, Known stars (matched, green and cyan alike), or Unknown stars (no match). It appears in Real Star depth mode only - the other star-depth models do not cross-match, so nothing there tells one star from another.

Reading a crowded field

A rich field can carry tens of thousands of detected stars, far more marks than a screen has room for. Three things keep it readable, and none of them hides a star from you.

Marks keep their size on screen: A ring stays the same size however far you zoom, so zooming in spreads the stars apart while the rings stay put. A core that is a solid mass of color when the whole image is in view resolves into separate rings a step or two in. Zoom is the main tool here.
Dots when rings will not fit: Past roughly 2500 marks on screen at once, rings overlap into a wash that says nothing, so each star is drawn as a dot instead. Every star is still marked and the colors still read, so a wide view works as a map of where the matched and unmatched stars are. Zoom in and the marks become rings again as soon as there is room.
Ring only near the pointer: View > Ring only near the pointer marks just the stars around the mouse, and nothing elsewhere. Useful when you want to examine a dense area at low zoom: sweep the pointer and every star is reachable, with no filtering and nothing left out. The setting is remembered.

Lowering Max stars also reduces the marks, but it does so by not detecting those stars at all, so they are missing from the depth result as well as from the overlay. The three above change only what is drawn.

File > Export star overlay writes the markers into the saved image, so a file matches what is on screen. See Exporting the current view.

Depth tab

Depth filters

Smoothness: Spatial scale, in pixels, of the edge-aware depth smoothing. Reduces noise and harsh transitions. 0 disables smoothing.
Edge preservation: How strongly the smoothing keeps depth edges aligned to image edges. 0 smooths across edges like a plain blur; 1 preserves edges strongly, reducing cardboard and halo artifacts. No effect when Smoothness is 0.
Depth gamma: Gamma applied to the normalized depth. Above 1 pushes mid-depths toward the background; below 1 pulls them toward the foreground.

Image depth

A checkable section: the title checkbox both gates the engine cue and enables the controls below. On by default. The main depth cues that read 3D from the image itself.

Luminance weight: Weight of the brightness cue. Brighter regions are treated as nearer (use Invert to swap).
Structure weight: Weight of the local-contrast (detail) cue. Sharper, more detailed regions read as foreground.
Structure scale: Sigma, in pixels, of the high-pass used to extract the structure cue. Larger values respond to coarser structure.
Landscape AI Depth: Weight of a learned depth cue that infers depth from image content. Not for deep sky; use it for nightscapes and landscapes under the sky, where it reads foreground-to-background depth. 0 is off. Needs dp_dmap.onnx next to the app.
Invert depth: Flip the depth ordering, so bright and detailed regions become far instead of near.

Narrowband depth

A depth cue for narrowband (SHO/HOO) images: the balance between two emission channels drives depth. Needs a color (RGB) source. Off by default.

Weight: Weight of the narrowband color cue. 0 disables it.
Near channel / Far channel: Which color channel reads as foreground and which as background.

Shaping tab

The sections here are listed in the order they are actually applied. Color depth and the External depth map fold into the cues from the Depth tab; Structure depth then anchors the whole map at a chosen distance; Depth Modelling composites last, so the sculpted map always has the final word.

Shaping tab

Color depth

Assigns depth by color: pick colors and push matching pixels toward a chosen depth. Useful for SHO/HOO palettes where specific hues should sit nearer or farther. Off by default.

Weight: Overall influence of the color-depth cue. At 1, matched pixels are fully set to their entry depth; lower values blend the assigned depth with the rest of the depth result.
Gamma: Gamma applied to the color-assigned depth. 1 leaves the picked depths literal; above 1 pushes them back, below 1 pulls them forward.
Edge fade: Edge-aware feathering, in pixels, of the color-assigned depth boundaries only. Softens crisp color edges while respecting luminance edges. 0 disables it.
Smoothness: A plain Gaussian blur, in pixels, of the color-assigned depth. Unlike Edge fade, it is uniform and ignores luminance edges. 0 disables it.
Apply to preview / Current: Color depth is the slowest cue to compute: a color-match pass plus a guided filter for every active row. So it is not rebuilt while you adjust it. A button at the foot of the section reads Apply to preview whenever the preview is behind the controls, and Current when it already reflects them. Anything else that rebuilds the depth map picks up your pending colors on the way, and the label notices.
The 10 color rows: Each row: an enable checkbox, a color swatch (click to pick a color), a Range slider (how far a pixel's color may differ from the picked color and still match), and a Depth slider (0 = far, 1 = near) for matching pixels. All 10 rows default to an astro palette (reds, teals, browns) but start unchecked. A profile of colors/ranges/depths can be saved and loaded as a .dpcol file via File > Load/Save color depth profile....

External depth map

Loads a hand-edited or externally produced grayscale depth map and blends it over the computed depth (white is nearest). Off by default.

Current: The name of the loaded map, or None. The map itself is stored inside the project, so a saved project carries it and stays self-contained wherever it is opened.
View: Opens the loaded map at up to 1600 pixels on its longest side, so you can check which map is in use.
Load... / Clear: Load a grayscale depth-map image, or remove the loaded one. Loaded maps are listed under File > Open Recent > Recent depth maps, and reopening one from there loads it as a depth map rather than as the working image.
Blend: How strongly the external depth map overrides the computed depth. 0 ignores it; 1 uses it fully. No effect until a map is loaded.
Combine: How the external depth map combines with the current depth before Blend is applied: Normal replaces; Lighten keeps whichever is nearer, Darken whichever is farther; Add/Subtract push nearer/farther; Screen pulls forward without clipping.
Smoothness: Edge-aware smoothing, in pixels, applied to the external depth map before it is blended in. 0 disables it.
Gamma: Gamma applied to the external depth map. 1 leaves it literal; above 1 pushes it back, below 1 pulls it forward.

Structure depth

Anchors the structure (the whole depth map) at a chosen distance among the stars. Applies in starless + stars or synthetic-stars mode. Off (unchecked) by default.

Weight: How strongly the structure is moved to the object's real distance. 0 leaves the depth as the cues produced it; 1 anchors the whole relief at the object's distance among the stars. The cue shape is preserved either way.
Depth: Target depth for the structure's mean: 0 is farthest, 1 is nearest. "Match object distance" sets this from the object's real distance.
Thickness: Physical depth span of the object's internal relief around the anchor. Larger gives more front-to-back depth; smaller flattens it toward a single plane. Most meaningful at higher Weight.
Floor (with "auto"): Deep-sky floor depth (0 is farthest). Pixels at or below this stay at the back; pixels above ramp toward the fitted depth, so the sky stays deep when the structure is anchored. "auto" estimates it from the image; uncheck to set it by hand.
Object field: Identifies the imaged object so its catalogued distance can anchor the structure. Type a catalog id or name (for example M42, NGC 7000, Orion) and press Enter, or click "Match object distance". Once the image is located in the sky, it auto-fills with the object at the field center. The field (and its resolved distance) resets whenever a new image or project loads, or when the app closes.
Match object distance: Looks up the object's distance (built-in catalog, SIMBAD fallback) and places the structure at that depth among the stars. A successful match also draws a gold reference line in the Star Distance Distribution chart.

Depth Modelling

Composites an internal, editor-produced depth model over the computed depth - the true last step in the pipeline. On by default. Uncheck to drop it without losing the sculpted model.

Edit depth map...: Opens the Depth Modelling editor to reshape regions of the computed depth.
Blend mode: How the internal depth model combines with the computed depth before Blend is applied: Normal, Lighten, Darken, Add, Subtract, or Screen.
Blend: How strongly the internal depth model overrides the computed depth. 1 is a full override; 0 ignores the model.

Parallax tab

Stereo

Parallax amount: Maximum total horizontal disparity in pixels: the overall 3D strength. Larger values exaggerate depth but increase eye strain and disocclusion artifacts.
Convergence: The depth that sits at the screen plane (zero parallax). Regions nearer than this pop out; regions farther recede. Shown as a raw 0.00 to 1.00 fraction regardless of the app's percent display preference. Disabled while Auto convergence is on.
Auto convergence: Places the screen plane at the median depth of the scene, so the result opens centered and comfortable. Uncheck to set Convergence manually.
Max disparity: Comfort clamp: the maximum total horizontal disparity, in pixels. Pixels that would shift farther are capped, keeping a deep scene fusible. 0 is off.
Anaglyph: How the red/cyan anaglyph is composited. Color keeps full color but saturated reds cause rivalry; Half-color tames red rivalry; Gray has the least ghosting; Optimized (Dubois) minimizes ghosting while keeping some color.
Swap eyes: Swap the left and right views: switch between parallel and cross-eyed free-viewing, or correct a reversed-depth result.

Parallax motion (wiggle)

Amplitude: How far the viewpoint swings. 1 is the full left/right eye separation; above 1 exaggerates the motion for a stronger wobble. Multiplies Parallax amount.
Frames: Number of viewpoint frames in the sweep. More is smoother motion.
Frame rate (fps): Frames per second for parallax motion, in playback and in video export alike. A flyby or a 3D flight runs at the rate its own script declares; this value applies to such a path only when the script declares none.
Path angle: Direction of the linear sweep, in degrees: 0 is horizontal, 90 is vertical, any value between for a diagonal. Ignored when Circular is on.
Circular sweep: Orbit the viewpoint in a circle around the scene instead of sweeping back and forth along a line. Often reads more naturally on round subjects (nebulae, galaxies). Disables Path angle.

Flyby frame

By default a flyby renders the whole image: load a 3000 x 1000 picture and the video is 3000 x 1000. Flyby frame sets a smaller view for it to render - 1000 x 1000, or 1000 x 800, or anything up to the source size - so the flyby becomes a reduced view travelling over the picture rather than the whole picture moving.

The frame is the field of view at zoom 1, which is what gives a flyby somewhere to go: with the whole image as the frame there is no room to pan until you zoom in, while a smaller frame can travel the length of the picture at zoom 1. Every waypoint's own zoom then works from the frame, so zoom 2 shows half the frame's width and height.

Nothing about authoring changes. The whole image stays visible in the Flyby Editor and waypoints go anywhere in it; the per-waypoint rectangles simply take the frame's shape, so they keep showing exactly what each point will render. A waypoint near an edge behaves as it always has - the view slides back inside the picture rather than running off it.

Width, Height: The rendered view, in image pixels, up to the source size. Setting them to the source size means the whole image, which is the default.
Ratio: Fits a common aspect ratio inside the image as large as it will go - a quick way to get a square or vertical flyby out of a wide picture. Source size returns to the whole image.

Export is unaffected in the way that matters: the frame is simply the video's native size, and the export dialog fits it into whatever output size you choose, exactly as it does a full-size flyby. This applies to a 2.5D flyby only - a 3D flight frames with its camera rather than by cropping the image, and parallax motion has no camera to move.

Post tab

A final tone and color grade applied to the finished image: levels, brightness, contrast, white balance, and color. Everything here is applied to the final rendered image, after the stereo/depth work is done, so it affects every output equally: the anaglyph, the side-by-side pair, and each parallax-motion, flyby and 3D flight frame, including video and image exports.

Where you can see it. Because the grade acts on the final image, it only shows in the "final" preview views: Anaglyph, Side-by-side, and during Parallax motion, Flyby or 3D flight playback. The views that exist to show a source layer instead of the final result, Original, Starless, and Stars only, deliberately ignore the grade, so you can keep using them to judge the inputs. Switch to Anaglyph or Side-by-side (or play the motion) to preview your Post settings. The color adjustments are applied before the anaglyph's red/cyan encoding, so they never distort the anaglyph channels. On a mono image the color controls have no effect.

Enable post-processing: Master switch for the whole tab. Turn it off for a quick before/after; the sliders keep their values. With every control at its default, the grade does nothing, so it is safe to leave on.

Tone

Levels and light. These apply to mono and color images alike.

Black point: Clip the darkest tones to black. Raise it to deepen the sky background and kill residual glow.
White point: Clip the brightest tones to white. Lower it to roll off blown highlights.
Gamma (midtones): Midtone brightness. Above 1 lifts faint detail (nebulosity) without blowing the stars; below 1 darkens the midtones.
Brightness: Overall lightness of the final image, from -100 to +100.
Contrast: Spread tones away from mid-gray (positive) or compress them toward it (negative), from -100 to +100.

Color

White balance and saturation, from -100 to +100 (Hue in degrees). Skipped automatically on mono images.

Temperature: White balance along blue and amber: positive is warmer (more red, less blue), negative is cooler.
Tint: White balance along green and magenta: positive is magenta, negative is green.
Saturation: Color intensity of every pixel. Negative desaturates toward gray, positive boosts all colors.
Vibrance: Like Saturation but gentler on already-vivid pixels (star cores), so it brings up muted nebula color without oversaturating.
Hue: Rotate every hue around the color wheel, in degrees.

The Defaults button resets all Post controls to no change.

Exporting the current view

File > Export... writes whatever the preview is showing. It is not a copy of what is on screen: the view is rendered again at the image's full resolution, so the file never inherits the preview's size, the window's size, or the reduced resolution a flyby preview may be running at. The menu item and the toolbar button both name the view, so you know what you will get before the dialog opens.

View	What is written
Depth map	The depth map itself, 0 to 1.
Anaglyph	The anaglyph, rendered at full size.
Side-by-side	The stereo pair, rendered at full size.
Starless	The starless layer at full size.
Stars only	The stars layer at full size.
Starless + synthetic stars	The composite at full size.
Original	The source image.
Star overlay	The source with the star markers drawn in.

The formats offered follow what the view is. The depth map and the image layers are real floating-point data, so they offer XISF (32-bit) first, then TIFF, PNG and JPEG. An 8-bit depth map bands, and that banding shows up as stepping if the map is ever brought back in, so XISF is the one worth reaching for. An anaglyph or a stereo pair is a viewing image, and gets the ordinary formats. When the image has been located in the sky, an XISF export of a layer carries the astrometric solution with it; a depth map does not, having none of its own.

The suggested filename is taken from the loaded project, so a project called M42.dpproj suggests M42_depth_map.xisf. With no project open the name falls back to deepparallax_.

The dialog opens in the folder your last export went to, remembered between sessions and shared by every export - stills, videos, VR180 and Apple Spatial alike - so a set of exports from one session lands together. Before anything has been exported it starts in the loaded project's own folder.

None of these is ever size-limited, whatever the license state: only video is. See Licensing.

Flyby Editor

Reachable from Window > Flyby Editor.... A visual editor for authoring a camera flyby path by clicking over the image, instead of typing a script directly. Click to drop a keyframe, drag to reposition one, Ctrl-click a point to delete it (the start point cannot be deleted). Every edit auto-syncs live to the shared flyby script - there is no manual "apply" step, and the Script Editor always reflects the same underlying script.

A point's marker and the path line are drawn where the camera will actually be pointed at that point's current zoom, not necessarily where you placed them. The camera always keeps its full framed view inside the image, so at low zoom it can only look at a limited region around the center - the more zoomed out a point is, the closer to dead-center its reachable range shrinks (at zoom 1, the camera can only look at the exact center). Dropping or dragging a point outside that reachable range settles its marker at the closest position the camera can actually reach; the point still remembers where you placed it, so raising that point's Zoom lets the marker slide back out toward the original spot. If a marker looks stuck away from where you put it, this is why - raise its Zoom to reach it.

Flyby Editor canvas

Numbered keyframe markers and the connecting path drawn over the image, with the selected point's frame-of-view box and its resize/rotate handles.

Toolbar

Group	Buttons	What they do
File	New, Load, Save	The first group on the toolbar. New opens a menu, from the button itself or from the drop-down beside it, with two choices: New flyby (2.5D) clears the canvas to a single start point, and New 3D flight starts a 3D flight path instead. A path is one kind or the other, so switching replaces what you have and asks first. Load/Save read and write a `.dpsc` path file, either kind.
Script	Switch to the script editor	Leaves this editor for the Script Editor, on the same path.
Edit	Undo, Redo	Step back and forward through the changes made to the path (Ctrl+Z, Ctrl+Shift+Z). See Undo and redo.
Transport	Play, Play point preview, Pause, Stop, Continuous loop	Play starts playback from the top - including from a paused clip, which it restarts rather than resumes; Play point preview renders just the neighbourhood of the selected point (see the point properties panel below). The status line under the canvas reports the path's frame count and playing time as you edit, so there is nothing to ask for separately. Continuous loop (on by default): on, the flyby repeats; off, it plays once and stops on the last frame.
View	Zoom out, Zoom in, Fit	Controls the canvas's own view of the backdrop image. The mouse wheel also zooms; right-drag pans.
Tools	SCC, Convert to script, Ongoing wiggle, Export	SCC (Script Coordinates Converter) rescales every literal image coordinate in the path from one image size to another. Convert to script flattens the waypoints into individual commands and removes the path block entirely (a one-way, confirmed action). Ongoing wiggle (on by default): on, the flyby gets the Parallax tab's wiggle wherever a point does not override it; off, the Parallax tab's wiggle is ignored during the flyby and only explicit per-point overrides apply. Export opens the flyby video export dialog. SCC and Convert to script are disabled for a 3D flight: its coordinates are world units rather than image pixels, so there is nothing to rescale, and its commands are not the 2.5D ones that Convert flattens to.
Right side	FPS, Res	FPS is the clip's frame rate: one value for the whole path, used for playback, for validation and to fill in the video export dialog. It is stored in the script as `fps=` on `path_start`. Res sets the flyby preview render resolution. Optimized (the default) picks the size from how large the preview is actually being displayed, rendering at twice that so stars stay clean. On a large image in a normal window this is far less work than 100 %, which renders every frame at the full source size only for the view to shrink it again - at the same quality or better. It follows the window: resize, and the preview re-renders once the resize settles. The fixed percentages (100 / 75 / 50 / 25 / 10 %) are shares of the SOURCE size, for when you want to pin the render size yourself. Lower renders faster and lets longer or larger flybys play back smoothly, since more frames fit in memory. Export is always full resolution. Zooming in during the flyby does not cost detail. A frame at 2x zoom needs twice the source detail of a wide one, so the preview renders that frame from a finer copy of the image while the wide frames stay on the coarse one - per frame, automatically, with nothing to set. A path that never zooms in renders exactly at the Res value and pays nothing for this. The frame is rendered at that size and then magnified to fill the canvas, so small features - stars especially - are drawn larger on screen than they will be in the output. The render itself is not affected: the same frame exported at 10 % and at 100 %, compared at the same size, is identical.

Point properties panel

The four navigation buttons (first / previous / next / last) sit right-aligned on the panel's title line, beside the name of the point they act on, with the X button that deletes the selected point at their right - the controls that act on one point are kept together, on the panel that edits it. Deleting is disabled on the start point, and does the same as Ctrl-clicking a point on the canvas or pressing Del. The 2.5D Point panel and the 3D Waypoint panel each carry the whole row, whichever is showing.

Edits the currently selected keyframe (click a point on the canvas, or use the navigation buttons).

Action: Move to, Fly to, Fly in, Zoom to, or Stay. The start point has no action (it is the beginning of the path).
Frames: Duration of the move into this point, in frames.
Zoom: Target framing magnification for Fly in / Zoom to / the start point.
Warp depth %: Depth-warp dive strength, for Fly to / Fly in.
Ease: Linear, Ease in, Ease out, or Ease in-out.
Hold: Extra still frames after the move completes.
Roll to: An optional absolute roll target, in degrees, that rides the move.
During move / On arrival: Two optional wiggle override groups (Angle, Amp, Frames, and, except on the start point, FPS), each opt-in via its own checkbox. The copy arrows between the groups copy one set onto the other. On the start point, "During move" doubles as the path's initial wiggle and its own FPS row is hidden (the toolbar's FPS applies instead).

FPS here is the rate the wiggle is written for, not the clip's rate: a clip has one frame rate throughout, set by the toolbar. FPS pairs with Frames to give the cycle a duration, so Frames 20 at FPS 10 is a cycle lasting two seconds. The cycle is then stretched to span however many real frames that duration takes, so a 30 fps clip runs that same cycle over 60 frames and it lasts two seconds there too. Leaving FPS unchecked reads Frames as real frames.
Play point preview: Plays a short stretch of the flyby around the selected point, rather than the whole path. It enters from the arrival of the previous point, so the move into the selected one is included, then continues for the number of further points set by Play point preview range in Preferences, or to the end of the path if Play until the end is checked. It always stops at the last point. The preview is playback only and never becomes the saved path. It works for a 3D flight too, windowing the flight the same way, and is available there whenever the path has more than its opening camera.

Right-click this button to set how far the preview runs without leaving the editor: it opens Points ahead and Play until the end, the same two settings Preferences holds. They are one setting seen from two places, not a copy, so changing either changes both.

Each waypoint's rectangle is the view that point renders. If you have set a Flyby frame, the rectangles take its shape - that is the whole of the framing feedback, and it is the honest place for it, since the view travels with the waypoints rather than sitting still anywhere on the image.

On a 2.5D path each point also carries two small arrows through its marker, on one line, showing the direction the parallax motion sweeps at that point: horizontal at a path angle of 0, vertical at 90, and so on. Their length follows that point's amplitude - a longer line is a wider sweep - while the arrowheads stay one size, so length alone carries the reading. They reflect what that point will actually do, which is the path-level angle and amplitude unless the point sets its own sway or amp override, in which case the arrows show the override. No ongoing parallax motion, no arrows; a 3D flight has none either, having no sweep angle to point at.

Canvas interactions

Click empty space: append a new point.
Click and drag a path segment: insert a new point mid-path.
Drag a point: move it.
Ctrl-click a point: delete it.
Del: delete the selected point (the start point cannot be deleted).
Drag a selected point's frame-of-view box handles: corners rotate, side handles resize (zoom).
Mouse wheel: zoom the backdrop view. Right-drag: pan. Zooming out past the fitted size is allowed, so the editing area can be made smaller than the canvas - useful for placing a waypoint outside the frame, or judging a path that leaves the image. Once it is smaller than the canvas it stays centred, and panning applies only along an axis that still overflows.

A 3D flight path uses the same canvas and the same two click gestures. Clicking empty space adds a waypoint after the selected one, taking its depth and aim from that one. Clicking a path line inserts a waypoint into that leg: its position across the frame is where you clicked, and everything the canvas cannot show - depth, aim point, field of view and roll - is interpolated between the leg's two ends at that same place along it. The leg's frames are split between the two halves, so the flight stays exactly as long as it was and the speed along that leg does not change.

On a straight fly-in the waypoints differ almost only in depth, so they land on nearly the same pixel here and there is no line to click - that is what the depth view is for. The frame-of-view box carries the waypoint's own Field of view: its side handles change the field of view, its corner handles change the roll.

Each 3D waypoint also shows where it is aimed: a cyan crosshair joined to its camera by a dashed line. Every waypoint's aim is drawn faintly so a developing turn can be read across the path; the selected one is drawn bright and is the only one that can be grabbed. Drag that crosshair to re-aim the camera without moving it, or Alt-click anywhere to aim the selected waypoint at that point. Both change the aim's position across the frame only - its depth belongs to the depth view, the same split the camera marker follows. Look X and Look Y are the same values as numbers.

Dragging the camera's frame box carries the aim along with it, so the framing follows the box. To move the camera while holding an aim - a strafe - use the Cam X/Y sliders or the depth view, which leave the aim where it is.

Undo and redo

Undo and Redo (Ctrl+Z and Ctrl+Shift+Z, or Ctrl+Y) step through the changes made to the path. They cover everything the path itself holds: point positions and timing, every property in the point panel, adding and deleting points, the frame rate, and for a 3D flight the waypoints and the whole 3D scene panel. Hand-written code kept alongside the path (see free-form commands) and the comments in it travel with each step, so stepping back never costs you either.

A continuous gesture is one step, not hundreds: dragging a point across the canvas, or a slider from end to end, records a single change once it settles. Fifty steps are kept.

The history belongs to the path currently open, so it starts empty whenever a different one arrives: opening the editor, loading a path file, starting a new path, or rescaling coordinates. The canvas zoom and which point is selected are not part of it - stepping back changes the path, not your view of it. Neither are Ongoing wiggle and Continuous loop: those two are playback settings that live outside the path, so they are unaffected by Undo.

The Depth Modelling Editor keeps its own separate history, and Ctrl+Z in one window never reaches the other.

3D flight

A 3D flight moves a true perspective camera through the image, rendered as a cloud of particles with the stars placed at their own depths. An ordinary flyby pans and zooms a warped view of a flat image; a 3D flight has a camera position and an aim point in space, so it can dolly into the scene, slide sideways for real parallax between near and far material, and turn to look off-axis.

Start one from the Flyby Editor: New > New 3D flight. It arrives seeded with an opening view that matches your image and a dolly straight in, so it plays immediately. A path is either an ordinary flyby or a 3D flight; the two cannot be mixed.

The flight uses the depth map and the star set you already have, so everything in the Depth, Shaping and Stars tabs feeds it, including anything painted in the Depth Modelling Editor and any structure placement dragged in the Star Distance Distribution window. The Parallax tab's Convergence sets the flight's neutral plane: the depth that the structure's surface pivots about, so changing Structure 3D does not shift where the structure sits.

The depth map is followed literally. Every cue you enable feeds it, and a flight renders what it says: black is the far end of the scene, brighter is nearer, and an area raised in the Depth Modelling Editor comes forward by exactly that much. No 3D setting reinterprets it - if a structure should sit behind the stars, give it a depth map that says so, or set Structure depth at or beyond Star depth.

3D flight in the Flyby Editor

The camera track over the image, the depth view beneath it, and the 3D waypoint and scene panels on the right.

Structure and stars are treated differently

The two populations in an astro image carry very different amounts of real information, and the flight treats them accordingly.

Star depth can be genuine. Each star is placed by the Star depth model, which in Real depth (Catalog) mode comes from actual catalog distances, and each star keeps its real sprite, so bright stars stay bright and keep their halo and spikes as you fly past them.

Structure depth is inferred, not measured. A single image records one view of the nebulosity, so there is no information about what sits behind any part of it. The depth map is a plausible arrangement rather than a measurement, which is why the flight lets you decide how much of it to use. Past a point, less reads better: a heavily three-dimensional structure distorts as you dolly into it and skews as you turn.

The scene is built from one viewpoint, so it occupies a cone spreading away from where the image was taken. Moving the camera sideways eventually reaches the edge of that cone, which shows as a dark wedge at the frame edge and a bright rim where the depth layers end. How far you can go depends on Structure depth: a shallow scene fills the frame and lateral moves have plenty of room; a deep one reaches the limit much sooner. Dolly moves are unaffected.

3D waypoint panel

Edits the selected waypoint. Select one by clicking it on the image canvas or in the depth view.

Cam X, Cam Y: Camera position across and up/down, in world units where the image is 1.0 tall. Dragging the point on the image canvas sets these two.
Cam Z: Camera depth. The structure occupies 0 to the scene's Structure depth, so negative values sit in front of it, and increasing this flies in. This is the axis the image canvas cannot show: two waypoints differing only in depth appear at the same place there, which is what the depth view is for.
Look X, Look Y, Look Z: The point the camera is aimed at. Moving it away from the camera's own position turns the view off-axis. Keeping Look Z inside the structure's depth range aims into the scene rather than past it. The target always stays ahead of the camera: it holds still while the camera approaches it, and once the camera arrives it travels on at the same offset, keeping your framing. See the note below for why.
Field of view: Vertical field of view in degrees. Narrower is a longer lens: it magnifies without moving the camera, and flattens the sense of depth. 55 is the reference value at which the opening view matches the source image. The selected waypoint's frame box on the image canvas is drawn at this field of view, and dragging the box's side handles sets it.
Roll: Rotates the view about the axis it looks along, in degrees. Absolute, not a relative turn. The frame box on the image canvas turns with it, and its corner handles drag it. Roll cannot be seen in the depth view, which looks straight down the axis it turns on.
Frames: How many frames the move into this waypoint takes. The start camera has no move, so this does not apply to it.
Ease: Speed curve of the move: Linear, Ease in, Ease out, or Ease in-out.
Hold: Still frames on arrival, before the next move. Exactly this many frames are added. On the start camera this is the pause before the flight begins.

3D scene panel

These apply to the whole flight rather than to one waypoint, because the scene cannot change shape mid-flight.

Structure 3D: How the structure's surface meets the camera, 0 to 1. It does not change how deep the structure is: the depth map is followed exactly at every setting, so an area raised in the Depth Modelling Editor comes forward by what the map says whatever this is set to.

At 1.00 the surface is fixed in the world and is seen from whatever angle the camera reaches, so it skews on a turn and distorts on a dolly - the most literal reading. At 0.00 it always presents face-on, so it can never skew or distort, while its depth still produces parallax and scale exactly as the map says. Values between blend the two. The default is 0.20, which keeps the surface mostly face-on.

If what you want is a rigid, parallax-free card, flatten the depth map - that is what asking for it actually means, and it leaves this dial free to do its own job.
Structure depth: How much world depth the structure's depth map occupies. Larger gives more internal parallax and brings the edge-of-cone limit closer. It is also what decides whether a flight can pass the structure: a camera that dives beyond this depth comes out the other side of it. Set it at or beyond Star depth for a structure the flight can never outrun.
Star depth: How much world depth the stars occupy. Their 0 to 1 placement comes from the Star depth model; this stretches that placement into the scene. Setting it well above Structure depth is the point: nebulosity is a thin shell while a star field is deep, and stars sliding past each other at visibly different rates is most of what makes the motion read as three-dimensional.
Cloud thickness: Spreads each pixel's light along its own line of sight, making the structure a volume rather than a sheet. At 0 the depth map's steep edges show as bright ridges that are not in the source image. Too high loses fine detail.
Depth samples: How finely the thickness is integrated. Fewer samples look grainy; the graininess falls off as the square root of this value. 10 is comfortable and 4 is enough while trying out camera moves. This is the main control over render time.

Raising it also reduces the layered, faintly striped look that can appear on the structure at close range. Each pixel's light is spread over a fixed number of depths, and the nearer the camera gets the further apart those land on screen, so they begin to read as separate shells. More samples close the gaps between them. It softens the effect rather than removing it outright; Focus blur below covers what is left.
Star plane: Center of the star depth distribution, 0 (far) to 1 (near). The Stars tab's own default sits stars near the front, which suits the stereo and parallax modes but gathers them onto one plane in a flight, so a flight wants this nearer the middle. Not used by Real depth (Catalog), which places each star at its catalogued distance instead.
Star spread: How widely stars scatter around that plane. Also unused by Real depth (Catalog).
Star floatation: 1 uses the model's depth outright. Lower values blend each star back toward the scene depth beneath it, flattening the field toward the structure.
Focus blur: Softens the structure as the camera closes on it, leaving the stars sharp. 0 turns it off; the default is 60%. The softening is measured against the frame height, so a reduced-resolution preview and a full export soften by the same visible amount.
Blur onset: How close the camera must get before Focus blur begins, as magnification at the structure: 1.00 (the default) is the opening framing, 3.00 is three times into it. Below it nothing happens; past it the softening ramps in smoothly and levels off, so pressing further in keeps softening without ever snapping. Raise it to hold the blur off until you are deeper in, lower it to start sooner. A smaller source image runs out of real detail earlier, so it wants a lower value.

Focus blur is worth understanding rather than treating as a filter. Closing in magnifies the source past its own resolution, and what the renderer draws beyond that point is not detail but the structure of its own sampling. Softening it is the truer rendering of having run out of information, as well as a convincing loss of focus, and it covers much of the distortion a high Structure 3D picks up at close range. The stars are composited after the blur, so the field stays crisp against the softened nebulosity.

The onset is measured as magnification, not against the source image's pixel size. Tying it to the source would make it depend on the output resolution, so the same flight would blur at different moments in a reduced preview and in a full export, and the control could not be tuned. Magnification belongs to the camera alone, so what you set up in a preview is what the export renders.

A camera aimed at a target reverses the moment it passes that target, because it always faces it: fly past the aim point and the view turns to look backward. Right after crossing, the only thing in front of the camera is a sliver of scene against the lens, which projects outside the frame, and every star is now behind it. The result is a stretch of pure black with not even a star in it, ending only when enough of the scene has fallen behind to become visible again. The editor prevents this by carrying the aim point along, so you can fly through the scene and out the far side and see the star field thin out ahead of you, which is what the geometry should give. A hand-written script can still place an aim point behind its camera; the path status line reports it as a warning.

Flying through the structure is allowed: the camera can pass it and carry on among the stars. As it does, the structure fades out over the last stretch in front of the camera rather than being clipped away in a single frame - a connected surface crosses the camera plane all at once, and cutting it produces a blink rather than a departure. Stars are not faded; a point of light disappearing reads as a star passing, which is what it is.

Depth view

The strip below the image canvas shows the scene from above: across is the image, down is depth. It appears for 3D flights only.

It is laid out to be read against the Star Distance Distribution window, using the same shared depth axis that chart uses:

Structure line (cyan): Where the structure sits, as a single depth - the same value, and the same cyan, as the SDD's structure bar. Dragging that bar moves this line. When the Structure depth anchor is engaged the line is the anchored depth itself, so it lands exactly where you put it.
Star band and star curve (blue, left edge): The depth range holding the bulk of the stars, labelled with that range, and the star-depth distribution itself - the same curve the SDD plots.
Depth map curve (cyan, right edge): The distribution of the depth map's own dark-to-white values, over that same depth range, so the two curves can be read against each other. Drawn on a square-root scale: background outnumbers structure by orders of magnitude, and a linear plot would be one spike and a flat line everywhere else.
Depth axis: Labelled gridlines down the left, so any position can be read off directly.

The camera track runs through it all as a line with numbered waypoints, and a short arrow from each waypoint points the way that camera is aimed. Drag that arrow to turn the camera left or right: it pivots about the camera's own position and keeps the aim point the same distance away, so aiming never changes how far ahead the camera looks. The Look X/Y/Z sliders follow along.

The view fits itself to whatever you have authored, so its scale changes as you drag a point beyond the current extent.

The structure's line shows its depth POSITION. How much depth the structure occupies is the 3D scene panel's Structure depth, which is a thickness and is not drawn here.

A camera parked far out in depth squeezes everything else into a sliver, so the view can also be framed by hand: the mouse wheel zooms about the pointer, the + and - buttons in its top right corner zoom about the centre, and dragging empty space pans. Fit (or the F key) returns to fitting everything, and lights up whenever the view is framed by hand, so it is clear when what you see is not the whole path. Loading a different path fits again from scratch.

The aim arrow does not show Roll, and cannot: roll turns the view about that very line, so a view from above looks straight down the axis it turns on. Roll shows on the image canvas instead, where the selected waypoint's frame box rotates with it.

Drag a waypoint: Moves it in position and depth together.
Double-click empty space: Adds a waypoint there, after the selected one. It inherits the aim point, field of view, roll and timing of the point it follows, since a click specifies only a position.
Del: Removes the selected waypoint. Click the depth view first so it has keyboard focus.

Clicking the image canvas also adds a waypoint, setting its position across the frame while inheriting depth and everything else. Between the two views, each supplies what the other cannot express.

Waypoints can be deleted from either view: the X button on the Waypoint panel's title line, Del, and Ctrl-clicking a point on the image canvas all remove the selected waypoint. The start camera cannot be deleted.

The image canvas and this view are separated by a draggable splitter, so you can give whichever one you are working in more room. A fly-in is mostly motion in depth, where this view is the one worth enlarging; framing and roll want the image instead. Neither can be dragged away entirely, and the position is remembered between sessions.

Depth view

The scene from above: the structure and star depth bands, the camera track, and each waypoint's aim direction.

Rendering and playback

On a machine with OpenGL 3.3 - which is nearly every machine with a working graphics driver - the graphics card joins the "Building preview" pass: it renders frames side by side with every processor core, so the build finishes faster on any scene, most dramatically on structure-heavy ones. Playback itself shows pre-rendered frames, which is what stays perfectly smooth at any resolution; the status bar notes "GPU-accelerated" while such a clip is playing. On a very long or very large clip the frames that did not fit the memory budget render on demand, also on the graphics card.

The GPU renderer is for previewing only, and it is held to the standard renderer: an automatic test verifies, stage by stage - structure, stars, focus blur, Post grade - that the two produce the same image. Exports always use the standard renderer, so a file rendered on any machine is identical.

Without usable OpenGL (some virtual machines and remote desktops), or with the option turned off in Preferences, the cache builds on the processor exactly as it always did. The Res control and the video export dialog behave identically either way.

Note that stars are drawn from their real sprites only when those project to more than a couple of pixels; at low preview resolutions most stars fall below that and render as points, so star appearance is best judged at full resolution or from an export.

Exporting video in 3D

The video export dialog (Export Parallax Motion / Export Flyby) offers a 3D format choice. Every 3D form renders a true left/right eye pair for every frame - for a 2.5D flyby and for parallax motion the eyes are the same warp the stereo stills use, riding on top of the motion; for a 3D flight the camera itself is displaced for each eye and converged where it looks, which is genuine binocular parallax through the particle scene. Depth strength and convergence come from the Stereo section's own parameters (including Swap eyes), so a 3D video agrees with your anaglyph stills about how deep everything is.

Anaglyph (red/cyan): Plays on any screen with paper glasses, using the Stereo section's anaglyph mode. The one 3D form a GIF can carry. Saturated reds ghost a little; that is anaglyph, not a bug.
Side-by-side (full width): Both eyes at full size, so the file is twice as wide as the chosen output size - the output-size box is per eye for this format. The highest-quality form for VR players.
Side-by-side (half width): The pair squeezed into the chosen size, each eye half width - the layout 3D TVs and most players auto-detect.
Top-bottom: As half side-by-side, but squeezed vertically instead.

The suggested filename gains a suffix naming the packing (_anaglyph, _SBS, _HSBS, _TB), so a folder of exports stays legible. Exporting two eyes per frame costs twice the render time of a flat export.

VR180 and Apple Spatial carry motion too. Both export doors ask what the export should contain: the still stereo pair (or its 3-second loop), the parallax motion sweep, or - when a path exists - the flyby or 3D flight. The motion forms render the same full side-by-side eye pairs described above, at the path's own frame rate, and receive the same VR180 or Apple spatial metadata as the stills, so they play as immersive 3D video on headsets and Apple devices. Filenames gain _parallax or _flyby accordingly.

The cup of coffee

A cup of coffee appearing in a progress dialog means the job still has more than about two minutes to run. Nothing is wrong, and nothing needs doing: it is there so you can decide whether to wait or to go and make one.

It is measured rather than predicted. The app cannot know how long a render will take until it has rendered a few frames, so the cup waits for a real rate and then works out the time remaining. It never appears on a job that finishes quickly, and once shown it stays for the rest of the run rather than flickering as the estimate settles. It can appear in any of the long operations - a video export, a stereo video export, or building a flyby preview.

Flyby script language

The flyby path compiles to (and the Script Editor edits directly as) a small line-based language. An empty script uses the built-in push-in loop. Lines starting with # are comments.

Instant pan/zoom

zoom v: set absolute zoom.
zoomd v: zoom by a relative delta.
pan dx dy: shift the center by (dx, dy).
panl v / panr v / pant v / panb v: pan left/right/top/bottom.
reset / home: recenter, zoom 1, no dolly or roll.
roll v: set absolute viewport roll, in degrees.
update: commit pending instant changes as one frame (a cut).

Animated moves

moveto: x y steps [rollTo]: ease the look-at center to (x, y).
zoomto: value steps [rollTo]: geometric zoom to a value.
rotate deg steps: roll the field of view by a relative amount.
flyto: x y steps away [rollTo]: pan to (x, y) while diving into the scene (away is the depth-dolly percent).
flyin: x y steps zoom away [rollTo]: combined pan, magnify, and dolly in one move.

Wiggle / parallax overlay

sway v: parallax sweep direction, in degrees.
amp v: wiggle amplitude (0 to 20).
period v: wiggle cycle length, in frames (2 to 600).
motion: amp [period] [sway]: a one-liner for all three; omitted arguments are unchanged.

Timing, looping, variables

hold n: emit n static frames.
setfps n: the frame rate the wiggle is written for, from here on, 1 to 240. It scales the wiggle's cycle length; it does not change the clip's rate, which comes from fps= on path_start.
ease m: linear, in, out, or inout.
repeat N ... end: a single-level loop (no nesting).
$name = expression: arithmetic variables. Reserved read-only variables: $w/$width, $h/$height (source dimensions), $centerx/$centery (image center), $curx/$cury (live viewport center), $zoom, $vw/$vh.

The Flyby Editor's own waypoint blocks (path_start / path_begin / waypoint ... / path_end) are the graphic-path form of the same language, expanded to the base commands above before the script compiles.

3D flight script

A 3D flight is written in the same script, declared by mode=3d on the path_start line. That declaration is what selects the 3D compiler; a script without it is an ordinary flyby. One script, one editor, one Load.

path_start version=1 mode=3d fps=24 pos=0,0,-0.96 look=0,0,0 fov=55
scene  depth_scale=0.35 star_depth_scale=1.6 ref_dist=0.96 particles=6000000
render structure_3d=0.2 thickness=0.10 samples=10 cloud_size=1.1 star_max_scale=3.0
stars  plane=0.50 range=0.90 floatation=1.0
path_begin hold=10
  waypoint pos=0,0,-0.55 look=0,0,0.05 frames=40 ease=inout hold=6
  waypoint pos=0.22,0.03,-0.45 look=-0.10,0,0.10 frames=40 ease=inout
path_end

Coordinates are world units in which the image is 1.0 tall, so x spans plus and minus half the aspect ratio. Depth runs from 0 at the nearest structure to depth_scale at the farthest, and the camera starts on the negative side looking toward positive depth, so flying in means increasing z. At fov=55 the image exactly fills the frame from a distance of 0.96, which is why a path opens at pos=0,0,-0.96.

path_start

mode=3d: required. Without it the script compiles as an ordinary flyby.
pos=x,y,z: the opening camera position.
look=x,y,z: the opening aim point.
fov=deg: vertical field of view.
roll=deg: optional opening roll.
fps=n: the clip's frame rate, one value for the whole flight. Used for playback and for export.

The opening camera is itself the first rendered frame.

scene

Scene geometry, before path_begin.

depth_scale=v: world depth the structure occupies.
star_depth_scale=v: world depth the stars occupy.
ref_dist=v: the distance the image is treated as having been taken from, which sets how the scene spreads with depth. Match it to the opening camera distance.
particles=n: how many particles the structure is built from. Higher resolves finer detail and takes longer to build.
floor=v: skip pixels dimmer than this, which drops empty sky.

render

Appearance, before path_begin.

structure_3d=v: how much three-dimensionality the structure gets, 0 to 1.
thickness=v: depth spread per particle.
samples=n: depth samples per particle.
cloud_size=v: particle splat radius as a multiple of particle spacing.
exposure=v / star_exposure=v: brightness of the structure and of the stars, separately.
star_size=v: point size for stars too small to draw from their sprite.
star_max_scale=v: how large a star sprite may be drawn relative to its size in the source image.
focus_blur=v: softening of the structure at full strength, as a share of frame height (0.03 by default, 0 turns it off). This is the raw fraction the renderer uses; the panel presents the same setting as 0 to 100% of a sensible maximum, where 0.03 reads as 60%. Stars are never blurred.
focus_onset=v: magnification at which that softening begins, where 1 (the default) is the opening framing.
width=n / height=n: optional output size. The app renders at the image's own size, so these matter only outside it.

stars

Star placement, before path_begin.

plane=v: center of the star depth distribution, 0 to 1.
range=v: how widely stars scatter around it.
floatation=v: 1 uses the model's depth outright, lower blends toward the scene depth.

path_begin, waypoint, path_end

path_begin [hold=n]: opens the path. The optional hold pauses on the opening camera before the first move.
waypoint pos=x,y,z look=x,y,z frames=n [ease=..] [fov=..] [roll=..] [hold=n]: a move to a new camera position and aim. frames is required; everything else a waypoint omits is inherited from the previous one. ease is linear, in, out or inout. hold adds exactly that many still frames on arrival and is never rounded up.
path_end: closes the path.

Every look should sit ahead of its own pos in depth. A path that places one behind still compiles and plays, but the camera turns to face backward there and the frame goes black for a stretch (see the note in 3D flight). The path status line reports any waypoint that does this, naming it and what to change.

The scene lines describe one scene for the whole flight and must come before path_begin. Placing them inside the path block is an error, since the scene cannot change shape while the camera is moving through it.

Free-form commands

Waypoints spell a path out one point at a time, which is tedious for anything a formula could describe: a circle needs a waypoint every few degrees, each with its position worked out by hand. Free-form commands let a path be computed instead. They can appear before path_begin or after path_end, in place of or alongside a waypoint block, and share the same running camera as the block, so a computed approach can lead into a clicked path and a computed exit can follow it.

A path written with any free-form commands cannot be drawn on the Flyby Editor canvas, so the editor leaves those parts untouched and edits only the waypoint block between them. This is the same trade the 2.5D Convert to script makes.

Set the camera at once

campos x y z / lookat x y z: set the camera position or aim point.
fov deg / roll deg: set field of view or roll.
setfps n: set what the $fps variable reads from here on. A 3D flight runs at the single rate given by fps= on path_start, so this does not change playback or export.
ease linear|in|out|inout: set the speed curve used by the moves below.
hold n: emit n still frames.
update: emit the current camera as one frame (a cut).

Animated moves

Each eases from the current camera over a number of frames, using the current ease.

camto: x y z frames: move the camera to a new position.
lookto: x y z frames: swing the aim point to a new place.
flyto: camx camy camz lookx looky lookz frames: move camera and aim together.
fovto: deg frames / rollto: deg frames: ease field of view or roll.
dolly: distance frames: travel along the direction the camera faces, carrying the aim point with it, so a dolly never runs past its own target.
orbit: degrees frames: swing the camera around its aim point at constant distance, staying pointed at it. This is the move waypoints are worst at.

Loops and variables

repeat N ... end: repeat the enclosed commands N times (one level, no nesting).
$name = expression: define a variable. Expressions use + - * / and parentheses.

Read-only variables are available in any expression: $camx, $camy, $camz, $lookx, $looky, $lookz, $fov, $roll (the live camera), $fps, $aspect, $depth, $stardepth, $refdist (the scene), and $pi. Reading $camz after a waypoint block, for instance, gives wherever the block actually left the camera, so a following move can be relative to it rather than a number kept in sync by hand.

# A full orbit in one command, with a beat before and after.
path_start version=1 mode=3d fps=24 pos=0,0,-1.10 look=0,0,0.12 fov=55
scene depth_scale=0.30 star_depth_scale=2.0 ref_dist=0.96 particles=6000000
render structure_3d=0.15 thickness=0.1 samples=10 cloud_size=1.1
stars plane=0.5 range=1.0 floatation=1

ease inout
hold 12
orbit: 360 320
hold 16

Free-form commands have no wiggle: the parallax sweep of the 2.5D flyby (sway, amp, period) does not apply to a 3D flight, which gets its depth from the camera moving through the scene rather than from a wiggle.

Script Editor

Reachable from Window > Script Editor.... The same flyby path as plain text, with line numbers and syntax highlighting (commands, parameter names, numbers, and comments each colored differently). The Flyby Editor and Script Editor read and write the same script.

Validate: Checks the script and shows the result (frame count and playing time, or the line and message of the first error) above the toolbar; validation also runs live as you type.
Load... / Save...: Read or write a .dpsc file.
Apply: Hands the current text back to the app as the flyby script.
Play: Applies the script and starts flyby playback.
Close: Hides the window (the text is not lost; reopening shows it again).

Depth Modelling Editor

Reachable from Window > Depth Modelling Editor..., or the Shaping tab's "Edit depth map..." button. Reshapes regions of the computed depth by hand: select a region, then apply an effect to it. On Apply, the result becomes the internal Depth Modelling map (see Shaping tab). Apart from Undo and Redo, everything is toolbar and mouse driven.

Depth Modelling Editor

A selection made with the magic wand tool, with the cyan overlay showing its extent before an effect is applied.

Selection tools

Freehand lasso: Drag to trace a region.
Rectangle: Drag from one corner to the opposite corner.
Ellipse: Drag out the bounding box.
Polygon: Click vertices; double-click, or click the first point again, to close.
Select all: One click makes a region covering the whole canvas - a rectangle that happens to fill the frame, with nothing to drag. It takes the current Feather, Grow/shrink and Effect settings like any other new region, and can be reshaped with Move afterwards. Sits with the shape tools, right after Rectangle, though it is an action rather than a tool.
Magic wand: Click to select similar depths, within the Tolerance slider's range.
Selection brush: Paints a selection, not pixels: a region anywhere on the canvas, with no prior selection needed, that takes the current Feather, Grow/shrink and Effect settings like any other. Every further stroke adds to that same region, so a sculpt of many strokes stays one region with one effect - and each stroke is one undo step. Painting over already-painted ground at less than full Opacity builds up, like layered paint. Switching tools, or moving the selection to another region, starts a fresh region on the next stroke. Its cursor ring is amber, the toolbar's selection color, and while a stroke is in progress its shape shows as a cyan tint - drawn directly, so it is visible even when the overlay toggle is off.
Depth brush: Paints depth directly: lays the Level slider's gray straight onto the depth map - 0 is far (black), 1 is near (white) - anywhere on the canvas, no selection involved. Softness fades the stroke's edge and Opacity blends it over what is there; strokes and sessions otherwise behave exactly as the Selection brush's. Underneath, a painting session is a region whose effect is Flatten at that level, so it appears in the selection navigator and can be re-leveled (drag Level after painting), moved, or deleted like any region. Its cursor ring is gray, because gray is what it paints - and the stroke draws exactly what will stay: what you see under the brush while painting is the committed result, not a preview tint.
Move: Move, rotate, or resize the current selection: drag inside to move, the corner or edge handles to resize, and the handle on the stalk above the box to rotate.
Ruler: Click a start then an end point; a "Depth cross-section" window shows the depth profile along the line (length, min/max/mean depth, and a plot). Measurement only, creates no selection.

The two brushes are easy to conflate, so the differences are worth stating plainly: the Selection brush answers "WHERE should the current effect act" and paints a dashed-world thing, a selection; the Depth brush answers "WHAT depth goes here" and paints the map itself. Amber cursor ring versus gray, dashed icon versus a solid gray swatch, and only the Depth brush enables the Level slider.

The Brush row appears only while one of the two brushes is the active tool; with any other tool selected it is hidden, since its sliders have nothing to act on. Its sliders serve both brushes: Brush size is the diameter in image pixels, up to 512; Softness runs from a hard-edged disc at 0 to a fade from the centre at 1; Opacity is the stroke strength; Level is the Depth brush's gray. The cursor shows the true painted circle, with a dotted inner ring marking the solid core when Softness leaves one.

The toolbar groups the tools by job: the region-creating tools (Freehand through the two brushes, with Select all among them) sit together, and Move and Ruler - which act on or measure what already exists - sit as their own pair after a gap. The two display toggles, the cyan selection overlay and the source-image underlay, sit together at the toolbar's end.

While you drag a region with the move, rotate or resize handles, its effect is lifted: you see the depth without it, and the selection outline moving over it. The effect is applied when you release the button. That keeps a drag responsive on a large image, and there is no ghost of the effect sitting at the place the region came from.

Selection navigator

First / Previous / Next / Last move between existing selections; the count label between them reads "current / total". Delete removes the current selection.

Adjustment row (applies to a new region as you create it)

Feather: Softens the edge of a new region (Gaussian radius, in pixels).
Grow/shrink: Expands (positive) or contracts (negative) a new region by this many pixels.
Tolerance: Magic-wand only: how close in depth a pixel must be to the seed to be selected.
Source: How strongly the source image shows under the depth map, 0 to 100%. Active only while the source-image button in the toolbar is on, and greyed out otherwise. See Seeing the source image.

Effects

Chosen from the Effect combo; each relabels the Amount slider and may add an Extra slider, a direction combo (Spherize, Flatten), or Gradient's own direction dial.

None: Leaves the depth alone. This is what a new region starts on, so you can draw, feather and grow a selection first and decide what it does afterwards. A region set to None costs nothing and is kept in the project like any other.
Offset (raise/lower): Raise (nearer) or lower (farther) the depth inside the selection.
Blur: Smooths the depth inside the selection; larger radius is softer.
Spherize: Domes the selection so its center pushes toward or away from the viewer (Bulge out / Pinch in).
Bump dark: Inverts pixels darker than a threshold (dark becomes near); brighter pixels ramp toward 50%.
Flatten: Blends the selected depth toward a single target value, or toward its own mean.
Gradient: Ramps the selection between a near depth and a far depth along a direction you set by dragging the small dial's arrow to any angle - not just left/right/top/bottom, any angle in between too. The ramp runs across the selection's own bounding box, from one edge to the opposite edge along that direction.
Histogram: A Levels-style tool: Shadows/Midtones/Highlights (input) and Low/High (output range), applied to the selection's depth.
Posterize: Reduces the selection's depth to Levels equally spaced steps, so a smooth gradient becomes a stack of flat plates - cut-out layers rather than a continuous ramp. 2 is a pure near/far cut; higher counts keep more of the shape while still reading as discrete plates. The steps land on a fixed grid with the endpoints preserved, so posterizing does not shift the depth range and applying it twice changes nothing the second time.
Contour: Domes the selection following the shape you actually drew, rather than its bounding ellipse the way Spherize does - which is what irregular nebulosity needs. The outline itself is left alone, and each contour further inside is raised a little more, until Peak steps pixels in, where full Strength is reached and held for the rest of the interior. Direction chooses Bulge out or Pinch in.

Peak steps is a distance in image pixels, so a region narrower than twice it never reaches full strength: a thin filament bulges less than a broad one, which reads as a natural thickness. Useful values run from a couple of pixels on a small region to a few thousand on a large one, so its slider is not evenly spaced: the left half covers 1 to about 600 pixels, one pixel at a time near the start, and the right half reaches 5000. The box beside it always reads the real pixel count, and you can type an exact value into it. Smoothness rounds the climb into a dome, and softens the crease a bare ramp leaves along the middle of a long or bent region; it smooths the effect's own profile, never the depth underneath, so structure inside the region is not blurred away.

Undo and redo

Undo and Redo (Ctrl+Z and Ctrl+Shift+Z, or Ctrl+Y) step through the edits made here: creating a region, deleting one, Clear all, moving or reshaping a region with the Move tool, and changes to its feather, grow/shrink, effect and effect settings. A slider drag is one step, recorded when you release it.

The history is bounded by memory rather than by a fixed number of steps, because a region carries a full-size coverage image: on a large image a single reshaped region is tens of megabytes, while a change of effect settings costs almost nothing. So the number of steps you can go back depends on what those steps were. The Undo button's tooltip reports how many are held and how much they are using; the oldest are dropped as new ones arrive.

This history covers the edits, not the applying of them: Apply commits the current state to the depth map, and undoing afterwards takes the editor back a step without un-applying. Apply again to commit what you have stepped back to. The history starts empty each time the editor opens on the committed model, and is dropped by Reset from cues and by loading a project.

Which region is selected is not part of it, and the Flyby Editor keeps its own separate history.

Seeing the source image

The toolbar button beside the cyan-overlay toggle, at the toolbar's end, shows the source image underneath the depth map, so you can tell what a region actually covers. Its strength is the Source slider on the adjustment row, 70% by default; the slider is active only while the button is on.

This is a viewing aid and nothing more, in exactly the way the cyan selection overlay is. It changes nothing about the depth map, the regions or the effects, and it never reaches a render: the same edit produces the same result whether the source is showing or not, and the region you are working on stays fully editable either way.

The setting is saved with the project, so reopening one puts the editor back the way you left it.

Editing resolution (Res)

Every edit replays all of your regions over the depth map, and that cost grows with the image size and with the number of regions. On a large image each change can take a visible moment. Res sets the resolution the map is edited at, which is the one thing that removes that cost rather than hiding it.

Optimized: The default. Matches the size the canvas is displayed at, on the reasoning that a selection cannot usefully be drawn finer than it can be seen. Taken from the fitted size, so zooming does not change it.
100% to 10%: A literal fraction of the image. Lower is faster, at a coarser picture and coarser selection edges.

Apply always commits at full resolution. The regions and their pixel-measured settings (feather, grow, Blur radius, Contour peak steps) are scaled up to match, so the depth map is built at full size whatever resolution you drew at. Saving a project stores the model at full resolution too, so a project opens the same way whatever setting was in use when it was saved. At a reduced setting the region edges carry the coarseness they were drawn with, which shows as slightly softer boundaries.

Changing Res rescales the regions already drawn. That cannot be stepped back through coherently, so it clears the undo history. Pick the resolution before doing detailed work rather than partway through.

On Optimized, resizing the editor window updates the resolution to match the new canvas size, since that is what Optimized tracks. This happens only while no regions have been drawn: once there are regions, following the window would mean rescaling them and losing the undo history, which is too much to spend on a window drag. With regions present the resolution stays put and the Res combo remains the deliberate way to change it.

Other controls

Overlay toggle: shows or hides a cyan tint over the selected pixels, so it is easier to see what an effect does underneath it.
Clear all: clears all selections, restoring the base depth.
Reset from cues: re-bakes the depth map from the current cues and parameters, discarding edits made here.
Apply: applies the edited depth as the internal Depth Modelling map, at full resolution. It takes effect in the depth map only when the Depth Modelling section's Blend is above 0.
Close (Keep Edits): closes the editor without applying it to the depth map; the selections and effects stay in memory and reopening the editor picks up where you left off.

The pointer shows a busy cursor while an edit is being recomputed, and the status line says "Each edit takes a moment to recompute" when the image size and region count together make that likely. Lowering Res is the way to shorten it.

Star Distance Distribution

Reachable from Window > Star Distance Distribution..., the toolbar, or View > Star Distance Distribution.... A chart of the star sprites' depths, with the convergence and structure planes (and, optionally, a looked-up object) marked on it.

Depth mode

Over the star bars runs a cyan line: the depth map's own distribution, on the same depth axis, so you can see where the structure's material sits against where the stars sit. It is the same curve the 3D flight's depth view draws, from the same measurement, so the two windows always agree. Its height is relative to its own peak - the y axis counts stars, not depth-map pixels - and it is drawn on a square-root scale, since background outnumbers structure by orders of magnitude and a linear plot would be one spike and a flat line. The depth chart only: the depth map has no distances, so there is nothing to place it on in real distance mode.

The default view: a histogram of every painted star's depth, 0 (far) to 1 (near); near is on the left, far on the right.

Convergence (white, dotted line): the zero-parallax depth - whatever sits at this depth does not shift between the left/right eyes or wiggle frames, while nearer/farther depths shift apart. Drag the line to set Convergence manually (turns off Auto convergence).
Structure (cyan, solid line): the main structure's bright bulk level (80th percentile of the depth map) - roughly where the nebula or galaxy sits, ignoring stars. Drag the line to anchor the Structure depth section there.
A gold, dashed line marks an object looked up in this window (see "Object lookup" below), when one is set.
When a real-distance fit is available (Real Star depth model with matches, or Synthetic mode), an approximate absolute-distance ruler is drawn under the depth axis.

Real distance (pc) mode

The "Real distance (pc)" checkbox switches the chart to a histogram of the matched stars' real catalog distances, available once at least two stars have a real distance (Real Star depth model, or Synthetic mode).

The axis is linear and always starts at 0 (us), so the gaps between stars on the chart reflect how far apart they really are. The far edge is set to the 95th percentile of the matched stars' distances, so a single very-far outlier does not squash the rest of the distribution into one bar; a star beyond that edge is left off the chart (not folded into the last bar), and the count above the chart reads "N of M stars with real distances" when that happens.
Convergence and Structure stay draggable in this mode too, mapped onto the distance axis through the real-distance fit.
If Convergence, Structure, or the looked-up object falls beyond the plotted range, a clickable "<label> >" tag appears at the right edge in place of the line. Clicking it rescales the axis so that marker lands at about 90% of the width. Looking up a new object resets the axis back to the natural (95th-percentile) range first, so it does not stay stretched out for a since-replaced object.
Convert to light years / Convert to parsecs: relabels the distance axis between the two units (display only, no recompute). Disabled outside Real Star depth mode, since there is then nothing to convert.

Star Distance Distribution, Real distance mode

Star Distance Distribution in Real distance mode

The distance histogram starting at 0, with the Structure and Convergence lines, a looked-up object's gold line, and an off-chart ">" tag for a marker beyond the current range.

Object lookup

A name field and "Show object" button. Typing a name or catalog id (for example M31) and pressing Enter, or clicking the button, looks it up and draws it as the gold reference line described above. This is independent of the Shaping tab's "Match object distance": looking up an object here only charts it, it does not move the Structure depth anchor. The field is prepopulated from the Shaping tab's Object field the first time this window is opened, but can be changed to look up a different object at any time - useful for images with several catalogued objects in them.

Detected Stars table

Reachable from Window > Detected stars table... or the toolbar. Every star the detector found, one row each, with everything the program knows about it: where its data came from, where it sits in the sky, and where it was placed in depth. This is the window to open when you want to verify a star's distance, find out why something looks wrong, or edit a sprite by hand.

The columns, briefly. Source says where the star's identity came from: Gaia, Hipparcos (the bright-star fallback), Synthetic, or "-" for a detection with no catalog match. Mag is the G magnitude for Gaia matches and V for Hipparcos ones - different bands, which is why the column is not labelled Gmag. RA/Dec come from the matched catalog row, or, for unmatched stars on a solved image, from the plate solution (marked "(wcs)"). Parallax, Distance and Depth are the star's measured parallax, its distance in parsecs, and the 0 to 1 depth it received in the scene. Size is the sprite's own pixel footprint. Unknown values show as a dash, never as zero: zero is a real coordinate and a real magnitude.

Click a column header to sort (every column but Sprite); unknowns go to the bottom in both directions. The Show filter narrows the table to matched, unmatched, not rendered, or edited stars, and the count above the table follows it.
A star marked (not rendered) was detected and measured but is not in the render: dropped by the Max stars cap, or unmatched with Omit selected. Marked (edited), its sprite carries at least one eraser point (see below).
Export... writes what is currently SHOWN (the filter is part of the question you asked) to a CSV/TSV file, with unknowns as blank fields.
Right-click a row: Locate in image centres the main preview on that star; Copy sprite puts the sprite on the clipboard as a transparent image; Save sprite as PNG... writes an opaque side-by-side study - the sprite on the left, its coverage on the right (white included, black rejected, gray partial) - which survives any messenger or editor untouched, where clipboard transparency often does not.

The pane on the right shows the selected star's sprite at its own scale - 1:1 when it fits, magnified in whole steps when small, reduced only when it cannot fit - with the true size always stated underneath. Normalise brightness scales each sprite to its own peak, so its shape is visible whatever its brightness; unticked, all sprites share one scale, so two stars can honestly be compared (a faint one then looks faint). The mouse wheel zooms around the cursor, Ctrl+= / Ctrl+- zoom from the keyboard, Ctrl+0 returns to the automatic fit, and a right-button drag pans. The view survives re-renders on purpose, so you can stay on the spot you are editing.

Detected Stars table

The star table with its filter and export controls, and the detail pane showing one sprite with the Sprite eraser below it.

Sprite eraser

Detection is not always able to separate what your eye can: a companion inside a bright star's glow, or a pair too close for Split merged stars to cut apart, ends up inside one detected star. The Sprite eraser reshapes such a sprite by hand: click an area of the sprite in the detail pane, and the star light inside that circle stops being rendered as part of it.

Eraser points live in image coordinates, not in the sprite: they survive re-detection, changes to the Star detection sliders, and project save/load, without being tied to any particular detection run. They are saved with the project, and every change re-runs detection, so the render updates as you work.

Placing and sizing: Click the sprite to place a point at the current radius. Ctrl+wheel over the sprite adjusts the radius (the spin box follows), and the prospective circle is drawn under the cursor before you click, feather included, so there is no guessing. Feather is set as a percentage of the radius; the soft edge is what keeps an erasure from stamping a visible circle into a stellar profile.
Area removed: The default. The light inside the circle is gone from the frame entirely, as if the companion had never been there.
Area moved to background: The light stays in the frame as flat, non-parallaxed background: the companion stops being a separate 3D object without leaving a hole where it stood.
Area blended into glow: For a companion sitting ON a bright star's glow, where the other two modes either take the glow down with the companion (a dark hole) or keep both. This one replaces the area with the glow's own level at that distance from the star, measured from the glow itself, so the halo stays smooth and continuous. Available with AI separation and with a loaded starless + stars pair; it does nothing under classical detection.
The list: Every point is a row: position, radius and mode, colour-matched to the rings drawn over the sprite (red removed, blue background, green glow). Selecting a row finds its star in the table and centres the preview on it; right-click changes the mode or deletes the point. Clear all removes every point after asking. The Outlines checkbox hides the rings without deleting anything, so the result can be judged with nothing drawn on top of it.
Undo: Ctrl+Z / Ctrl+Y, scoped to this window: every placement, deletion and mode change steps back and forward individually.

Sprite eraser

A companion erased from a detected star: the eraser panel with its mode and feather controls, the point list, and the rings over the sprite.

Manual solve

Reachable from Edit > Manual solve.... Locates the image in the sky by having you point at objects you can name, instead of matching stars against a catalog. It needs no catalog, no approximate center and no image scale: three identified points are enough to fit a solution.

This is the way in when Locate in the Sky cannot do the field. Automatic solving works by matching star patterns, so it struggles on frames that are very wide, very narrow, sparse, heavily processed, or not really stellar at all. Everything gated behind having an astrometric solution - Real depth stars, Synthetic stars, the Star Distance Distribution's real distance mode - works exactly the same afterwards, whichever way the solution was found.

If the image already has a sky location, you are asked before the window opens whether to discard it. Declining opens nothing, so there is no way to lose an existing solution by looking. When an automatic solve fails, its dialog offers a Manual solve... button that hands straight over.

Manual solve

The Sprite eraser panel and an edited sprite

If DeepParallax Studio cannot figure out what part of the sky the image is showing, we can manually solve it by setting at least 3 identifiable points, by name, designation, or coordinates.

Identifying a point

Click anywhere on the image to place a marker and name what is there. The name is resolved against the built-in object catalog first, and against SIMBAD online if it is not bundled. You can also type a position instead of a name, which is how you use a star that has no designation anything will resolve:

Name: M42, Rigel, NGC 1976, HD 4628.
Position: 83.822 -5.391 (decimal degrees), or 05 35 17 -05 23 28 (RA in hours, minutes, seconds).

Each marker is labelled with its number and the name it resolved to.

Working with the markers

Click a marker: Re-identify it. The pixel stays where it is and only the name changes, which is what you want when the position is right but the identification was wrong.
Drag a marker: Move it to a better pixel, keeping its identification.
Ctrl+click a marker: Delete it.
Right-drag, or middle-drag: Pan the view. The mouse wheel zooms about the pointer.
Reset: Remove every point and start again.

Getting a good solution

Three points is the minimum, not the target. Spread them as widely across the frame as you can: points bunched together, or lying on a straight line, describe the geometry poorly and are rejected as degenerate. More points spread wider give a better fit and a smaller residual.

The fit refuses a solution whose points disagree with each other on image scale, which is the signature of one object having been misidentified. If you are told the points disagree on scale, one of the names is wrong rather than the whole attempt being hopeless: check the identifications before removing points.

Zoom and display

Zoom in, Zoom out, Fit, 1:1: The usual four. Fit sizes the image to the window; 1:1 shows actual pixels.
Fit window to image: Resizes the window itself so the image at the current zoom fits exactly.
Scale: The current zoom as a percentage. Type a value to go straight there.
Quality: Smooth interpolates when scaling; Precise shows raw pixels, which is easier to aim with at high zoom.
Stretch: A screen stretch for linear images, off by default. A linear image opening dark is correct behaviour, not a fault; this only brightens the display, and never affects the solution.

What is kept

Your points survive closing the window, whether you accepted or cancelled, so you can come back and add to them. They belong to the image in front of you and are cleared when that changes: opening a project, loading a different image, or loading a stars + starless pair of a different field. On a proxy swap to a proportionally larger or smaller version of the same image they are carried over and rescaled with everything else.

The points themselves are not written to the project file. What a project stores is the resulting astrometric solution, which is the part that matters once the fit is done.

Autosave and recovery

DeepParallax Studio periodically records the open project so that work is not lost if the app or the machine stops unexpectedly. It is on by default, every 10 minutes; the interval and the on/off switch are in Edit > Preferences > System.

The first record for a document does not wait for that interval: it is made about 90 seconds after you start working on it, whatever the interval is set to. The opening minutes are when a new document exists nowhere but in memory, so waiting a full interval would leave exactly that stretch unprotected.

It never writes to your project file. The autosave is a separate small file kept with the application's own data, not in the folder your project lives in. Saving a project has to be something you asked for.

What is recorded

Your work, not your pixels: every parameter, the flyby or 3D flight path, the depth model with all its regions, the star settings, the Post grade, and a note of which image files the work was based on. That is typically a few kilobytes - never the images - which is what makes it affordable to write on a timer.

A saved .dpproj is the opposite by design: it embeds every image so it is self-contained and can be moved or sent to someone else. A project built on a large mosaic can run to several gigabytes, so a full copy every few minutes would take minutes each time and stall the app. The images are already on disk, and the autosave points at them.

The one consequence: recovery needs those files to still be where they were. If one has been moved or deleted, everything else is restored and the missing file is named, so you can open it again and carry on.

When it runs, and when it does not

The countdown starts over, and the recorded file is cleared, whenever the work is safe or deliberately abandoned: saving the project, opening a project, opening an image, File > New, and closing the app normally. A file left behind therefore means the app did not close normally, which is exactly when it is worth offering.

An autosave is skipped when there is nothing to protect or when writing would interrupt you: nothing has changed since the last save, no image is open, a render or an export is running, a dialog is open, the mouse button is down, or a preview is playing. A skipped attempt is retried within seconds rather than deferred to the next interval, so a record that happens to come due during a render is not silently postponed for another full period. When one is written the status bar says Autosaved briefly. Nothing else interrupts you.

Recovering

If work from a previous session is found at startup, you are asked whether to recover it, and told which project it belongs to and when it was recorded. Discarding deletes it.

Recovering reopens the images the work was based on and restores the settings over them. The result is treated as unsaved work: it has no project file of its own, so Save asks where to put it rather than overwriting the project it came from with state you have not looked at yet. The name it offers is dpRecovered-<project>.dpproj in the folder the original project lives in, or dpRecovered.dpproj for work that had never been saved, numbered -01, -02 and so on if such a file already exists.

Running two copies of the app at once is fine. Each knows which recovery file is its own, so one window never offers to recover, or deletes, the work of another that is still open.

Hints

Workflow advice that pays off once the basics are familiar, and the handful of behaviours that surprise people the first time they meet them.

A new point will not move: it is showing the whole image

Add a second point to a fresh flyby, try to drag it, and it springs back to the centre. Nothing is stuck. A new point starts at Zoom 1, which frames the entire image - and the only place a view that large can sit is dead centre. There is nowhere to move it to.

Give it something to travel in first: raise Zoom in the point's properties, or drag one of the side handles of its rectangle on the canvas (the handles at the middle of each edge zoom; the corner ones rotate). The rectangle is drawn green while the view fills the image and turns cyan as soon as it is smaller than the image - cyan means "this view can travel". Then the point drags freely.

The colour follows the view's real size, not the zoom number: with a Flyby frame set, a view can be smaller than the image at Zoom 1 and is cyan and movable straight away.

Preview one point, not the whole flyby

Rebuilding an entire flyby to judge one waypoint is the slowest way to work, and on a long path or a large image it is slow enough to break concentration. Play point preview in the Flyby Editor toolbar renders a window around the selected point instead: it enters at the arrival of the previous point, so you see the move into the point as well as the point itself, then carries on for a set number of further points. One or two is usually all you need. Right-click the button to set that number where you are using it, or set it in Preferences under Rendering - both write the same value. Play until the end, in either place, ignores the count and runs through to the last point. A short preview rebuilds quickly enough to try several values of a parameter in the time one full rebuild would take.

Watch what a parameter does to the shot, not to the number

Flyby parameters interact, and the interesting question is always what it looks like, not what the number reads. Change one thing, preview that point, watch. A few pairings that are much easier to see than to reason about:

Ease against the move's length. Ease in-out flatters a long travelling move and makes a short one look hesitant; on a two-second move, Linear often reads better than any of the curves.
Warp depth % against what is in the foreground. The dive is what sells the travel, but it also pushes more of the frame past the camera, so gaps behind near structure show up. The right value is the one you find by walking it up until they do.
Zoom against the next point. Two points that both zoom in leave the second one with much less room to move than the panel suggests.
Stay with Hold. A pause reads as deliberate or as a stall depending entirely on its length, and there is no way to know which from the number.

This is what makes the short preview above worth setting up: it turns "try it" into a few seconds rather than a coffee break.

Parallax speed is the ratio of Frames to FPS

Inside a point's During move and On arrival groups, Frames is the length of one complete parallax cycle - out to one side, across to the other, and back. Fewer frames is a faster sweep. Every row in these two groups is opt-in: tick it to change it at this point, leave it unticked and whatever is already in effect carries on.

Tick FPS as well and the pair stops counting frames and starts stating a duration: Frames 20 at FPS 10 is a two-second cycle, and Studio stretches that cycle over however many real frames two seconds take at the clip's own rate. That is what makes a sweep look the same speed whether you finally render at 24 or 60 fps. Leave FPS unticked and Frames counts real frames of the clip, so the same setting sweeps faster in a slower clip.

Note that the point's own Frames, up in the point properties, is a different control with the same name: it is how many frames the move into the point takes - its duration, not the sweep's. Worth knowing before adjusting one and wondering why nothing changed.

Make the motion read as travel, not as a wobble

A parallax sweep that runs back and forth on the spot reads as a wiggle. The same machinery reads as continuous movement through the field if you point it where the camera is going:

Set the Angle in During move to the direction of travel - 0 sweeps horizontally, 90 vertically - and usually the same in On arrival, so the motion does not turn a corner the moment the point lands. The arrow buttons between the two groups copy a whole set up or down, which is quicker than typing it twice. A change of Angle is adopted at the next moment the sweep crosses its centre, so expect it a few frames late rather than instantly.
Make the cycle long enough that it does not visibly repeat inside the move: a sweep that completes several cycles while the camera travels a short distance announces itself as a loop. Compare the point's Frames (the move) with the group's Frames (one cycle) and keep the cycle the larger of the two if you want no repeat at all.
Raise Warp depth % so the move dives into the scene rather than sliding across it - the depth change is a large part of what sells travel. It applies to the Fly to and Fly in move kinds only; Zoom to and Stay have no pan to dive through.

The two small arrows drawn through each point's marker show the sweep direction and, by their length, the amplitude - so you can see the angles agreeing along the path without opening every point in turn.

Working on a proxy, rendering at full size

Every preview, every depth rebuild and every frame of a flight costs more on a large image. The way to keep the design work responsive is to do it on a reduced-size copy and swap in the full-resolution frames only for the final render.

Studio recognizes that swap. When you open an image, or load a stars + starless pair, whose dimensions are proportional to the one already loaded - the same shape at a different scale - it asks what to do with the work you have already done:

Carry over: Everything shaped against the old pixels moves onto the new grid: Depth Modelling regions are rescaled, an External depth map is resampled, a flyby path's pixel coordinates are rescaled, and the link to the project file is kept, so Save writes the same .dpproj now built against the new images.
Start fresh: The new images are treated as a different subject. The Depth Modelling sculpt, the External depth map and the project link are dropped, exactly as they are for any other size change.
Cancel: Nothing is loaded and the current document is left untouched.

The dialog lists what is actually at stake before you choose, and appears only when there is something to carry.

A 3D flight is kept either way. Its waypoints are world units rather than image pixels, so they do not depend on the image size at all and there is nothing to rescale. This is why swapping in a larger image never asks about a 3D flight, only about a 2.5D flyby path, whose waypoints really are pixel coordinates.

Proportional means both dimensions scale by the same factor, allowing 1% for the rounding a resized proxy picks up. A crop changes one ratio and not the other, so it is not a proxy of the same field and is handled as an ordinary size change.

A carried-over session counts as unsaved work, since it no longer matches the project stored on disk.

Big stars with ragged masks, and holes as they move

If a large star seems to carry an arbitrary, lumpy mask instead of a clean round one - and leaves a hole behind it as the parallax moves - turn Split merged stars off, in the Stars tab's Star detection section. Splitting is aimed at dense fields of similar stars; on a big star with a wide glow it can divide what should stay one sprite.

When a flyby needs splitting and has large stars in it, you do not have to choose. Render the flyby twice, identical but for that checkbox, and blend the better passages of each in your video editor. The two renders line up frame for frame, so the cut can fall anywhere.

Judge parallax in motion, not in a still

Depth mistakes hide in a static frame and jump out the moment the scene moves. A mask that looks acceptable, a star sitting at the wrong distance, a structure edge that is really a step - all of them read as ordinary until parallax slides the layers past each other.

Press Play parallax motion (toolbar, or View > Play parallax motion) and leave it running while you work: the controls stay live during playback, so you can drag Parallax amount on the Parallax tab and watch the error grow or vanish. Turn it up higher than you intend to ship for the diagnosis - an exaggerated move makes a small mistake obvious - then bring it back down. It is the cheapest test in the program.

The star layer decides how good the depth can get

Everything the Real Star depth model does rests on stars being found, and found separately. Two stars merged into one detection share a single distance no matter how good the catalog is.

Before tuning depth, open Window > Detected stars table... and click the Size (px) header to sort by sprite size, largest first. Click the top few rows and look at the sprite in the pane on the right: each should be one star, not a cluster of them. If they are clusters, that is what Split merged stars (Stars tab, Star detection) is for. If one sprite holds a bright star plus a companion the splitter deliberately leaves alone, the Sprite eraser below the pane can take the companion out by hand. The Show filter set to Matched only tells you how many stars actually carry a real distance - the number the whole model rests on.

Nothing is measured about a nebula's interior

Catalogs know how far away an object is; nothing anywhere knows how its gas is arranged along the line of sight, for any nebula. So the method is: anchor what IS known, then sculpt the rest deliberately.

Anchor the distance. Type the object's name in the Object field of Structure depth (Shaping tab) and use Match object distance. Open Window > Star Distance Distribution... to see it: the gold line is the object's catalogued distance, the cyan line is where your structure currently sits. Drag the cyan line onto the gold one, or set Depth in the same section until they meet.
Decide how deep it extends. Thickness, in Structure depth, spreads the cloud around that anchor. There is no measurement to match here - the chart shows you what you are choosing.
Sculpt the inside. Click Edit depth map... in the Depth Modelling section (Shaping tab) and shape it by hand, guided by what the image tells you: dust lanes silhouetted against emission are in front of it, a rim lit by a cluster faces the cluster, dense knots stand apart from diffuse veils.

That is the honest method, not a workaround for a measurement you failed to find.

Save the project, not just the video

A .dpproj holds every setting, the flyby path, the depth sculpt and the images themselves - the source, and the starless and stars layers when you have them, stored as complete XISF inside the file. It is self-contained: copy it to another machine and it opens with everything in place, nothing to relink.

File > Save Project As... the first time, then Ctrl+S as you go. That completeness is why a project file is large - it holds your images - and why it is the thing worth keeping: it is what lets you come back a year later and change the camera move without redoing any of the depth work. Autosave (Preferences, System) is a crash net, not a substitute: it is cleared the moment you save, and it records the settings, not the images.

A control that does nothing is usually a mode, not a bug

Several sections apply only to a particular way of working, so they grey out or disappear rather than mislead:

Max star radius and Background scale are dead under AI Star separation - that input is already a stars-only layer, with no nebulosity to reject and no background to model. Untick AI Star separation (Stars tab) to use classical detection and they come back.
All four detection sliders are dead on a loaded starless + stars pair: the star layer is read with fixed settings, because it is your layer, not something Studio detected. Remove companions and Split merged stars do still apply there.
The star overlay's All / Known / Unknown drop-down appears only in Real Star depth mode, the only model that cross-matches and so the only one that can tell a known star from an unknown one.
Everything on the Stars tab goes dead when Star separation is unticked, and the whole left panel is dead until an image is loaded.

If a control is missing or grey, the mode you are in has no use for it - look at the mode first, not at the control.

Trial exports are capped, and that is all

Two separate trial restrictions, and they apply to different things:

Size limits video only, to 1280x720 - parallax motion, flyby, VR180's MP4 and Apple Spatial alike. Aspect ratio is kept and nothing is upscaled. Nothing else is ever size-limited.
The wordmark is drawn into video and into stereo stills (anaglyph, side-by-side, VR180 stills). Data views - the depth map, the starless and stars-only layers, the source - carry no mark at all, because a wordmark burned into a depth map would corrupt the very values that make it useful.

So the depth engine, the catalogs and the editors are the finished product, and File > Export... writes any view at full native resolution. To judge output quality without a mark, export the depth map or the starless layer; to judge the 3D itself, use the preview, which is never marked. Entering a license (Help > License...) lifts both restrictions immediately - nothing to reinstall, no work lost.

Menu reference

Everything in the Edit menu except License and Preferences acts on a loaded image, so those entries stay disabled until one is open. Loading a path or a profile into an empty session would only leave it waiting for an image that may never arrive, or be replaced by the next project opened.

Menu	Item	What it does
File	New	Closes the current document and returns to the empty window, offering to save unsaved work first.
File	Open Image...	Load the working image.
File	Export <current view>...	Writes whatever the preview is showing, rendered fresh at full resolution. The item names the view it would write, so it reads "Export depth map...", "Export anaglyph...", "Export starless..." and so on. See Exporting the current view.
File	Open Recent	Files grouped by what they are: projects, images, stars + starless pairs, depth maps, scripts and color depth profiles. Each group keeps its own 20 most recent entries, so a run of image opening cannot push the project you want off the end, and a group appears only once it has something in it. A stars + starless pair is one entry holding both files, and reopens both. A depth map reopens as a depth map rather than as the working image. Each group can be cleared on its own.
File	Open Project..., Save Project, Save Project As...	Load or save a `.dpproj` project. Save Project needs only an image, not an existing project file: with no file yet it asks where to save, and its menu entry shows an ellipsis to say so. Afterwards it saves straight over that file.
File	Exit	Closes the program, offering to save unsaved work first.
File	Export Parallax Motion..., Export Flyby..., Export VR180..., Export Apple Spatial (stereo pair)...	Video and stereo-image export. Apple Spatial writes a frame-packed side-by-side MP4 (royalty-free H.264) with the spatial-video metadata Apple devices read; it needs ffmpeg configured (see Preferences). The video export dialog's 3D format choice renders parallax motion, flybys and 3D flights as stereo video, and the VR180 / Apple Spatial doors can carry that motion in their own containers - see Exporting video in 3D.
Edit	Rescale flyby coordinates...	The Script Coordinates Converter, outside the Flyby Editor. Available only while an ordinary flyby path is loaded: it rewrites literal x,y pixel coordinates, which a 3D flight does not have, its camera being in world units.
Edit	Blend starless and stars	Merges a loaded starless layer and its stars layer back into one ordinary image, which re-enables the features that need a single image. The two layers stop being separate, so this cannot be undone from within the app; reload the project to get them back. Available only when a starless + stars project is loaded.
Edit	Load flyby script...	Load a flyby path from a file (`.dpsc`, `.txt`, `.flyby`). It takes either kind: a hand-written script, a path saved from the Flyby Editor, or a 3D flight.
Edit	Load 3D flight path..., Clear 3D flight path	Load a 3D flight from a `.dpsc` script file, which becomes the current path, or drop back to an ordinary flyby. This is the stricter door than Load flyby script above: it refuses anything that is not a flight, so picking the wrong file says so rather than quietly loading a 2.5D path. Clear is available only while a flight is loaded. A 3D flight can also be started from scratch in the Flyby Editor's `New` menu.
Edit	Load/Save color depth profile...	A reusable `.dpcol` file of the Color depth tab's 10 rows. Save appears only while that section is switched on.
Edit	Manual solve...	Locate the image in the sky by clicking and naming known objects, when automatic solving cannot (see Manual solve).
Edit	Preferences...	See Preferences.
View	Original image / Depth map / Anaglyph (red/cyan) / Side-by-side stereo / Starless image / Stars only / Starless + synthetic stars	The live preview mode (also on the toolbar).
View	Star overlay	Marks the detected stars, in any star mode. In Real Star depth mode the color reads the catalog match: green for matched, cyan for bright matched, amber for unmatched; in the other modes every detected star is amber. Which stars are marked (All / Known / Unknown) is chosen on the drop-down beside the toolbar button, in Real Star depth mode only. See Star overlay for reading a crowded field.
View	Ring only near the pointer	Marks only the stars around the mouse pointer instead of all of them at once, for a field too crowded to mark in full. Nothing is filtered out: sweeping the pointer reaches every star. Remembered between sessions. See Star overlay.
View	Play parallax motion, Play flyby	Starts playback.
View	Locate in the Sky...	Plate-solve the current image.
Window	Flyby Editor..., Script Editor..., Depth Modelling Editor..., Star Distance Distribution..., Detected stars table...	One launcher per tool window; each shows a checkmark when its window is currently open, and clicking always opens or raises it (never closes it).
Help	DeepParallax Studio Help	Opens this page in your system browser (shortcut F1).
Help	Check for Updates...	Asks the Deep Sky Colors repository whether a newer version exists, and reports either way. The same check runs at launch unless it is turned off in Preferences.
Help	License...	Shows the current license state and is where a purchased key is entered. On a subscription it can also collect a renewal that has already been issued, and offers the upgrade to a permanent license. See Licensing.
Help	Extended Star Catalog...	For owners of that add-on, downloads and installs the extended Gaia catalog and reports what is already installed; without it, explains what the add-on is.
Help	About DeepParallax Studio...	Version and credits.

Preferences

Complete Preferences window

Edit > Preferences.... Every change applies immediately - there is no OK or Apply. The dialog mirrors the sections below; System and Advanced start collapsed, and the window shrinks back when a section is folded.

Interface

Theme: System, Light, or Dark. System follows the operating system's light/dark setting.
Accent color: The highlight color used throughout the interface.
Secondary color: The section-title color in dark mode. Light mode is unaffected.
Units: Show parameter values as raw 0 to 1 (PixInsight style) instead of the default 0-100%. Display only; stored and project values are always 0 to 1.
Main toolbar: Show or hide each toolbar group independently: View, Load / Save, Export, Play, Flyby, Tools.

Rendering

Play point preview - points ahead: How many waypoints after the selected one the Flyby Editor's Play point preview renders, 1 to 20 (default 4). The preview always enters from the arrival of the point before the selected one, so you see the move into it as well. Play until the end ignores the count and previews through to the last point. Both are also reachable by right-clicking the Play point preview button in the Flyby Editor.
Use the GPU when building 3D flight previews: On by default. Adds the graphics card to the 3D flight preview build alongside every processor core - see 3D flight. Playback itself shows pre-rendered frames either way, and exports always use the standard renderer. Machines without OpenGL 3.3 build on the processor alone automatically, so this switch exists mainly for troubleshooting a misbehaving graphics driver. Takes effect the next time a flight starts playing.
Stars keep their true color on any background: Gives each star its real recorded color so it holds that color wherever it is drawn - a flyby carrying it over a different part of the nebula, or a 3D flight past the structure onto black. Off uses the raw separated-stars layer, which is exact over each star's home background but shifts color (often toward green) elsewhere. Takes effect on the next render.

Video export (ffmpeg)

Locate ffmpeg / Auto-detect: Point at the ffmpeg executable, or clear the manual path and fall back to finding ffmpeg on your PATH. The status line above the buttons says which one is in use. ffmpeg is required for video export; still exports never need it.
Warn at startup if ffmpeg is not found: Re-enables (or silences) the one-time startup notice. The notice's own "Don't remind me again" is the same switch from the other side.

System

Max RAM for preview cache: Share of free memory (20 to 80%, default 80) the parallax-motion / flyby preview may use to pre-render frames for smooth playback. Frames beyond this budget are rendered live during playback, so a very long or 4K clip may not stay perfectly smooth toward the end. Higher is smoother but uses more RAM.
Autosave recovery information: Periodically record the open project so it can be recovered after a crash - every 5 to 60 minutes (default 10), with the first record about 90 seconds into a session. This never touches your saved .dpproj: it writes a small separate file, cleared whenever you save. Turning the checkbox off stops it entirely and disables the interval box. See Autosave and recovery.
Automatically check for updates on launch: On by default: asks the Deep Sky Colors repository for a newer version when the app starts, and stays silent when you are current. A manual check is always available from Help > Check for Updates.

License

The current license state - who the license belongs to, its kind, and for a subscription its renewal date. Two buttons appear for subscribers only: Refresh license now collects a renewal that has already been issued, so a new key never has to be dug out of an e-mail; Upgrade to permanent... opens the discounted trade from the recurring subscription to a one-time permanent license. See Licensing for the full picture.

Advanced

AI Stars Separation model: Load a trained ONNX star-separation model, or fall back to the one shipped next to the app. The status line names the model in use.
Solving catalog: An optional denser, positions-only catalog for plate-solving. When none is set, solving uses the Real depth stars catalog - which works, but a denser positional set solves more fields.

Licensing

Studio is its own product. A license for the PixInsight DeepParallax module does not unlock it, and a Studio license does not unlock the module; the two are sold separately. Licensing is verified fully offline: the app embeds only a public key, so it can check a license but never mint one. Enter your email and key in Help > License... to activate; that dialog also reports the current state at any time.

Trial

DeepParallax Studio runs on a 14-day trial from first launch, tracked independently of any other app. A trial copy is fully functional. Two limits apply when a file is written, and they cover different things:

Output size: video only: Video is fitted inside 1280x720: parallax motion, flyby, VR180's MP4 and Apple Spatial. The aspect ratio is preserved and nothing is ever upscaled, so an export you asked to be smaller keeps the size you chose. Nothing else is size-limited. A trial copy writes stills, depth maps and the starless and stars-only layers at full native resolution.
Branding: video and stereo: A "Made with DeepParallax Studio" mark, sized in proportion to the frame, is drawn into video, into anaglyphs and into stereo pairs, VR180 stills and Apple Spatial included. The depth map and the image layers carry no mark: they are working material, and a mark burned into a depth map would corrupt the values that make it useful.

A license of either kind lifts both. After the trial the app does not start until a key is entered: there is no permanently-free mode.

License types

Studio is sold under two kinds of license. Both unlock every feature and both lift the trial limits in full; what differs is how long the license lasts and which versions it covers. A key carries its own kind, so there is nothing to pick in the app: enter the key you were issued and it behaves accordingly.

Classic: Perpetual: it never expires. It covers the major version it was bought for, and every update within that major version is free. A future major version needs a new key.
Subscription: Runs for a term and carries its own end date. For as long as the term lasts it covers every version, new major versions included, so upgrades are free whatever the version number. Renewing extends the term from its existing end date rather than from the day you renew, so renewing early never costs you days.

The License dialog shows which one is on file. A subscription adds a line reading "Subscription active until" with its date and the days remaining; a Classic license simply shows the address it is registered to, since there is no date to report. A Refresh license button appears only when a subscription is on file, whether it is still running or has lapsed: it fetches a renewal that has already been issued, so a renewed key does not have to be typed in by hand. It is the one part of licensing that uses the network, and it is optional; everything else works offline.

A subscription that has run out is reported as exactly that, with a prompt to renew and enter the new key. It is never described as an invalid key or an expired trial, so a lapsed subscriber is never told their key was never good.

Third-party components

Everything below is summarized in licenses\THIRD-PARTY-NOTICES.txt inside the installation folder, with the full text of each license beside it.

Qt 6.8.3: The application framework, used under the GNU Lesser General Public License version 3. Qt is used unmodified and is linked dynamically: the Qt libraries are the separate Qt6*.dll files in the installation folder, not built into the program, so they can be replaced with another build of the same Qt version. The complete corresponding source for Qt 6.8.3 is published by The Qt Company at https://download.qt.io/archive/qt/6.8/6.8.3/single/. The LGPLv3 applies to Qt, not to DeepParallax Studio, which uses Qt as a library rather than deriving from it.
ONNX Runtime 1.27: Microsoft's inference engine, under the MIT license. It runs the AI depth and AI star separation models.
Raleway: By the Raleway Project Authors, under the SIL Open Font License 1.1. Four weights are compiled into the application and used for the wordmark on the splash screen, so it renders identically on every machine. The font is not installed on your system and no other application can see it.
FFmpeg: Not included. Video export runs whichever ffmpeg you already have, found on your PATH or chosen in Preferences, as a separate program exchanging frames over a pipe. Nothing of FFmpeg is contained in, downloaded by, or installed with DeepParallax Studio, and your copy stays under whatever license it was built and obtained under.

DeepParallax Studio Help

Contents

Getting started

Two minutes to your first parallax motion

The window at a glance

Status bar

Stars tab

Star separation

Star detection

Star depth

Real depth stars (sub-group, Real Star depth mode)

Advanced Star Profiling

Synthetic real depth stars

Star overlay

Reading a crowded field

Depth tab

Depth filters

Image depth

Narrowband depth

Shaping tab

Color depth

External depth map

Structure depth

Depth Modelling

Parallax tab

Stereo

Parallax motion (wiggle)

Flyby frame

Post tab

Tone

Color

Exporting the current view

Flyby Editor

Toolbar

Point properties panel

Canvas interactions

Undo and redo

3D flight

Structure and stars are treated differently

3D waypoint panel

3D scene panel

Depth view

Rendering and playback

Exporting video in 3D

The cup of coffee

Flyby script language

Instant pan/zoom

Animated moves

Wiggle / parallax overlay

Timing, looping, variables

3D flight script

path_start

scene

render

stars

path_begin, waypoint, path_end

Free-form commands

Set the camera at once

Animated moves

Loops and variables

Script Editor

Depth Modelling Editor

Selection tools

Selection navigator

Adjustment row (applies to a new region as you create it)

Effects

Undo and redo

Seeing the source image

Editing resolution (Res)

Other controls

Star Distance Distribution

Depth mode

Real distance (pc) mode

Object lookup

Detected Stars table

Sprite eraser

Manual solve

Identifying a point

Working with the markers

Getting a good solution