v1.1.1 to v1.1.1

428 added, 428 removed. Audit A to A.

- ---

- name: 3dgs-compression-deploy

- description: "3DGS compression-to-deployment pipeline: quantization (scalar/VQ/mixed-precision), pruning (coreset/adaptive/variational/merge/Bayesian), progressive streaming & LoD, Web/WebGPU/mobile deployment, hardware acceleration (Tensor Core/GEMM/FPGA/ASIC), training-free semantic compression. Covers 53+ methods across 6 compression categories. Use when: compressing 3DGS models, deploying 3DGS to web/mobile/edge, selecting quantization bit-width, designing streaming pipelines, 3DGS压缩/量化/剪枝/部署/流式传输/移动端/硬件加速."

- license: Apache-2.0

- user-invocable: true

- metadata:

- version: "1.1.1"

- author: jaccen

- tags: ["3dgs", "gaussian-splatting", "compression", "quantization", "pruning", "vector-quantization", "streaming", "deployment", "mobile", "webgpu", "tensor-core", "hardware-acceleration", "bayesian", "semantic-compression"]

- when_to_use:

- - "Compress a 3DGS model for storage or transmission"

- - "Deploy 3DGS to web browser, mobile device, or edge hardware"

- - "Select quantization scheme, bit-width, or pruning strategy"

- - "Design progressive streaming or Level-of-Detail pipeline"

- - "Evaluate hardware acceleration options (Tensor Core, GEMM, FPGA, ASIC)"

- - "3DGS压缩 / 量化 / 剪枝 / 部署 / 流式传输 / 移动端 / 硬件加速"

- ---

- # 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:**

- |--------|------------------------|-----------------|-----------|-------------|

- | Web | 100K–500K | 4–8 bit | Required | CAGS, StreamLoD-GS, Spark 2.0 |

- | Mobile | 50K–200K | 4–8 bit | Optional | Mobile-GS, Flux-GS, PocketGS |

- | Desktop | 500K–5M | 8–16 bit | For large scenes | MesonGS++, HiGS, gsplat |

- | Edge/FPGA | 10K–100K | 2–6 bit | Required | SpqGS, VEDAL, GEMM-GS |

- ## Step 3: Quantization

- ### Method Selection

- |--------|------|-------|-----------|-------------|

- | GSQ | Learned step size | CVPR 2025 | 4–8 bit | Group-wise quantization with learnable step |

- ### Bit-width Selection Guide

- | Attribute | 4–5 bit | 6–8 bit | 8–12 bit | 12–16 bit |

- |-----------|---------|---------|----------|-----------|

- **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

- |--------|--------------|-------|-------------|-------------|

- | HAC | Hash-grid context | ECCV 2024 | ~100x | Context modeling for entropy coding |

- ### 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

- |----------|--------|-------|-------------|---------|-------|

- | Variational Prune | VEDAL | arXiv 2026（venue 待核实） | 5.2x | 0.31 dB drop | 185 FPS |

- | Tri-plane | TC-GS | IEEE 2026 | Implicit | — | — |

- | Mobile | Mobile-GS | ICLR 2026 | 50–100x | Acceptable | 1000+ FPS |

- | Web | Spark 2.0 | 2026 | Stream | 100M+ splats | WebGPU |

- | Tensor Core | GEMM-GS | arXiv 2026 | — | Negligible loss | 1.42x |

- | Tensor Core | TensorGS | arXiv 2026 | — | Negligible loss | 1.65x |

- | Hierarchical Tile | HiGS | NVIDIA 2026 | — | Exact compositing | 15.8x |

- | Hash-grid Context | HAC | ECCV 2024 | ~100x | High | Encoding |

- ## Output Format

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

- ```markdown

- # 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

+ ---

+ name: 3dgs-compression-deploy

+ description: "3DGS compression-to-deployment pipeline: quantization (scalar/VQ/mixed-precision), pruning (coreset/adaptive/variational/merge/Bayesian), progressive streaming & LoD, Web/WebGPU/mobile deployment, hardware acceleration (Tensor Core/GEMM/FPGA/ASIC), training-free semantic compression. Covers 53+ methods across 6 compression categories. Use when: compressing 3DGS models, deploying 3DGS to web/mobile/edge, selecting quantization bit-width, designing streaming pipelines, 3DGS压缩/量化/剪枝/部署/流式传输/移动端/硬件加速."

+ license: Apache-2.0

+ user-invocable: true

+ metadata:

+ version: "1.1.1"

+ author: jaccen

+ tags: ["3dgs", "gaussian-splatting", "compression", "quantization", "pruning", "vector-quantization", "streaming", "deployment", "mobile", "webgpu", "tensor-core", "hardware-acceleration", "bayesian", "semantic-compression"]

+ when_to_use:

+ - "Compress a 3DGS model for storage or transmission"

+ - "Deploy 3DGS to web browser, mobile device, or edge hardware"

+ - "Select quantization scheme, bit-width, or pruning strategy"

+ - "Design progressive streaming or Level-of-Detail pipeline"

+ - "Evaluate hardware acceleration options (Tensor Core, GEMM, FPGA, ASIC)"

+ - "3DGS压缩 / 量化 / 剪枝 / 部署 / 流式传输 / 移动端 / 硬件加速"

+ ---

+ # 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:**

+ |--------|------------------------|-----------------|-----------|-------------|

+ | Web | 100K–500K | 4–8 bit | Required | CAGS, StreamLoD-GS, Spark 2.0 |

+ | Mobile | 50K–200K | 4–8 bit | Optional | Mobile-GS, Flux-GS, PocketGS |

+ | Desktop | 500K–5M | 8–16 bit | For large scenes | MesonGS++, HiGS, gsplat |

+ | Edge/FPGA | 10K–100K | 2–6 bit | Required | SpqGS, VEDAL, GEMM-GS |

+ ## Step 3: Quantization

+ ### Method Selection

+ |--------|------|-------|-----------|-------------|

+ | GSQ | Learned step size | CVPR 2025 | 4–8 bit | Group-wise quantization with learnable step |

+ ### Bit-width Selection Guide

+ | Attribute | 4–5 bit | 6–8 bit | 8–12 bit | 12–16 bit |

+ |-----------|---------|---------|----------|-----------|

+ **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

+ |--------|--------------|-------|-------------|-------------|

+ | HAC | Hash-grid context | ECCV 2024 | ~100x | Context modeling for entropy coding |

+ ### 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

+ |----------|--------|-------|-------------|---------|-------|

+ | Variational Prune | VEDAL | arXiv 2026（venue 待核实） | 5.2x | 0.31 dB drop | 185 FPS |

+ | Tri-plane | TC-GS | IEEE 2026 | Implicit | — | — |

+ | Mobile | Mobile-GS | ICLR 2026 | 50–100x | Acceptable | 1000+ FPS |

+ | Web | Spark 2.0 | 2026 | Stream | 100M+ splats | WebGPU |

+ | Tensor Core | GEMM-GS | arXiv 2026 | — | Negligible loss | 1.42x |

+ | Tensor Core | TensorGS | arXiv 2026 | — | Negligible loss | 1.65x |

+ | Hierarchical Tile | HiGS | NVIDIA 2026 | — | Exact compositing | 15.8x |

+ | Hash-grid Context | HAC | ECCV 2024 | ~100x | High | Encoding |

+ ## Output Format

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

+ ```markdown

+ # 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