Gaussian-splat compression and deployment

3DGS Compression & Deployment

End-to-end pipeline from raw 3DGS model to deployed application. Covers 6 compression categories + 4 deployment targets + hardware acceleration.

Capabilities

• Analyze 3DGS model attributes (position, SH, opacity, scale, rotation) and recommend compression strategy
• Select quantization method and bit-width per attribute (scalar, VQ, mixed-precision)
• Design pruning pipeline (coreset, adaptive, variational, merge-based)
• Plan VQ codebook architecture and residual coding
• Architect progressive streaming and LoD systems (static and 4D dynamic)
• Guide platform-specific deployment (WebGL, WebGPU, iOS/Android, desktop)
• Evaluate hardware acceleration paths (Tensor Core, GEMM, FPGA, ASIC)
• Estimate compression ratio, quality loss, and rendering speed for each method combination

Compression Pipeline

Raw 3DGS Model
    │
    ▼
[Step 1] Analysis ── attribute profiling, bottleneck identification
    │
    ▼
[Step 2] Strategy Selection ── target platform → compression recipe
    │
    ▼
[Step 3] Pruning ── reduce Gaussian count (coreset / adaptive / variational / merge)
    │
    ▼
[Step 4] Quantization ── reduce per-attribute bit-width (scalar / VQ / mixed-precision)
    │
    ▼
[Step 5] Vector Quantization ── codebook-based attribute compression (optional, replaces/augments Step 4)
    │
    ▼
[Step 6] Streaming & LoD ── progressive loading structure for network delivery
    │
    ▼
[Step 7] Deployment ── platform-specific renderer and runtime
    │
    ▼
Deployed Application (Web / Mobile / Desktop / Edge)

Step 1: Analysis

Profile the 3DGS model before selecting compression methods:

Profiling checklist:

1. Total Gaussian count N and file size S
2. Target platform constraints (memory budget, bandwidth, GPU capability)
3. Quality floor (minimum acceptable PSNR/SSIM)
4. Required FPS threshold
5. Whether dynamic (4DGS) or static scene

Step 2: Compression Strategy Selection

Decision tree by target platform:

Target Platform?
├── Web (WebGL/WebGPU)
│   ├── Bandwidth-limited → Pruning + VQ + Streaming (CAGS/HGS pipeline)
│   └── Compute-limited → Aggressive pruning + low SH degree + Flux-GS
├── Mobile (iOS/Android)
│   ├── Real-time required → Mobile-GS pipeline (depth-aware OIT + distillation + pruning)
│   └── Quality priority → MesonGS++ (mixed-precision, budget-controlled) + NanoGS merge
├── Desktop (GPU ≥ RTX 3060)
│   ├── Max quality → Light quantization only (8-10 bit, ContextGS entropy coding)
│   └── Large scene → Pruning + Streaming + HiGS hierarchical tiles
└── Edge / Embedded
    ├── FPGA targeted → SpqGS (hardware-friendly quantization) + Axis-Shared Accelerator
    └── Low-power GPU → VEDAL pruning + 4-6 bit quantization + PocketGS on-device

Combined target table:

Step 3: Quantization

Method Selection

Bit-width Selection Guide

Rule of thumb: Position and SH dominate quality; allocate more bits there. Opacity and rotation tolerate aggressive quantization.

Step 4: Pruning

Strategies

Pruning Decision Flow

Need theoretical guarantees?
├── Yes → Provable Pruning via Coresets
└── No
    ├── Training-free requirement?
    │   ├── Yes → NanoGS (merge) or LightGaussian (post-training)
    │   └── No
    │       ├── Can retrain/fine-tune after pruning?
    │       │   ├── Yes → Prune Wisely (DoG) + finetune, or VEDAL
    │       │   └── No → NanoGS or GETA-3DGS (auto, no per-scene thresholds)
    │       └── Need continuous quality levels?
    │           └── Yes → MGS (Matryoshka stochastic budget training)

Step 5: Vector Quantization

VQ Pipeline

Gaussian Attributes
    │
    ▼
[1] Attribute Grouping ── group by type (position, SH, scale/rotation)
    │
    ▼
[2] Codebook Learning ── K-means / learned / residual codebook
    │
    ▼
[3] Assignment ── nearest-neighbor lookup per group
    │
    ▼
[4] Residual Coding ── (optional) multi-level residual VQ
    │
    ▼
[5] Entropy Coding ── arithmetic / ANS coding of indices
    │
    ▼
Compressed Bitstream

VQ Methods

Codebook Design Rules

1. Codebook size K: 256 (8-bit index) is standard; 1024 (10-bit) for quality; 64 (6-bit) for extreme compression
2. Grouping strategy: Group by attribute type (position separate from SH); within SH, separate DC from higher-order
3. Residual levels: 1 level = 10–20x; 2 levels = 20–50x; 3 levels = diminishing returns
4. LoD integration: Each residual level can serve as a LoD tier (see Step 6)

Step 6: Streaming & LoD

Static Scene Streaming

Dynamic (4DGS) Streaming

Streaming Architecture Pattern

Server                                          Client
┌──────────┐    HTTP/HLS/DASH    ┌──────────────────┐
│ 3DGS     │ ──── Layer 0 ────→ │ Base quality      │
│ Encoder  │ ──── Layer 1 ────→ │ + Deformation     │
│          │ ──── Layer 2 ────→ │ + Refinement      │
│ CAGS/    │                    │                   │
│ PD-4DGS  │ ←── Bandwidth ──── │ Quality Feedback  │
└──────────┘                    └──────────────────┘

Step 7: Deployment

Web (WebGL / WebGPU)

Web deployment checklist:

1. Choose WebGPU (Chrome 113+) for compute shader support; fallback WebGL 2.0 for compatibility
2. Chunk Gaussians into 50K–200K groups for progressive loading
3. Use INT8/FP16 textures for quantized attributes
4. Implement front-to-back alpha compositing in fragment shader (WebGL) or compute shader (WebGPU)
5. Target 30+ FPS at 1080p for interactive experience

Mobile (iOS / Android)

Mobile deployment pipeline:

1. Train on server → compress (prune + quantize + merge via NanoGS)
2. Export to mobile-optimized format (INT8 attributes, fused SH degree ≤ 2)
3. Use Metal (iOS) / Vulkan (Android) for GPU rasterization
4. Apply Mobile-GS depth-aware OIT for correct blending on tile-based GPUs
5. Memory budget: stay under 500MB for iOS, 300MB for Android

Desktop

• gsplat (UC Berkeley/NVIDIA): Production-grade CUDA rasterization, 4x VRAM savings
• HiGS (NVIDIA): Hierarchical tiling for 15.8x speedup, exact front-to-back compositing
• GEMM-GS: Tensor Core-compatible blending for 1.42x speedup

Hardware Acceleration

Acceleration Selection

Deployment hardware?
├── NVIDIA GPU (RTX 30xx+)
│   ├── Tensor Core available → GEMM-GS or TensorGS
│   └── Standard CUDA → HiGS + gsplat
├── Custom ASIC / SoC design
│   └── Axis-Shared Rasterization Accelerator (ISCA 2026)
├── FPGA
│   └── SpqGS (hardware-friendly quant) + custom rasterizer
├── Mobile GPU (Mali/Adreno/Apple)
│   └── Mobile-GS depth-aware OIT + Flux-GS Monte Carlo
└── VR/AR HMD (stereoscopic)
    └── StereoGS (dual-eye shared compute + memory bandwidth)

Methods Quick Reference

Output Format

When this skill produces a compression-deployment plan, use this template:

# 3DGS Compression & Deployment Plan

## Model Profile
- Gaussian count: N
- File size: S MB
- Scene type: static / dynamic (4DGS)
- Key bottleneck: [storage / bandwidth / compute / memory]

## Target Platform
- Platform: [Web / Mobile / Desktop / Edge]
- Constraints: [memory budget, bandwidth, GPU]

## Compression Recipe
1. Pruning: [method] → target: X% reduction
2. Quantization: [method] → [bit-width per attribute]
3. VQ: [method, codebook size] → (if applicable)
4. Entropy coding: [method]

## Expected Results
- Compression ratio: Xx
- Estimated PSNR: Y dB (drop: Δ dB)
- Estimated file size: Z MB
- Rendering speed: W FPS on target

## Streaming Architecture (if applicable)
- Layers: [base / deformation / refinement]
- First-frame latency: < T seconds

## Deployment Stack
- Renderer: [gsplat / Spark 2.0 / Mobile-GS / custom]
- Acceleration: [Tensor Core / HiGS / FPGA / none]
- Format: [PLY compressed / chunk stream / custom binary]

Rules

1. Always profile before compressing: attribute distribution dictates bit-width allocation, not a fixed recipe
2. Pruning before quantization: reducing Gaussian count first lowers total data; then quantize the remaining attributes
3. VQ replaces or augments scalar quantization: do not apply both independently to the same attribute group
4. Streaming requires LoD structure: flat compression without LoD degrades user experience on slow connections
5. Mobile deployment needs Metal/Vulkan: CUDA is not available on mobile; plan the rasterization backend from Step 2
6. Quantization-aware finetuning recovers quality: always finetune 1–5k iterations after aggressive (≤6 bit) quantization
7. Entropy coding is the last step: apply after all other compression; HAC/ContextGS/GaussianCodec specialize in this
8. Cross-reference with knowledge base: load references/compression-methods.md for full method details before making recommendations

Red Lines

• No invented metrics: Never fabricate compression ratios, PSNR values, or FPS numbers. If a value is not in the knowledge base, state "data not available"
• No hallucinated methods: Only reference methods explicitly present in references/compression-methods.md or provided by the user
• No speculative hardware claims: Do not claim FPGA/ASIC performance numbers without source data
• No silent speculation: Flag uncertain details with [UNCERTAIN] rather than presenting as fact
• No method misattribution: Do not assign compression ratios from one method to another

Related Skills

• 3dgs-engineering-guide — Production deployment decisions, industry verticals, tech stack
• 3dgs-method-compare — Compare compression methods head-to-head on benchmarks
• 3dgs-visualizer — Generate radar charts comparing compression methods
• 3dgs-experiment-planner — Design ablation studies for compression pipelines
• cad-mesh-3dgs — Mesh extraction from compressed 3DGS for BIM/CAD workflows
• 3dgs-mcp-renderer — MCP protocol for compressed 3DGS rendering integration

Guardrail: Do Not Apply From Memory

Do NOT try to apply the method data, compression ratios, technical details, or deployment recommendations described in this skill from memory. Always read the SKILL.md and references/compression-methods.md from disk before producing any output. The knowledge base is updated frequently; stale memory may produce outdated, inaccurate, or fabricated results.

If you cannot find a method, metric, or data point in the loaded files, say so explicitly. Never invent compression ratios, venue acceptances, performance numbers, or technical features not present in the source data.

If you like it, please star this repo https://github.com/jaccen/Awesome-Gaussian-Skills