OpenGS

KO | EN

gitlite — search

#bash #redis #ruby #ai-agents #ui #chatgpt #html #awesome #mcp #go

(★ 9)

No description available.

File Explorer

ZIP Download

- - d_GaussianContext.png
  - d_GaussianContext.png.meta
  - [email protected]
  - [email protected]
  - GaussianContext.png
  - GaussianContext.png.meta
  - [email protected]
  - [email protected]
- - CaptureScreenshot.cs
  - CaptureScreenshot.cs.meta
  - FilePickerControl.cs
  - FilePickerControl.cs.meta
  - KMeansClustering.cs
  - KMeansClustering.cs.meta
  - PLYFileReader.cs
  - PLYFileReader.cs.meta
  - RenderTextureDebug.cs
  - RenderTextureDebug.cs.meta
  - TinyJsonParser.cs
  - TinyJsonParser.cs.meta
- GaussianMoveTool.cs
- GaussianMoveTool.cs.meta
- GaussianSplatAssetCreator.cs
- GaussianSplatAssetCreator.cs.meta
- GaussianSplatAssetEditor.cs
- GaussianSplatAssetEditor.cs.meta
- GaussianSplatRendererEditor.cs
- GaussianSplatRendererEditor.cs.meta
- GaussianSplattingEditor.asmdef
- GaussianSplattingEditor.asmdef.meta
- GaussianSplatValidator.cs
- GaussianSplatValidator.cs.meta
- GaussianTool.cs
- GaussianTool.cs.meta
- GaussianToolContext.cs
- GaussianToolContext.cs.meta
- Icons.meta
- Utils.meta
- BlackSkybox.mat
- BlackSkybox.mat.meta
- - GPUPrefixScan.cs
  - GPUPrefixScan.cs.meta
  - GPURadixSort.cs
  - GPURadixSort.cs.meta
- - Layouts.meta
- - GaussianFileReader.cs
  - GaussianFileReader.cs.meta
  - PLYFileReader.cs
  - PLYFileReader.cs.meta
  - RenderTextureDebugger.cs
  - RenderTextureDebugger.cs.meta
- Assets.meta
- GaussianCutout.cs
- GaussianCutout.cs.meta
- GaussianSplatAsset.cs
- GaussianSplatAsset.cs.meta
- GaussianSplatAssetBuilder.cs
- GaussianSplatAssetBuilder.cs.meta
- GaussianSplatAssetSerializer.cs
- GaussianSplatAssetSerializer.cs.meta
- GaussianSplatHDRPPass.cs
- GaussianSplatHDRPPass.cs.meta
- GaussianSplatRenderer.cs
- GaussianSplatRenderer.cs.meta
- GaussianSplatting.asmdef
- GaussianSplatting.asmdef.meta
- GaussianSplattingResources.cs
- GaussianSplattingResources.cs.meta
- GaussianSplatURPFeature.cs
- GaussianSplatURPFeature.cs.meta
- GaussianUtils.cs
- GaussianUtils.cs.meta
- GPUSort.meta
- GpuSorting.cs
- GpuSorting.cs.meta
- Logs.meta
- Packages.meta
- ProjectSettings.meta
- UserSettings.meta
- Utils.meta
- - GPUPrefixScan.compute
  - GPUPrefixScan.compute.meta
  - GPUPrefixScan.hlsl
  - GPUPrefixScan.hlsl.meta
  - GPURadixSort.compute
  - GPURadixSort.compute.meta
  - GPURadixSort.hlsl
  - GPURadixSort.hlsl.meta
- BlackSkybox.shader
- BlackSkybox.shader.meta
- DepthGradient.shader
- DepthGradient.shader.meta
- DeviceRadixSort.hlsl
- DeviceRadixSort.hlsl.meta
- GaussianComposite.shader
- GaussianComposite.shader.meta
- GaussianDebugRenderBoxes.shader
- GaussianDebugRenderBoxes.shader.meta
- GaussianDebugRenderPoints.shader
- GaussianDebugRenderPoints.shader.meta
- GaussianSplatting.hlsl
- GaussianSplatting.hlsl.meta
- GPUSort.meta
- RenderGaussianSplats.shader
- RenderGaussianSplats.shader.meta
- RenderGaussianSplatsSortFree.shader
- RenderGaussianSplatsSortFree.shader.meta
- ShadowComposite.shader
- ShadowComposite.shader.meta
- SortCommon.hlsl
- SortCommon.hlsl.meta
- SphericalHarmonics.hlsl
- SphericalHarmonics.hlsl.meta
- SplatUtilities.compute
- SplatUtilities.compute.meta
- demo1.gif
- introduction.gif
.gitignore
Editor.meta
LICENSE
Materials.meta
package.json
package.json.meta
README.md
Runtime.meta
Shaders.meta
Third Party Notices.md
Third Party Notices.md.meta

# Use via CDN

jsDelivr

jsDelivr serves any public GitHub repository as a CDN with zero setup. Pick a version and a file to get a ready-to-paste link and snippet.

Version

File

Link

Example

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://raw.githubusercontent.com/MeTownInc/OpenGS/main/LICENSE.md) &nbsp;
[![Page](https://img.shields.io/badge/Project_Page-blue?logo=github)](https://metowninc.github.io/evova-unity-docs/index.html) &nbsp;
[![Third Party Notices](https://img.shields.io/badge/Third_Party_Notice-yellow.svg)](https://raw.githubusercontent.com/MeTownInc/OpenGS/main/Third%20Party%20Notices.md)

### Special Thanks

We express sincere gratitude to Aras Pranckevičius, the original author of UnityGaussianSplatting, whose work provided the foundation for this project.
The original proejct UnityGaussianSplatting made it possible for us to explore and extend Gaussian Splatting in Unity.
Adapting and extending the renderer for Sort-Free Gaussian Splatting and mobile-oriented workflows are based on the original work, UnityGaussianSplatting, by Aras Pranckevičius.

## 1. Overview

OpenGS is a Unity Package Manager (UPM) package for importing and rendering 3D Gaussian Splatting data. It converts standard and Sort-Free Gaussian Splat PLY files into Unity assets and renders them in the scene through a URP renderer feature.

OpenGS targets **Unity 6 and the Universal Render Pipeline (URP)**. Profile large scenes and mobile builds on the actual target device.

![Video Placeholder](https://raw.githubusercontent.com/MeTownInc/OpenGS/main/Video/introduction.gif)

![Video Placeholder](https://raw.githubusercontent.com/MeTownInc/OpenGS/main/Video/demo1.gif)

For more information, visit [EVOVA Unity Docs](https://metowninc.github.io/evova-unity-docs)

## 2. Features

- Import standard 3D Gaussian Splatting PLY files.
- Import Sort-Free GS PLY files containing `f_do_0` and `f_ro_0` through `f_ro_14`.
- Render standard data using GPU radix sorting for depth ordering.
- Render compatible Sort-Free data without per-frame depth sorting.
- Adjust color spherical-harmonics order, splat scale, and opacity.
- Convert source data with selectable quality and compression presets.
- Select, move, transform, cut out, and export standard splat data with editor tools.
- Use original color, translucent, depth, normal, shadow, and relighting composite modes.

## 3. Requirements

| Item | Requirement |
| --- | --- |
| Unity | Unity 6.0.0f1 or later (package target: `6000.0.68f1`) |
| Render pipeline | Universal Render Pipeline (URP) |
| GPU | Compute Shader support |
| Package dependencies | Burst 1.8.8, Collections 2.1.4, Mathematics 1.2.6 |

Installing URP automatically applies the `GS_ENABLE_URP` compilation define used by this package.

## 4. Platform Compatibility

OpenGS requires a graphics device and API combination that supports the Compute Shaders used by the renderer and GPU sorting path. URP is the primary supported render pipeline.

| Platform | Status | Notes |
| --- | --- | --- |
| Windows / macOS / Linux Editor | Supported for development | Verify the selected graphics API and GPU support. |
| Desktop standalone | Supported in principle | Validate shader compilation, memory use, and performance per target API. |
| Android | Supported in principle | Compute Shader support and performance validation are required per device. The Sort-Free path does not support OpenGL ES and may require Vulkan. |
| iOS / iPadOS | Supported in principle | Validate on the target Metal device before release. |
| WebGL | Not supported | The required Compute Shader path is unavailable. |

“Supported in principle” means the package does not intentionally exclude the platform; it is not a guarantee for every GPU, driver, graphics API, or device.

We have tested that OpenGS works properly on following devices:
| Platform | Device |
| --- | --- |
| Android | Galaxy S23 |
| Android | Galaxy S23+ |
| Android | Galaxy Tab S9 |
| Android | Galaxy S24 Ultra |
| iOS | iPhone 16 Pro |
| iOS | iPhone 17 Air |
| iOS | iPhone 12 Mini |

## 5. Installation

### Add from a Git URL

In Unity, open **Window > Package Manager > + > Add package from git URL...**, then enter:

```
https://github.com/MeTownInc/OpenGS.git
```

### Add as a local package

If you have cloned the repository, choose **Add package from disk...** and select this folder's [`package.json`](package.json).

Unity Package Manager installs the declared Burst, Collections, and Mathematics dependencies automatically.

## 6. Quick Start

1. Configure the project to use URP.
2. In the URP Renderer Data asset, add `GaussianSplatURPFeature` under **Renderer Features**.
3. Open **Tools > Gaussian Splats > Create GaussianSplatAsset**.
4. Select an input PLY file, an output folder, and a quality preset, then click **Create Asset**.
5. Create an empty GameObject and add `GaussianSplatRenderer`.
6. Assign the generated `GaussianSplatAsset` to the component's **Asset** field.
7. View the result through a Game camera.

If shader or Compute Shader references are missing on `GaussianSplatRenderer`, assign the corresponding package resources in the Inspector's **Resources** section.

## 7. Importing Gaussian Splat Data

Input must be in `binary_little_endian` PLY format. A standard Gaussian Splat PLY requires at least the following properties:

```
x y z
f_dc_0 f_dc_1 f_dc_2
opacity
scale_0 scale_1 scale_2
rot_0 rot_1 rot_2 rot_3
```

Color spherical harmonics data is recognized from degree 0 through degree 3. The importer accepts only complete residual-SH property sets: 0, 9, 24, or 45 `f_rest_*` properties.

Conversion presets balance asset size against visual quality. Start with **Medium**, then adjust the setting for the scene and target hardware. When camera information is included in the input, enable **Import Cameras** to import it.

## 8. Creating Gaussian Splat PLY Files

OpenGS imports pre-trained Gaussian Splat PLY files; it does not train Gaussian Splatting models. To create a PLY file yourself, use an open-source training pipeline such as [gsplat](https://github.com/nerfstudio-project/gsplat). Follow the project's documentation to set up the training environment, train a model from your image data, and export a compatible PLY file.

Alternatively, [EVOVA](https://app.evova.ai/) provides a managed service for generating PLY files from uploaded data.

Training software, trained models, source imagery, and generated assets may be governed by licenses that differ from OpenGS. Review the applicable terms before using them, especially in commercial projects.

## 9. Using the Unity Renderer

`GaussianSplatRenderer` is the scene component that displays a `GaussianSplatAsset`.

- **Splat Scale / Opacity Scale** adjust splat size and opacity.
- **SH Order** selects the color spherical harmonics order (0–3). Lower values can reduce rendering cost.
- **Sort Nth Frame** sets the sort interval for standard assets. Larger values reduce sorting work but can reduce transparency quality during camera movement.
- **Render Mode** provides normal rendering plus point, point-index, box, and chunk-bound debug views.

`GaussianSplatURPFeature` exposes the composite mode and Depth Bias. Depth, normal, shadow, and relighting output depend on the scene's lighting and depth configuration.

## 10. Sort-Free Rendering

Sort-Free Gaussian Splatting (Sort-Free GS) is a rendering approach introduced in [Hou et al., *Sort-Free Gaussian Splatting via Weighted Sum Rendering*](https://arxiv.org/abs/2410.18931). It replaces the view-dependent depth sorting used by standard 3D Gaussian Splatting with weighted-sum compositing. By avoiding sorting, it can reduce rendering overhead, particularly on resource-constrained devices. The [sort-free-gs repository](https://github.com/LiYukeee/sort-free-gs), a separate implementation, provides training code for producing Sort-Free GS data.

The linked repository is governed by its own [Gaussian-Splatting License](https://github.com/LiYukeee/sort-free-gs/blob/main/LICENSE.md). OpenGS only links to that repository and does not include its source code; review its license before using its code, trained models, or other assets.

Sort-Free GS files are detected when the source contains the complete `f_do_0` and `f_ro_0`–`f_ro_14` property set. The optional per-splat `info` field supplies Sort-Free rendering parameters: the first splat's value is used as the background weight, and the second splat's value is used as sigma. Their opacity-SH data is converted with the asset and used by the Sort-Free rendering path.

This avoids the standard per-frame depth-sorting path, but it has trade-offs. In particular, bright backgrounds can appear through dark objects from some viewpoints. This is a transparency/compositing artifact of the current Sort-Free approach.

Editor editing operations are not supported for Sort-Free assets because the current editing path does not update Sort-Free opacity-SH data. As a result, cutouts, copying, and merging are also unavailable for Sort-Free assets.

## 11. Mobile / Android Setup

1. Set **Build Settings** to Android and configure URP for the target quality tier.
2. Confirm that the target device and selected graphics API support Compute Shaders. The Android Sort-Free path does not support OpenGL ES; enable Vulkan in **Player Settings > Other Settings > Graphics APIs** when using Sort-Free assets.
3. Start with a low or medium conversion-quality preset and a lower **SH Order**.
4. Test with the target resolution, scene lighting, and camera movement.
5. Profile GPU frame time and memory use on physical devices before increasing asset quality or splat count.

Use Android hardware as the source of truth: driver behavior, GPU memory, thermal limits, and Compute Shader performance vary significantly by device.

## 12. Performance

Rendering cost and memory usage increase with splat count, output resolution, and the portion of the screen covered by splats.

- Use the lowest conversion-quality preset that satisfies the visual target.
- Reduce **SH Order** when full directional color detail is unnecessary.
- For standard assets, increase **Sort Nth Frame** to trade some motion quality for lower sorting cost.
- Split and profile large datasets. A single asset supports up to 8,600,000 splats.
- Profile builds on the intended device; Editor performance is not representative of a mobile build.

## 13. Known Issues / Limitations

- Sort-Free rendering can show bright backgrounds through dark objects in some views.
- Editor editing operations are not supported for Sort-Free assets because the current editing path does not update Sort-Free opacity-SH data. Cutouts, copying, and merging are also unavailable.
- Copy/merge operations and some transform tools for standard assets require unchunked data, such as the **Very High** quality preset.
- Input files with unsupported headers or properties cannot be imported.
- PLY files that are 2 GB or larger cannot be imported.
- Compute Shader compatibility and rendering performance vary by target device, graphics API, and driver. Android Sort-Free rendering may require Vulkan because that path does not support OpenGL ES.

## 14. How It Works

1. The editor reads a `binary_little_endian` Gaussian Splat PLY file and validates its properties.
2. The importer converts the PLY data into a `GaussianSplatAsset` and companion binary data assets. The selected quality preset controls the stored data formats and compression.
3. `GaussianSplatRenderer` uploads the asset data to GPU buffers and textures.
4. `GaussianSplatURPFeature` gathers active renderers for each camera and submits the rendering passes in URP.
5. Standard assets use GPU radix sorting to approximate correct alpha compositing. Compatible Sort-Free assets use their opacity-SH data instead.

## 15. Project Structure

| Path | Contents |
| --- | --- |
| `Runtime/` | Runtime renderer, assets, asset serialization, and GPU sorting code |
| `Runtime/Utils/` | PLY reader and runtime utilities |
| `Runtime/GPUSort/` | GPU radix-sort and prefix-scan C# code |
| `Editor/` | PLY conversion, custom Inspector, selection, and editing tools |
| `Shaders/` | Gaussian Splat, composition, and GPU sorting shaders |
| `Materials/` | Default materials |

## 16. Roadmap

The following are potential areas for future development, not committed release promises:

- Sort-Free opacity-SH editing, cutouts, copying, and merging.
- Broader platform/device validation and compatibility guidance.
- Further mobile memory and rendering optimizations.
- Additional import, diagnostics, and authoring workflows.

## 17. Credits / Acknowledgements

- Original Unity Gaussian Splatting work: Aras Pranckevičius.
- OpenGS package maintenance and modifications: MeTown Inc.
- GPU radix-sort and prefix-scan components are vendored and adapted from [GPUBufferOperators for Unity](https://github.com/abecombe/GPUBufferOperators-for-Unity) by abecombe.
- 3D Gaussian Splatting research and the broader community that developed the data formats and workflows used by this package.

See [Third Party Notices](Third%20Party%20Notices.md) for third-party license details.

## 18. License

OpenGS is available under the [MIT License](LICENSE.md).

The GPUBufferOperators-derived components are licensed under Apache-2.0. Their notices and license text are included in [Third Party Notices](Third%20Party%20Notices.md).

Official __*training*__ software for the Gaussian Splats is for educational / academic / non-commercial purpose; commercial usage requires getting license from INRIA. That is: This viewer / renderer / integration into Unity is just "MIT license", you need to separately consider __*how*__ did you get your Gaussian Splat PLY files.

## 19. References

- Kerbl et al., [3D Gaussian Splatting for Real-Time Radiance Field Rendering](https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/), 2023.
- [3D Gaussian Splatting reference implementation](https://github.com/graphdeco-inria/gaussian-splatting).
- Hou et al., [Sort-Free Gaussian Splatting via Weighted Sum Rendering](https://arxiv.org/abs/2410.18931), ICLR 2025.
- [Unity Universal Render Pipeline documentation](https://docs.unity3d.com/Manual/urp/urp-introduction.html).

OpenGS

File Explorer

# Use via CDN

Was this content helpful?

Recent Feedback

Download README