Build a scene from an aligned image dataset

Splatfiction creates and displays a 3D Gaussian-splat scene from an already aligned image dataset.

The input must already contain:

• the source images used by the reconstruction;
• camera intrinsics, including image dimensions and lens calibration;
• camera extrinsics, meaning the solved position and orientation of every registered image; and
• a sparse 3D point cloud associated with those cameras.

Splatfiction then reads the alignment, initializes the Gaussian scene, optimizes it against the registered images, displays the reconstruction in the browser, and exports the resulting scene.

Pipeline summary

The canonical input is a COLMAP-compatible reconstruction folder. Use one coherent model and the exact images referenced by that model.

my_scene/
├── images/
│   ├── image_0001.jpg
│   ├── image_0002.jpg
│   ├── image_0003.jpg
│   └── ...
└── sparse/
    └── 0/
        ├── cameras.bin
        ├── images.bin
        └── points3D.bin

Required files

Use the binary COLMAP model shown above unless the current Splatfiction build explicitly offers another import format.

Dataset integrity rules

Before import, verify all of the following:

1. Every image name referenced by images.bin exists under images/ with the same spelling and extension.
2. The images have not been renamed after alignment.
3. The images have not been resized, cropped, mirrored, rotated, or re-encoded with a changed orientation after alignment.
4. cameras.bin, images.bin, and points3D.bin come from the same reconstruction.
5. The imported images match the calibrated image dimensions stored in the camera model.
6. The sparse model contains registered cameras and valid 3D points.
7. If the alignment uses undistorted images, import those exact undistorted images—not the original distorted files.
8. Keep only the model that you intend to train under sparse/0/.

A dataset can look visually correct in a file browser while still being invalid for reconstruction. Splatfiction relies on exact correspondence between image pixels, camera calibration, solved pose, and sparse geometry.

Splatfiction is downstream of the alignment application. The alignment may come from COLMAP, GLOMAP, RealityCapture, Metashape, HLoc, or another solver, but it must be exported into a compatible camera-and-sparse-model structure before import.

Do not modify images after alignment

Any pixel-space change can invalidate the solved camera model:

• resizing changes the focal length and principal point in pixel units;
• cropping changes the principal point and image dimensions;
• rotating changes the image coordinate system;
• mirroring changes handedness;
• lens correction changes the projection model;
• replacing an image with an edited version may change geometry-visible content.

When smaller images are required for memory or performance, resize them before alignment and solve the cameras against those resized images. Do not resize only the images while keeping the old camera files.

Registered and unregistered images

Only registered images with valid poses contribute to training. For a clean production dataset, place the registered subset in images/ and remove unrelated files, thumbnails, previews, videos, hidden exports, and duplicate image versions.

Multiple camera models

A reconstruction may contain several physical cameras or focal lengths. This is valid only when every registered image references the correct camera entry. Unsupported projection models should be converted or undistorted in the alignment application before import.

Splatfiction performs the reconstruction on the user's device. The practical project size therefore depends on browser support, system memory, GPU memory, image resolution, camera count, and the selected reconstruction settings.

Use:

• a modern 64-bit desktop browser with WebGPU available;
• an up-to-date graphics driver and operating system;
• sufficient system RAM for decoded images and reconstruction state;
• sufficient GPU memory for image data, Gaussian parameters, and rendering; and
• enough free local storage for recovery data and exported scenes.

A discrete GPU or Apple Silicon system is recommended for substantial datasets. Integrated GPUs may work for small scenes but can reach memory limits quickly.

During a reconstruction

• Keep the Splatfiction tab open.
• Prevent the computer from sleeping.
• Avoid running several Splatfiction reconstructions in different tabs.
• Close other GPU-heavy applications when memory is limited.
• Do not clear browser site data while a project is active.

GPU utilization does not need to remain constant. Dataset inspection, image decoding, memory transfer, serialization, and browser work can be limited by CPU, storage, or browser scheduling rather than the GPU.

On first use, review and accept the current Beta Use Conditions. The acceptance control is required before protected application functions are opened.

The main application header contains:

• Storage — local projects, recovery data, preferences, and optional privacy choices;
• New — create a reconstruction from an aligned dataset;
• Open — open a saved Splatfiction project or a supported Gaussian scene;
• Export — save the active reconstruction in an available output format.

When no scene is active, the application displays No project open and waits for a new or existing project.

Step 1 — Select New

Choose the root folder of the aligned dataset. Select the folder containing both images/ and sparse/, not only the image folder and not only sparse/0/.

The browser may ask for permission to read the selected folder. Splatfiction only receives access to files that the user deliberately selects through the browser interface.

Step 2 — Let Splatfiction inspect the dataset

The workspace preparation screen uses four user-facing stages:

1. Read — enumerate and read the selected project files;
2. Inspect — identify the dataset structure and validate required data;
3. Decode — decode images and reconstruction records;
4. Display — initialize the local scene and viewer.

Do not begin training when inspection reports missing images, invalid camera records, an empty sparse model, incompatible image dimensions, or an unsupported file structure.

Step 3 — Verify the imported alignment

Before starting optimization, check the imported scene information and any available camera or sparse-point preview.

Verify that:

• the expected number of registered images is present;
• camera positions surround or traverse the reconstructed subject correctly;
• cameras point toward the scene rather than away from it;
• the sparse points form a recognizable version of the subject;
• the model is not mirrored, exploded, collapsed, or located at an extreme scale; and
• there are no large groups of unrelated cameras or points.

A visibly incorrect camera arrangement is an alignment problem. Gaussian optimization cannot repair fundamentally incorrect camera poses or calibration.

Step 4 — Configure the reconstruction

The exact controls may change during the beta. Depending on the active build, Splatfiction may expose automatic settings or controls for image resolution, optimization length, Gaussian count, densification, pruning, or quality/performance balance.

The important relationships are:

Start with the automatic or balanced configuration for the first run. Increase detail only after the dataset has completed successfully and the remaining limitation is clearly reconstruction capacity rather than alignment quality.

Step 5 — Select Train

Training begins from the imported sparse model and solved cameras. A typical run passes through user-visible work corresponding to:

1. loading camera and image data;
2. initializing the Gaussian representation;
3. optimizing appearance and geometry against the aligned views;
4. adding detail through densification;
5. removing weak or unnecessary Gaussians;
6. final refinement; and
7. preparing the scene for interactive display and export.

The viewport may initially appear sparse, blurred, cloudy, or incomplete. Early training state is not the final quality target. Evaluate the model after densification and final refinement have progressed.

Step 6 — Use Stop only when necessary

Stop the run when:

• the wrong folder was selected;
• camera geometry is clearly invalid;
• memory use is approaching a system limit;
• the scene remains structurally incorrect because of bad input; or
• the browser reports an unrecoverable error.

Do not treat a manually stopped intermediate state as a finished production result unless the interface explicitly confirms that it is complete and exportable.

A Gaussian scene should be judged from within and near the camera coverage used for training. Large movements far outside the solved camera envelope expose regions that were never observed and are not reliable reconstruction targets.

Navigation

Use the viewer's on-screen controls to:

• orbit around the scene;
• pan the camera;
• move closer or farther away;
• reset or frame the scene when available; and
• enable camera, sparse-point, or diagnostic overlays when offered by the current build.

What to inspect

Review:

• high-contrast edges and corners;
• thin structures;
• floors, ceilings, and wall intersections;
• reflective and transparent surfaces;
• regions seen by only a small number of cameras;
• foreground/background boundaries;
• exposure transitions between cameras; and
• areas near the limits of camera coverage.

Reading common visual defects

Correct the alignment when the defect is pose- or calibration-related. Changing Gaussian settings cannot reliably compensate for an inconsistent camera solution.

Select Open to load an existing item supported by the current build.

Splatfiction may distinguish between:

• a Splatfiction project or recovery file, which can contain scene state and project metadata; and
• an imported Gaussian model, which may contain only the final renderable scene.

A final Gaussian model is not equivalent to a complete training project. It may not contain source images, camera records, optimizer state, or the information required to resume training.

Gaussian PLY versus ordinary point-cloud PLY

A standard XYZ or XYZRGB point cloud is not automatically a Gaussian-splat scene. A Gaussian PLY requires the attributes used by a compatible Gaussian renderer, such as opacity, scale, rotation/covariance, and appearance coefficients.

When a generic point cloud is selected, Splatfiction may reject it or display it differently from a trained Gaussian scene.

Select Export after the reconstruction has completed and passed visual inspection.

Only use formats displayed by the current Splatfiction build. Export options may change during the beta and may include a Gaussian scene file, a Splatfiction project/recovery package, or other supported output.

Before export

1. Confirm that training has finished rather than merely paused or stopped.
2. Inspect the complete scene from several viewpoints.
3. Check that the orientation and scale are suitable for the intended downstream application.
4. Record the settings used for the successful run.
5. Keep the original aligned dataset; the exported Gaussian scene is not a replacement for source images and camera data.

Downstream compatibility

A Gaussian scene is not a polygon mesh and normally does not include conventional UVs, texture maps, topology, or watertight surfaces. Open the export only in software that supports the selected Gaussian format and attribute layout.

Large, high-detail scenes can produce large files. Compression or conversion may reduce size, but conversion can also remove attributes, spherical-harmonic detail, precision, or compatibility. Preserve an original export before creating downstream variants.

Under the current Beta Use Conditions, an Output created through permitted direct human-operated use may be published, delivered, licensed, or sold, subject to rights in the source material and the restrictions on reselling or automating the Splatfiction service itself.

Splatfiction is local-first. During ordinary use, selected source files, scene state, recovery points, and exports are processed in the browser and remain on the device by default.

Open Storage to review or remove:

• locally saved scenes;
• recovery data;
• workspace preferences;
• the local Terms acceptance receipt; and
• optional analytics or contribution choices.

Local storage is not a backup

Browser-stored data can be removed by:

• clearing site data;
• browser cleanup settings;
• operating-system storage pressure;
• browser or application updates;
• corruption or an interrupted write;
• private/incognito-session closure; or
• manual removal in the Storage panel.

Always keep independent copies of:

• the aligned input dataset;
• the final exported Gaussian scene; and
• any Splatfiction project package offered by the application.

Analytics and optional contribution

Performance analytics and project-data contribution are separate choices and are off until enabled. Ordinary local use does not require either option.

When optional contribution is deliberately selected, the review interface must identify the categories included in the package before upload. These may include reduced images, camera calibration or poses, sparse or dense reconstruction data, point clouds, meshes, Gaussian splats, settings, quality measurements, or limited diagnostics.

The dataset is not recognized

Check that the selected root contains images/ and sparse/0/, and that the three required COLMAP binary files are present. Remove archives, nested duplicate project folders, and unrelated files.

Splatfiction reports missing images

The names in images.bin do not resolve to files under images/. Restore the original names and directory structure or re-export the alignment correctly.

Images have the wrong orientation

The pixel data or EXIF orientation changed after alignment. Export physically oriented images before alignment, or regenerate the camera model for the exact image files being imported.

Cameras load but the scene is empty

Confirm that points3D.bin is not empty, that the registered images belong to the same sparse model, and that the imported component is the intended reconstruction.

The scene is doubled, split, or exploded

Inspect the source alignment for disconnected components, pose outliers, wrong intrinsics, mixed image sets, or images modified after registration. Correct and re-export the alignment before retraining.

Training begins with a black or nearly empty viewport

Allow initialization to complete, then verify camera direction, scene scale, sparse-point presence, and browser/GPU compatibility. A persistent empty scene after initialization usually indicates invalid input or a failed GPU stage.

The page runs out of memory or crashes

Reduce project size at the dataset level, use lower-resolution images that were aligned at that resolution, select a lower-memory reconstruction configuration, close other GPU applications, and restart the browser before retrying.

Do not resize only the images while reusing camera files from the full-resolution alignment.

Training is slow or GPU utilization appears low

Check whether the application is reading files, decoding images, transferring data, compiling browser GPU code, saving recovery state, or finalizing an export. These stages may not fully occupy the GPU. Also confirm that hardware acceleration and WebGPU are available in the browser.

The result remains hazy or milky

First confirm that the run reached its final refinement stage. Then test a more appropriate pruning, opacity, densification, or quality configuration if those controls are exposed. If haze follows double edges or inconsistent geometry, repair the camera alignment instead.

Export fails

Confirm that a scene is active and complete, that sufficient disk space is available, and that the browser is permitted to save the file. Retry after closing other memory-heavy applications. Preserve the project or recovery state before restarting the browser.

Before import

• The images are already aligned.
• The selected model contains valid camera intrinsics and poses.
• The sparse point cloud belongs to the same model.
• Every registered image exists under images/.
• No image was renamed, resized, cropped, rotated, mirrored, or lens-corrected after alignment.
• cameras.bin, images.bin, and points3D.bin are under sparse/0/.
• The dataset fits the available system and GPU memory.

Before training

• Splatfiction completed Read, Inspect, Decode, and Display.
• The registered camera count is plausible.
• Camera positions and directions are correct.
• The sparse points form the expected scene.
• No disconnected or obviously invalid component is present.
• The reconstruction settings match the available hardware.

Before export

• Training reached completion.
• The scene was inspected from several viewpoints.
• Alignment defects were distinguished from Gaussian-training defects.
• The final orientation and scale are acceptable.
• An independent copy of the aligned dataset is retained.
• The export is opened once in the intended downstream viewer to verify compatibility.

• Splatfiction trains from an existing alignment; it does not replace the alignment application in this workflow.
• Output quality cannot exceed the consistency and coverage of the solved cameras and source images.
• Browser and hardware memory determine the practical scene size.
• A Gaussian scene is a view-dependent radiance representation, not a conventional mesh.
• Local browser storage is temporary project storage, not archival storage.
• Features, controls, formats, compatibility, and performance may change during the beta.

For a reproducible beta problem, send the following to support@splatfiction.com:

• operating system and version;
• browser and browser version;
• GPU model and graphics-driver version where applicable;
• Splatfiction application release shown in the interface;
• the stage that failed;
• number of registered images;
• approximate image resolution;
• camera model or models used by the alignment;
• sparse model format;
• exact error text or a screenshot; and
• whether the failure is repeatable with the same dataset.

Do not email source photographs, private project files, passwords, tokens, or confidential material unless specifically requested through an appropriate channel.

Security vulnerabilities should be reported privately with the subject Splatfiction security report and only the minimum evidence needed.

Related documents

• Splatfiction Legal & Trust
• Beta Use Conditions
• Privacy Notice
• Optional Data Contribution Terms
• Security Reporting

Splatfiction — Every point has a story.