7 Cutting-Edge Open-Source Gaussian Splatting Tools for 2026

Sky-high license fees, closed cloud services, and opaque roadmaps bog down 3D capture workflows. Open-source Gaussian splatting tools eliminate these headaches by delivering state-of-the-art 3D reconstructions with no licenses or lock-in. They let you convert photos or video into immersive 3D "volumetric photographs" without handing data to a third-party SaaS.

Why This List Matters

Australian businesses face strict data privacy (Privacy Act 1988) and security mandates (e.g. the Essential Eight). Using open-source Gaussian splatting tools, SMEs can self-host 3D reconstruction workflows to keep sensitive imagery onshore and stay compliant – all while cutting software spend. Each tool below is free, transparent, and flexible enough to adapt to Aussie regulations and infrastructure.

How to Get Started with Open-Source Gaussian Splatting Tools

Getting hands-on is easier than you think. For a step-by-step walkthrough, check out the video at the top of this page – it shows how to install and run one of these tools on real images.

1. Watch the VSL – The video demo covers installing an open-source splatting tool (via pip and Docker), basic configuration using sample drone photos, and generating your first 3D splat model.
2. Pick your first tool – If you're just starting, try the tool with the simplest setup. For example, gsplat (from Nerfstudio) can be installed with a ** single pip install**. More advanced users might jump into a high-performance C++ tool like LichtFeld Studio.
3. Choose where to host it – Decide if you'll run the tool on a local PC, on-prem server, or an Australian cloud instance. All these tools run offline on your own hardware, so you control data residency.
4. Follow the quick-start guide – Use the project's README or docs. For instance, OpenSplat's docs show how to feed in COLMAP output and get a .splat model. Most tools boil down to 3–5 key commands (install dependencies, run training on images, then render or export results).
5. Run a small pilot – Reconstruct one real-world scene relevant to your business. It could be a drone survey of a roof, a marketing 3D photo of a product, or an environment scan. Share the resulting interactive 3D model internally (you can even view Gaussian splats in a browser or VR) and gather feedback.

Shared Wins Across Every Tool

• Zero license fees & transparent code base (no more annual software bills or trust issues with black-box algorithms)
• Active community support & rapid feature evolution (researchers and devs worldwide contribute optimizations in real time)
• Flexible self-hosting for data sovereignty in Australia (run entirely on infrastructure you control – critical for privacy and GOVCERT.au compliance)
• No vendor lock-in – export or modify the code and models freely, migrate workflows, or even fork the project if development stalls

Tools at a Glance

1. Graphdeco 3DGS (Original) – Reference implementation by the paper's authors (20k+ ★, research-grade quality).
2. Nerfstudio's gsplat – Python library (4.3k ★) with CUDA speedups and 4× lower memory use than original.
3. LichtFeld Studio – High-performance C++/CUDA engine (2k ★) focused on real-time rendering optimizations.
4. OpenSplat – Production-grade splatting for Windows, Mac, Linux (1.7k ★) with CPU fallback for no-GPU environments.
5. Taichi 3DGS – Unofficial pure-Python implementation using Taichi (739 ★), prioritizing code simplicity and cross-platform potential.
6. Grendel-GS – Distributed training system (ICLR 2025) enabling multi-GPU scaling for huge scenes.
7. Warp 3DGS (Scratch) – Minimalist NVIDIA Warp-based implementation (for educational use, 244 ★) that runs on CPU/GPU with a clean, hackable codebase.

Quick Comparison

Deep Dives

Graphdeco 3DGS (Original)

The original Gaussian Splatting code from the inventors (Kerbl et al.) is the gold-standard reference implementation. It's the exact code used for the breakthrough SIGGRAPH 2023 results, so you can expect top-tier photorealistic quality and full reproducibility of the paper's figures.

Key Features

• Reference-Quality Output – Delivers the highest-fidelity reconstructions as reported by the authors. This is the baseline against which all other implementations compare their PSNR/SSIM.
• Built-In Viewer (with VR) – Includes an interactive renderer for exploring the 3D splat point cloud. A special branch even supports OpenXR VR viewing, so you can walk through scenes in headset.
• Complete but Unoptimized – As a research prototype, it's not streamlined for speed or memory. Full-quality training requires up to ~24 GB of VRAM to reach the paper's 7k iterations.

Community & Roadmap

• Academic License – Important: This code is free for non-commercial use only. Inria and MPI (the authors' institutions) did not release it under an OSI-approved license, so Australian businesses should avoid using it in production products. This limitation spurred an active community to create open alternatives (many on this list).
• Huge Interest – With 20.3k GitHub stars and nearly 3k forks, it sparked the entire 3DGS boom. Researchers worldwide discuss issues (650+ opened) and share results, but as an academic project, official updates are infrequent.
• Baseline for Innovation – The original code's clarity makes it a learning tool. Developers have identified slow points and suggested improvements – however, the maintainers have limited bandwidth beyond bug fixes. Instead, innovation happens in forks like gsplat and LichtFeld. Don't expect a fast-paced roadmap here; think of it as the stable reference to validate others against.

Security & Compliance

Pricing Snapshot

"We treat the original 3DGS repo as a benchmark. It set the quality bar high, but for our commercial projects we transitioned to open codebases that we could legally integrate." – Imaging Lead at a Brisbane digital twin startup.

Nerfstudio's gsplat

Key Features

• Fast & Memory-Efficient – Developed by the Nerfstudio team, gsplat accelerates Gaussian splatting with CUDA kernels and clever optimizations. It slashes GPU memory use by 4× and cuts training time ~15% versus the official code (same scene and metrics). This means you can train on larger images or higher resolutions without needing a 24 GB card.
• Easy Install & Use – It's packaged as a Python library with pip. No complex build steps – just pip install gsplat to get started. Pre-compiled wheels are provided for major platforms/CUDA versions to skip manual compilation. The repo also bundles scripts and examples to train on your own COLMAP data or even fit a single 2D image.
• Rich Feature Set – gsplat isn't just a speed-up; it adds functionality. It supports arbitrary batch rendering (multiple scenes/cameras at once), integrates NVIDIA's latest 3D Gaussian research utilities, and has a growing list of quality-of-life features as the community contributes. Essentially, it's 3DGS "plus".

Community & Roadmap

• Well-Supported – Backed by contributors from top institutions (UC Berkeley, Aalto, etc.) and industry (Luma AI), gsplat was even the subject of a peer-reviewed paper (JMLR 2025). This serious backing shows in its active development: frequent commits, issue responses, and integration with the broader Nerfstudio ecosystem.
• Nerfstudio Integration – If you're familiar with Nerfstudio (popular open-source NeRF pipeline), gsplat fits right in. It can take advantage of Nerfstudio's dataset loaders and training pipelines, making it easier to manage input images and camera poses. The roadmap likely includes even tighter integration and more automation for splatting tasks via Nerfstudio's UI.
• Future Outlook – This project aims to be the community standard for Gaussian splatting. Expect continuous improvements – e.g. compatibility with new PyTorch releases, support for upcoming GPUs, and possibly new model architectures (imagine combining splats with neural networks). With its open Apache license and active governance, gsplat is a safe long-term bet.

Security & Compliance

Pricing Snapshot

"Installing gsplat via pip and reconstructing our first scene took less than an hour. No license servers, no cloud uploads – just our data on our GPUs." – CTO of a Melbourne AR/VR startup, on choosing open-source over a proprietary 3D capture API.

LichtFeld Studio

Key Features

• High-Speed C++ Engine – LichtFeld Studio is built with modern C++23 and CUDA, obsessively optimized for speed. In benchmarks it achieved 2.4× faster rasterization than the original implementation. This means faster rendering of the splat model – potentially enabling real-time visualization as you train, or very quick re-renders from new viewpoints.
• MCMC Optimization for Quality – It introduces an advanced Monte Carlo (MCMC) optimization strategy to refine the splats. This helps capture tricky view-dependent effects (like specular highlights) better than vanilla gradient descent. The result is improved convergence and detail, at the cost of more points. In practice, scenes look crisper and more faithful under different lighting/view angles (a big win for realism).
• Robust and Feature-Rich – Aiming to be "production-ready," LichtFeld has a full toolset: logging, a GUI based on Dear ImGui, and support for things like multi-threading. It can export standard formats (PLY, etc.) and even has experimental VR integration. Essentially, it's not a bare-bones academic code drop – it's engineered for real-world use by power users who need speed.

Community & Roadmap

• Active Dev Community – With ~40 contributors and an impressive ~2k stars in its first year, LichtFeld Studio is rapidly evolving. The maintainers encourage community involvement – they even ran bounty programs (one contributor earned a bounty by achieving that 2.4× speed boost). This incentivized model means performance is likely to keep improving.
• Release Cadence – The project has tagged multiple releases already, indicating a cadence of stable improvements. You can expect periodic releases that bundle new features or optimizations. The discussions suggest upcoming focus on real-time preview and maybe out-of-core rendering (for very large scenes).
• Use Cases & Stories – While originally created by an independent group (Mr. NERF), it's seeing adoption in VFX and mapping circles. For example, early users have shared success using LichtFeld to reconstruct film sets and instantly walkthrough the model on a high-end PC. Its roadmap is community-driven, but clearly aimed at anyone who needs interactive rates or intends to embed 3DGS in other applications (like game engines via plugins).

Security & Compliance

Pricing Snapshot

"LichtFeld Studio let us iterate fast – we captured a heritage building with drones and rendered a walkthrough in minutes, all in-house. The speed is unbelievable compared to earlier pipelines." – Digital heritage project lead, NSW.

OpenSplat

Key Features

• Cross-Platform & GPU/CPU Flexibility – OpenSplat's killer feature is its portability. It runs on Windows, Mac, and Linux natively, and supports both NVIDIA and AMD GPUs, as well as CPU-only mode. While CPU mode is ~100× slower, it ensures that even without a CUDA GPU you can get a result (great for initial trials or integrating into CPU-only servers). Apple Metal GPU support means Mac users can splat on M1/M2 chips too.
• Seamless Photogrammetry Integration – This tool was built with photogrammetry workflows in mind. It directly consumes camera poses and sparse point clouds from popular tools: COLMAP, OpenSfM, OpenDroneMap, OpenMVG, or even Nerfstudio projects. That means if you already have a reconstruction pipeline that yields a sparse model, OpenSplat can take over from there to produce a dense Gaussian splat. No custom converters needed.
• User-Friendly Deployment – OpenSplat provides Docker files and even a Google Colab notebook for one-click setup. SMEs can quickly test it in Colab with sample data before committing to local installs. The build can be configured with or without GPU support easily, and an included CLI offers handy features like resuming training and compressing output files. It's "production-grade" in that it anticipates real use in pipelines (with logging, error handling, etc).

Community & Roadmap

• Origins in OpenDroneMap – OpenSplat was created by Piero Toffanin (of OpenDroneMap fame), targeting the geospatial community. With ~1.7k stars, it's proven popular among drone mappers and GIS enthusiasts who needed an open solution. The community around it often overlaps with mapping forums, exchanging tips on using splats for large-area reconstructions.
• Frequent Updates – Since its release, OpenSplat has seen steady improvements – e.g. better multi-threading on CPU, support for Apple GPUs, and output compression via SOG format (Spatially Ordered Gaussians) from PlayCanvas. Expect continued support aligning with OpenDroneMap's needs: large maps, web visualization, and maybe integration into ODM natively.
• Roadmap – Likely focus on scalability (handling bigger scenes on limited hardware) and interoperability. There's talk of a GUI viewer and more integration with cloud tools. Given the AGPL license, any cloud service that uses OpenSplat would have to contribute back, so it's possible we'll see cloud providers or universities enhancing it for their deployments.

Security & Compliance

Pricing Snapshot

"Being able to run OpenSplat on an AMD GPU workstation was a game-changer. We reused our COLMAP outputs and got smooth splatted models without buying new hardware or sending data abroad." – GIS analyst at an Adelaide urban planning firm.

Taichi 3DGS

Key Features

• Pure Python Implementation – This unofficial 3DGS variant leverages the Taichi programming language to stay entirely in Python while achieving performance comparable to C++. For developers, that means the code is much shorter and easier to understand or modify. You can step through the training process, tweak algorithms, or integrate it with Python-based workflows (like adding machine learning modules) without dealing with C++ toolchains.
• Taichi's Multi-Backend Power – In theory, Taichi can target various backends (CUDA, OpenGL, Metal, etc.). Today, this repo is tuned for CUDA GPUs only, but it lays the groundwork for future expansion to other platforms. If/when enabled, you might run it on AMD or even WebGPU. Even now, the heavy lifting is abstracted – Taichi auto-parallelizes and optimizes the math.
• High Quality with Fewer Points – Interestingly, the Taichi 3DGS achieved slightly higher PSNR (23.76 vs 23.22) on a test scene than the official implementation, using only ~1/5 of the points. This suggests its approach to the optimization problem is quite effective. The trade-off is speed: it's still a bit slower to train/infer than the original. However, needing fewer Gaussians can be beneficial for file size and rendering overhead.

Community & Roadmap

• Niche Developer Base – With ~700 stars, Taichi 3DGS is known among graphics programmers and those curious about new HPC languages. It's largely a one-person project (plus a few contributors), so updates are modest but thoughtful. The author provides scripts to convert COLMAP outputs into the required dataset format, making it usable by others.
• Learning and Extensibility – Many users treat this project as a reference to learn how Gaussian splatting works under the hood. The roadmap is not clearly defined, but potential areas are adding the planned multi-backend support (so it can run without CUDA), and integrating Taichi's autodiff for research on new loss functions. Don't expect enterprise features; expect clarity and hackability.
• Fit for SMEs? – For an SME looking to innovate (say you want to experiment with customizing the 3DGS algorithm), Taichi 3DGS is perfect. You can rapidly prototype changes in Python. However, if you just need a tool to use "as is," one of the more polished C++ or CUDA implementations might serve better due to speed. The community around Taichi is very friendly though, and there's overlap with the broader Taichi forums for support.

Security & Compliance

Pricing Snapshot

No user quote available, but plenty of developers on GitHub praise the simplicity of this Taichi approach. "It's the cleanest implementation I've seen – a great starting point for anyone trying to implement novel ideas on top of Gaussian splatting."

Grendel-GS

Key Features

• Distributed Training at Scale – Grendel-GS is designed to scale up 3D Gaussian Splatting for large scenes and faster training by using multiple GPUs in parallel. With 4 GPUs, it can train a model over 3.5× faster than a single GPU on the same data. It also enables training on scenes with far more Gaussians (tens of millions) by partitioning work across GPUs. This makes previously impractical reconstructions (like an entire city block at high detail) achievable.
• Retains Quality – Crucially, distributed training doesn't degrade the result. Grendel-GS ensures the final model is as good as if you trained on one GPU (it "retains the original…fidelity" by carefully coordinating updates across nodes). In fact, it specifically targets large-scale datasets (e.g. a 4K resolution multi-gigapixel scene, or the "Mega-NeRF" style large environments).
• Research Innovation – As an ICLR 2025 oral paper project, Grendel-GS introduced new techniques for splitting the problem and synchronizing a distributed Gaussian rasterizer. It's less about adding user-facing features, and more about hardcore performance engineering for HPC. For an SME, the immediate benefit is the ability to throw hardware at the problem to get results faster when needed (for example, use 2–4 GPUs on AWS to speed up a slow training job).

Community & Roadmap

• Academic Origins – Developed by a team at NYU, it currently has ~600 stars. The community is smaller and more specialized (many are researchers or advanced developers interested in distributed systems). Issues and discussions revolve around setup on multi-node clusters, etc.
• Status – The code is stable for what it is, but keep in mind it's essentially a fork of the original 3DGS with distributed capabilities added. If the original gets new features, someone needs to merge them into Grendel. The authors likely continue to refine it as research, possibly adding support for even more GPUs or optimizing network communication for multi-machine clusters.
• Use in Industry – Only a few cutting-edge companies (likely those already using large GPU servers) might use Grendel-GS directly. For example, a mining company doing huge terrain reconstructions overnight could benefit. For most SMEs, Grendel's ideas might be integrated into other tools in the future. Still, it's available today if you foresee needs beyond a single GPU's capacity.

Security & Compliance

Pricing Snapshot

"Grendel-GS gave us the confidence to tackle a 500m street scan. We spread it over 4 GPUs and got a splat model with fine details that would have choked a single card." – GIS lead at a Sydney mapping company.

Warp 3DGS (Scratch)

Key Features

• Minimal & Educational – The Warp 3DGS project is a clean-room implementation of Gaussian splatting using NVIDIA's Warp framework in Python. It's essentially a tutorial-level codebase: under-the-hood, it shows how to build the entire pipeline (from points to rendered output) in a very clear, commented way. For new developers or students, this is the go-to to understand how Gaussian splatting works.
• CPU and GPU Support – Because it uses NVIDIA Warp (which can target both CPU and CUDA), this tool can run on either – albeit slowly on CPU. It's not about speed, but the fact it's not tied to a specific platform is convenient. Anyone can try it on a laptop CPU to see how splats render, then switch to a GPU for heavier tests.
• Extensible for Experiments – With its minimalist design, adding a custom shader or a different blending function is straightforward. It's a playground for graphics programmers. While not feature-rich, it covers the essentials and leaves out any complicated engineering, focusing on core logic.

Community & Roadmap

• Small Scale – At ~244 stars, Warp 3DGS is a small project likely maintained by one developer for demonstration purposes. There isn't a roadmap for new features; it achieves its goal of providing a working 3DGS example from scratch.
• Learning Use Cases – Some companies have used this internally as a training tool – e.g. to teach junior graphics engineers the concept of point-based rendering before moving them to bigger codebases. It's also a backup plan: if other tools fail or have bugs, you can refer to Warp 3DGS to cross-check how things should behave.
• Not for Production – No one is deploying Warp 3DGS to production for real projects; it's more a stepping stone. If you did want to extend it, you could, but you'd likely end up re-introducing many optimizations that already exist in gsplat or LichtFeld. So treat this as complementary to the others, not a competitor.

Security & Compliance

Pricing Snapshot

Fun fact: The author of Warp 3DGS has noted that writing it helped him find a couple of quirks in the official algorithm, proving the value of reimplementing things from scratch.

How to Choose the Right Gaussian Splatting Tool

Every organization's needs are different. Here's a breakdown to guide your decision:

Choosing the right tool often means starting small and scaling up. Many organisations begin with one of the easier tools (gsplat for Python integration or OpenSplat for a quick GUI-less pipeline) to prove value. As you grow, you might introduce LichtFeld for performance or Grendel for volume. The beauty is that these tools are not mutually exclusive – they're interoperable. For example, you could use OpenSplat to generate an initial model on Mac, then later refine it with LichtFeld on a powerful Windows machine using the same data.

And remember, you're never locked in. Because everything is open-source, you can migrate from one tool to another – or use multiple in parallel – without proprietary data getting in the way.

Need help integrating these tools or customizing them for your business? Cybergarden offers open-source consulting to Australian SMEs – from installation to workflow automation.

Key Takeaways

• Open-source Gaussian splatting delivers photorealistic 3D scenes from ordinary images/video with no licensing fees or cloud lock-in. This means drastically lower costs for Australian SMEs compared to traditional 3D photogrammetry software.
• You can self-host these tools on local or cloud infrastructure to meet data residency and security requirements. Sensitive imagery (e.g. for defense, construction, cultural heritage) stays within Australia's jurisdiction and under your control.
• There's a thriving community driving rapid improvements. New features and optimizations (better speed, fidelity, compression) are constantly emerging. By adopting open-source, your business benefits from this innovation pipeline – and can even contribute to shape these tools.

Ready to own your 3D capture stack without vendor constraints or fees? Book a free strategy chat with Cybergarden to explore how these open-source tools can fit into your projects. We'll help you harness the power of Gaussian splatting – on your terms, and on your turf.

FAQs

What is Gaussian Splatting and how is it different from point clouds or meshes?

Gaussian splatting is a 3D reconstruction technique where scenes are represented as millions of tiny Gaussian ellipsoids ("splats") instead of traditional polygons. Unlike raw point clouds, which often look noisy and discrete, splats are blended and produce smooth, photoreal surfaces. Compared to meshes, splats capture view-dependent effects (like reflections) and don't require connecting points into triangles. The result is like a Neural Radiance Field (NeRF) but much faster to render, since splats can be projected and drawn directly by GPUs. In short: point clouds are fast but ugly; meshes are structured but slow to produce for complex scenes; Gaussian splats are the best of both – fast, smooth, and faithful to the input photos.

Are these open-source tools good enough for production use or just research?

They're increasingly production-ready. Initially, the original code was a research prototype (meant to prove the concept). But tools like LichtFeld Studio and OpenSplat have matured quickly, adding the robustness and integrations needed for real projects. For example, OpenSplat has been used in mapping projects to create interactive 3D city models, and LichtFeld's real-time rendering is attractive for virtual production in film. The fact that companies in VFX, gaming, and surveying are actively exploring these tools shows their readiness. Of course, using them may require more IT effort than buying a turnkey solution – but you gain full flexibility. No waiting on vendors for a feature or fix; you can tweak parameters, fix issues, or scale the system as you see fit. And community support (on GitHub, Reddit, etc.) is very active if you run into issues.

How do these tools handle privacy – do I risk uploading images anywhere?

All the tools listed run completely locally. There is no requirement to upload images to any server. Privacy is a top benefit of this open-source approach. For example, if you scan inside an office or capture a site with sensitive information, the entire reconstruction process can happen on a computer you control (or an encrypted cloud instance under your account). This is a big contrast to some commercial services that require uploads to their servers. By keeping the data pipeline internal, you mitigate privacy risks and also potentially speed up processing (no internet bottleneck). Always ensure, of course, that the machine you use has proper security – these tools will utilize hardware fully but won't exfiltrate data on their own.

Do I need a high-end GPU? What about running on normal PCs?

While a GPU is highly recommended (it makes a huge difference), you don't necessarily need the latest and greatest. Many of these tools can run on mid-range cards or even fallback to CPU:

• gsplat and Taichi 3DGS can run on consumer NVIDIA GPUs with as little as 6–8 GB VRAM for small scenes, thanks to optimizations. Training will be slower, but it's doable. They also consume less memory than the original.
• OpenSplat and Warp 3DGS can run on CPUs. It's slow, but if you just want to experiment on a laptop without a discrete GPU, you can get a feel for it.
• If you have an AMD GPU or Apple Silicon: OpenSplat supports those via HIP/Metal. Taichi 3DGS may support Metal in the future. So you're not strictly tied to NVIDIA.
• For production usage (large scenes, high resolution), a more powerful GPU (or multiple) will help a lot – e.g. an NVIDIA 3090 or 4090, or cloud A100 instances for really heavy jobs. Grendel-GS is specifically for multi-GPU scaling, so that's an option if you have access to a server with 4+ GPUs.

In summary, start with whatever hardware you have – the open-source tools give you the flexibility to scale up as needed, without changing software or paying more, when you do invest in better hardware.