SageMaker Serving Image Selection
huggingface/skills
Chooses the right serving container and current image URI for deploying a Hugging Face model to a SageMaker endpoint, preferring Hugging Face images over generic ones.
3DGS compression-to-deployment pipeline: quantization (scalar/VQ/mixed-precision), pruning (coreset/adaptive/variational/merge/Bayesian), progressive streaming & LoD, Web/WebGPU/mobile deployment…
Install 3dgs Compression Deploy
$ npx skills add jaccen/Awesome-Gaussian-Skills --skill 3dgs-compression-deploy -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install jaccen/Awesome-Gaussian-Skills 3dgs-compression-deploy --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/jaccen/Awesome-Gaussian-Skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/3dgs-compression-deploy .claude/skills/3dgs-compression-deploy && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "3dgs-compression-deploy" agent skill from https://github.com/jaccen/Awesome-Gaussian-Skills/tree/main/skills/3dgs-compression-deploy into .claude/skills/3dgs-compression-deploy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "3dgs-compression-deploy", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/jaccen/Awesome-Gaussian-Skills/tree/main/skills/3dgs-compression-deployType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add jaccen/Awesome-Gaussian-Skills --skill 3dgs-compression-deploy -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install jaccen/Awesome-Gaussian-Skills 3dgs-compression-deploy --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jaccen/Awesome-Gaussian-Skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/3dgs-compression-deploy .agents/skills/3dgs-compression-deploy && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "3dgs-compression-deploy" agent skill from https://github.com/jaccen/Awesome-Gaussian-Skills/tree/main/skills/3dgs-compression-deploy into .agents/skills/3dgs-compression-deploy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "3dgs-compression-deploy", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add jaccen/Awesome-Gaussian-Skills --skill 3dgs-compression-deploy -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install jaccen/Awesome-Gaussian-Skills 3dgs-compression-deploy --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jaccen/Awesome-Gaussian-Skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/3dgs-compression-deploy .cursor/skills/3dgs-compression-deploy && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "3dgs-compression-deploy" agent skill from https://github.com/jaccen/Awesome-Gaussian-Skills/tree/main/skills/3dgs-compression-deploy into .cursor/skills/3dgs-compression-deploy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "3dgs-compression-deploy", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/jaccen/Awesome-Gaussian-Skills.git --path skills/3dgs-compression-deploy--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add jaccen/Awesome-Gaussian-Skills --skill 3dgs-compression-deploy -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install jaccen/Awesome-Gaussian-Skills 3dgs-compression-deploy --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jaccen/Awesome-Gaussian-Skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/3dgs-compression-deploy .gemini/skills/3dgs-compression-deploy && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "3dgs-compression-deploy" agent skill from https://github.com/jaccen/Awesome-Gaussian-Skills/tree/main/skills/3dgs-compression-deploy into .gemini/skills/3dgs-compression-deploy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "3dgs-compression-deploy", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install jaccen/Awesome-Gaussian-Skills 3dgs-compression-deployInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add jaccen/Awesome-Gaussian-Skills --skill 3dgs-compression-deploy -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/jaccen/Awesome-Gaussian-Skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/3dgs-compression-deploy .github/skills/3dgs-compression-deploy && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "3dgs-compression-deploy" agent skill from https://github.com/jaccen/Awesome-Gaussian-Skills/tree/main/skills/3dgs-compression-deploy into .github/skills/3dgs-compression-deploy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "3dgs-compression-deploy", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add jaccen/Awesome-Gaussian-Skills --skill 3dgs-compression-deploy -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install jaccen/Awesome-Gaussian-Skills 3dgs-compression-deploy --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/jaccen/Awesome-Gaussian-Skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/3dgs-compression-deploy .opencode/skills/3dgs-compression-deploy && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "3dgs-compression-deploy" agent skill from https://github.com/jaccen/Awesome-Gaussian-Skills/tree/main/skills/3dgs-compression-deploy into .opencode/skills/3dgs-compression-deploy/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "3dgs-compression-deploy", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
3dgs-compression-deploy- GitHub stars
- 161
- Token cost
- ~5.5k tokens
- SKILL.md length
- 1,828 words
- Files
- 2 (incl. references)
- Skills in repo
- 13
- Repo updated
- First seen
- Licence
- Apache-2.0
At a glance
3DGS compression-to-deployment pipeline: quantization (scalar/VQ/mixed-precision), pruning (coreset/adaptive/variational/merge/Bayesian), progressive streaming & LoD, Web/WebGPU/mobile deployment…
- Works in 7 steps: Analysis → Compression Strategy Selection → Quantization → …
- : compressing 3DGS models
- SKILL.md covers Capabilities, Compression Pipeline, Step 1: Analysis and Step 2: Compression Strategy…, plus 11 more sections
- Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
What it does
3dgs Compression Deploy is an agent skill from jaccen/Awesome-Gaussian-Skills. 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压缩/量化/剪枝/部署/流式传输/移动端/硬件加速.
Its SKILL.md is about 5.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including reference files (for example `references/compression-methods.md`).
It sits in AI & LLM Engineering, covering LLM inference and serving, Deployment and GPU and accelerator computing. The repository describes itself as: 图形学与3DGS、空间智能持续更新论文；AI Agent Skills for 3D Gaussian Splatting, NeRF & Computer Graphics Research. 800+ methods, 25categories, 12skills. OpenClaw / Claude Code compatible. The licence is Apache-2.0.
When your agent uses it
- : compressing 3DGS models
- Deploying 3DGS to web/mobile/edge
- Selecting quantization bit-width
- Designing streaming pipelines
Example prompts
- “/3dgs-compression-deploy”
Workflow steps
7 steps, taken from the step headings in SKILL.md.
What it can do on your machine
Read from SKILL.md and the folder at commit 437c820. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
3dgs Compression Deploy loads about 5.5k tokens when it runs, and up to ~10k if it reads all its reference files. Until then it costs about 132 tokens; SKILL.md has 1,828 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
SKILL.md
The full file from jaccen/Awesome-Gaussian-Skills at commit 437c820, republished under its Apache-2.0 licence (© jaccen). 1,828 words, ~5,521 tokens.
Download SKILL.mdSave it as
.claude/skills/3dgs-compression-deploy/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.- 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
- metadata.author
- jaccen
- metadata.tags
- 3dgs, gaussian-splatting, compression, quantization, pruning, vector-quantization, streaming, deployment, mobile, webgpu, tensor-core, hardware-acceleration…
- metadata.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…
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:
| Attribute | FP32 Size | Typical Range | Sensitivity to Quantization |
|---|---|---|---|
| Position (μ) | 12B/Gaussian | Scene bounds | High — direct geometry impact |
| SH (degree 0–3) | 48B/Gaussian | [-1, 1] per coeff | Medium-High — visual quality driver |
| Opacity (α) | 4B/Gaussian | [0, 1] | Medium — pruning signal |
| Scale (s) | 12B/Gaussian | [1e-5, 1e2] | Medium — anisotropy sensitive |
| Rotation (q) | 16B/Gaussian | Unit quaternion | Low-Medium — can tolerate 8-bit |
Profiling checklist:
- Total Gaussian count N and file size S
- Target platform constraints (memory budget, bandwidth, GPU capability)
- Quality floor (minimum acceptable PSNR/SSIM)
- Required FPS threshold
- 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-deviceCombined target table:
| Target | Typical Gaussian Budget | Bit-width Range | Streaming | Key Methods |
|---|---|---|---|---|
| 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
| Method | Type | Venue | Bit-width | Key Feature |
|---|---|---|---|---|
| MesonGS++ | Mixed-precision (post-training) | arXiv 2026 | 4–16 bit per attribute | 0-1 ILP hyperparameter search, 34x compression |
| GETA-3DGS | Joint pruning + quantization | arXiv 2026 | 4–8 bit heterogeneous | Render-aware saliency, QADG dependency graph |
| GSQ | Learned step size | CVPR 2025 | 4–8 bit | Group-wise quantization with learnable step |
| ContextGS | Context-model entropy coding | NeurIPS 2024 | 8–16 bit | Anchor-level context replaces uniform quant |
| SpqGS | Scalable parallel | CVPR 2025 | Hardware-friendly | Parallel bit allocation for FPGA/ASIC |
| SOG-GS | Channel-grouped | CVPR 2025 | Per-channel | Preserves inter-Gaussian correlations |
| ZipGS | Pruning + quant + entropy | CVPR 2025 | Variable | Volumetric entropy coding |
| GaussianCodec | Entropy-constrained | CVPR 2025 | Rate-distortion optimized | Learned codec with ECVQ |
| EAGLES | Quantized embeddings | ECCV 2024 | 8–16 bit | Coarse-to-fine training + pruning |
| TC-GS | Tri-plane representation | IEEE 2026 | Implicit via tri-plane | Replaces per-Gaussian SH with shared tri-plane |
Bit-width Selection Guide
| Attribute | 4–5 bit | 6–8 bit | 8–12 bit | 12–16 bit |
|---|---|---|---|---|
| Position | Edge only — visible artifacts | Mobile/Web acceptable | Desktop recommended | Lossless-range |
| SH (dc) | Not recommended | Edge/mobile | Desktop | High-fidelity |
| SH (rest) | Aggressive mobile | Mobile/Web | Desktop | Unnecessary |
| Opacity | Acceptable (post-sigmoid) | Recommended | Overkill | Overkill |
| Scale | Log-space 4-bit risky | Log-space 6–8 bit | Recommended | Overkill |
| Rotation | 8-bit often sufficient | Standard | Unnecessary | Overkill |
Rule of thumb: Position and SH dominate quality; allocate more bits there. Opacity and rotation tolerate aggressive quantization.
Step 4: Pruning
Strategies
| Strategy | Method | Venue | Compression | Quality Impact |
|---|---|---|---|---|
| Coreset-based | Provable Pruning via Coresets | arXiv 2026 | Theoretical guarantee | Minimal — multiplicative approximation |
| Bayesian | DP-Splat | arXiv 2026 | Automatic complexity control | Minimal — DP prior converges to optimal count |
| Training-free semantic | CoSAG | arXiv 2026 | 37–76× over LangSplatV2 | Minimal — zero fine-tuning, leverages CLIP features |
| Importance-based | Prune Wisely (DoG) | CVPR 2026 | 90% reduction | Minimal — DoG avoids false positives |
| Variational | VEDAL | arXiv 2026（venue 待核实） | 5.2x (0.31 dB drop) | Low — uncertainty-gated async pruning |
| Merge-based | NanoGS | arXiv 2026 | Training-free | Mass-preserving moment matching |
| Global+Local | LightGaussian | NeurIPS 2024 | 15x | SVD distillation compensates |
| Render-aware | GETA-3DGS | arXiv 2026 | ~5x storage | Transmittance-weighted saliency |
| Frequency-aware | FAD-GS | CVPR 2024 | Frequency-separated | Separates low/high freq Gaussians |
| Memory-bounded | Gaussians on a Diet | arXiv 2026 | 80% peak memory | Iterative growth+pruning |
| Hybrid | HybridGS | CVPR 2025 | Explicit+implicit | Neural coding recovers pruned info |
| Budget-controlled | MGS (Matryoshka) | arXiv 2026 | Continuous LoD | Any prefix of ordered set is coherent |
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 BitstreamVQ Methods
| Method | Codebook Type | Venue | Compression | Key Feature |
|---|---|---|---|---|
| CompactGS | Learned per-attribute | ECCV 2024 | 10–15x | Simple codebook, minimal overhead |
| VQGS | Residual codebook | CVPR 2025 | High-ratio | Multi-level residual improves quality |
| RDO-Gaussian | ECVQ (entropy-constrained) | ECCV 2024 | 40x+ | Rate-distortion optimized VQ |
| CAGS | VQ + LoD layers | SIGGRAPH 2026 | Adaptive | VQ establishes quality LoDs for streaming |
| CGVQ | Clustered codebook | SIGGRAPH 2026 Poster | 20% bpp reduction | Cluster-guided grouping before quant |
| Sp2403GS | Codebook + pruning | CVPR 2024 | Combined | Importance-based codebook selection |
| HAC | Hash-grid context | ECCV 2024 | ~100x | Context modeling for entropy coding |
| CompGS | Importance-aware | CVPR 2025 | Progressive | Progressive decoding support |
Codebook Design Rules
- Codebook size K: 256 (8-bit index) is standard; 1024 (10-bit) for quality; 64 (6-bit) for extreme compression
- Grouping strategy: Group by attribute type (position separate from SH); within SH, separate DC from higher-order
- Residual levels: 1 level = 10–20x; 2 levels = 20–50x; 3 levels = diminishing returns
- LoD integration: Each residual level can serve as a LoD tier (see Step 6)
Step 6: Streaming & LoD
Static Scene Streaming
| Method | LoD Mechanism | Venue | Latency Reduction | Key Feature |
|---|---|---|---|---|
| StreamLoD-GS | View-dependent LoD levels | arXiv 2026 | Progressive | Bandwidth-adaptive FVV delivery |
| HGS | Hierarchical Gaussian structuring | CVPR 2025 | Progressive | Level-of-detail Gaussian hierarchy |
| GS-Stream | Progressive chunk delivery | CVPR 2025 | Bandwidth-adaptive | Chunk-based 3DGS streaming |
| EvoGS | Evolution Tree (wavelet-inspired) | arXiv 2026 | 2.4x payload reduction | Continuous parent-child refinement |
| MGS | Stochastic budget training | arXiv 2026 | Continuous | Any prefix = coherent render |
| SCube | VoxSplats + hierarchical LOD | NeurIPS 2024 | Hierarchical | Voxelized splat for large-scale |
| CAGS | VQ-based LoD + reference image | SIGGRAPH 2026 | +5–20 dB PSNR | Server-side low-res reference corrects color |
Dynamic (4DGS) Streaming
| Method | Mechanism | Venue | First-frame Latency | Key Feature |
|---|---|---|---|---|
| PD-4DGS | Hierarchical Deformation Decomposition | arXiv 2026 | ~1.7s (from 73–930s) | 3 independent layers: static + global deform + local refine |
| CAGS | VQ LoD + color correction | SIGGRAPH 2026 | Adaptive | Representation-agnostic, works with diverse Gaussian types |
| QUEEN | Quantized streaming encoding | NeurIPS 2024 | Streaming | Dynamic Gaussian free-viewpoint video |
| BlitzGS | Distributed GPU sharding | arXiv 2026 | Parity-based | City-scale distributed rendering + importance scoring |
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)
| Platform | Renderer | Max Gaussians | Key Feature |
|---|---|---|---|
| Spark 2.0 | WebGPU | 100M+ splats | Chunk streaming, multi-splat sorting, progressive LOD |
| Visionary | WebGPU + ONNX Runtime | Large | 4DGS + neural avatars + generative post-processing |
| SuperSplat | WebGL | ~5M | Editable viewer, selection tools |
| PlayCanvas | WebGL 2.0 | ~2M | Game engine integration |
Web deployment checklist:
- Choose WebGPU (Chrome 113+) for compute shader support; fallback WebGL 2.0 for compatibility
- Chunk Gaussians into 50K–200K groups for progressive loading
- Use INT8/FP16 textures for quantized attributes
- Implement front-to-back alpha compositing in fragment shader (WebGL) or compute shader (WebGPU)
- Target 30+ FPS at 1080p for interactive experience
Mobile (iOS / Android)
| Method | Venue | FPS (Mobile) | Key Feature |
|---|---|---|---|
| Mobile-GS | ICLR 2026 | 1000+ FPS (on-device) | Depth-aware OIT + distillation + contribution pruning |
| Flux-GS | ECCV 2026 | Real-time | Monte Carlo specular energy, compact latent SH |
| PocketGS | arXiv 2026 | On-device training | Anisotropic seeding + cached alpha compositing |
Mobile deployment pipeline:
- Train on server → compress (prune + quantize + merge via NanoGS)
- Export to mobile-optimized format (INT8 attributes, fused SH degree ≤ 2)
- Use Metal (iOS) / Vulkan (Android) for GPU rasterization
- Apply Mobile-GS depth-aware OIT for correct blending on tile-based GPUs
- Memory budget: stay under 500MB for iOS, 300MB for Android
Show full SKILL.md (694 more words)Show less
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
| Method | Hardware | Venue | Speedup | Key Feature |
|---|---|---|---|---|
| GEMM-GS | Tensor Core (GEMM) | arXiv 2026 | 1.42x | Reformulates blending as GEMM ops |
| TensorGS | Tensor Core (FP16 matrix) | arXiv 2026 | 1.65x | Tensorizes rasterization with cross-tile grouping |
| Axis-Shared Accelerator | ASIC (custom) | ISCA 2026 | On-chip real-time | First 3DGS hardware accelerator, order-independent transmittance |
| HiGS | GPU (hierarchical tiles) | NVIDIA 2026 | 15.8x | Macro-tile + fine render tile decoupling |
| LiteGS | GPU (Moore Threads) | SIGGRAPH Asia 2025 | Software-hardware co-opt | Won 3DGS Challenge silver at SIGGRAPH Asia |
| SpqGS | FPGA-friendly | CVPR 2025 | Parallel bit allocation | Hardware-scalable quantization |
| QuadBox | GPU (AABB optimization) | arXiv 2026 | 1.85x | Geometry-aware bounding boxes |
| StereoGS | ASIC (stereoscopic) | 2026 | Dual-eye shared | Energy-efficient stereoscopic GS processor; shared compute + memory bandwidth for VR/AR |
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
| Category | Method | Venue | Compression | Quality | Speed |
|---|---|---|---|---|---|
| Mixed-precision Q | MesonGS++ | arXiv 2026 | 34x | High | Post-training |
| Joint Prune+Q | GETA-3DGS | arXiv 2026 | ~5x | High | Auto |
| Adaptive Prune | Prune Wisely | CVPR 2026 | 90% Gaussians | High | Post-training |
| Variational Prune | VEDAL | arXiv 2026（venue 待核实） | 5.2x | 0.31 dB drop | 185 FPS |
| Coreset Prune | Provable Coresets | arXiv 2026 | Guaranteed | Theoretical | + finetune |
| Merge Simplify | NanoGS | arXiv 2026 | Training-free | High | Fast (CPU) |
| VQ+LoD Stream | CAGS | SIGGRAPH 2026 | Adaptive | +5–20 dB | Stream |
| VQ Residual | VQGS | CVPR 2025 | High-ratio | Medium | — |
| Tri-plane | TC-GS | IEEE 2026 | Implicit | — | — |
| 4D Stream | PD-4DGS | arXiv 2026 | Progressive | 3-layer | 1.7s first-frame |
| Large-scale Dist | BlitzGS | arXiv 2026 | Parity shards | City-scale | Distributed |
| Mobile | Mobile-GS | ICLR 2026 | 50–100x | Acceptable | 1000+ FPS |
| Mobile | Flux-GS | ECCV 2026 | Parameter reduction | High | Real-time |
| WebGPU | Visionary | arXiv 2025 | Stream | High | WebGPU |
| 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 |
| ASIC | Axis-Shared Accel | ISCA 2026 | — | On-chip | Real-time |
| Hierarchical Tile | HiGS | NVIDIA 2026 | — | Exact compositing | 15.8x |
| Evolution Tree | EvoGS | arXiv 2026 | 2.4x payload | Continuous | Stream |
| Matryoshka LoD | MGS | arXiv 2026 | Continuous | Any prefix | Flexible |
| Hash-grid Context | HAC | ECCV 2024 | ~100x | High | Encoding |
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
- Always profile before compressing: attribute distribution dictates bit-width allocation, not a fixed recipe
- Pruning before quantization: reducing Gaussian count first lowers total data; then quantize the remaining attributes
- VQ replaces or augments scalar quantization: do not apply both independently to the same attribute group
- Streaming requires LoD structure: flat compression without LoD degrades user experience on slow connections
- Mobile deployment needs Metal/Vulkan: CUDA is not available on mobile; plan the rasterization backend from Step 2
- Quantization-aware finetuning recovers quality: always finetune 1–5k iterations after aggressive (≤6 bit) quantization
- Entropy coding is the last step: apply after all other compression; HAC/ContextGS/GaussianCodec specialize in this
- Cross-reference with knowledge base: load
references/compression-methods.mdfor 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.mdor 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
© jaccen, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 1 other file (references) in skills/3dgs-compression-deploy of jaccen/Awesome-Gaussian-Skills.
- SKILL.md
- references/compression-methods.md
Open the folder on GitHubat commit 437c820
Compare with similar skills
3dgs Compression Deploy next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| 3dgs Compression Deploy this skilljaccen/Awesome-Gaussian-Skills | 161 | — | ~5.5k | Automated safety check: Pass | Apache-2.0 | |
| SageMaker Serving Image Selectionhuggingface/skills | 11k | 1 repos | ~4.6k | Automated safety check: Pass | Apache-2.0 | |
| Hugging Face Local Model Evalshuggingface/skills | 11k | 2 repos | ~1.6k | Automated safety check: Pass | Apache-2.0 | |
| Triton Kernel Writingguqiong96/Lvllm | 464 | 1 repos | ~831 | Automated safety check: Pass | Apache-2.0 | |
| Nemotron Nano3NVIDIA-NeMo/Nemotron | 2.1k | — | ~1.9k | Automated safety check: Pass | Apache-2.0 | |
| bitsandbytes Model QuantizationOrchestra-Research/AI-Research-SKILLs | 13k | 3 repos | ~2.5k | Automated safety check: Pass | MIT |
Similar skills
- Official
- Official
Hugging Face Local Model Evals
huggingface/skills
Runs evaluations of Hugging Face Hub models on local hardware with inspect-ai or lighteval, and helps choose between vLLM, Transformers and accelerate backends.
Triton Kernel Writing
guqiong96/Lvllm
Write or review Triton kernels for vLLM, with practical guidance for generated-code inspection, launch grids, indexing, specialization, tuning, and representative performance validation.
Nemotron Nano3
NVIDIA-NeMo/Nemotron
Reference desk for Nemotron 3 Nano / Llama-Nemotron Nano 3 — architecture, training data, recipes, evaluation, quantization, deployment.
bitsandbytes Model Quantization
Orchestra-Research/AI-Research-SKILLs
Loads large language models in 8-bit or 4-bit with bitsandbytes so they fit smaller GPUs, and sets up QLoRA fine-tuning on a 4-bit base model.
- Official
SageMaker Deployment Planner
huggingface/skills
Entry point for hosting a model on Amazon SageMaker: asks a few questions, picks a deployment pathway and hands off to the specialist skills.
More from jaccen/Awesome-Gaussian-Skills
All 13 skills in this repo3dgs Code Reviewer
jaccen/Awesome-Gaussian-Skills
Review 3DGS implementation code for correctness, performance bugs, and best practices.
Patent Software Ip
jaccen/Awesome-Gaussian-Skills
Generate CN patent docs (claims, specification, abstract) and software copyright materials from AI/big-data project code or docs.
3dgs Articulated Reasoner
jaccen/Awesome-Gaussian-Skills
3DGS Articulated Object Reasoning & Digital Twin Agent. An agent skill from jaccen/Awesome-Gaussian-Skills.
3dgs MCP Renderer
jaccen/Awesome-Gaussian-Skills
MCP protocol integration with 3DGS rendering pipeline: Agent-controlled Three.js/WebGPU rendering, voice-driven scene reconstruction, real-time parameter manipulation, light tracing backend.
3dgs Paper Reader
jaccen/Awesome-Gaussian-Skills
Read and summarize 3DGS research papers. An agent skill from jaccen/Awesome-Gaussian-Skills.
3dgs Spatial Agent
jaccen/Awesome-Gaussian-Skills
3DGS/CAD/Mesh domain-specific spatial intelligence agent: scene-level reasoning, CAD-in-the-loop parametric extraction, multi-modal 3D interaction, geometry-opacity decoupling, reflective material…
Related
Categories
Questions about 3dgs Compression Deploy
What does 3dgs Compression Deploy do?
3DGS compression-to-deployment pipeline: quantization (scalar/VQ/mixed-precision), pruning (coreset/adaptive/variational/merge/Bayesian), progressive streaming & LoD, Web/WebGPU/mobile deployment…. 3dgs Compression Deploy is an agent skill from jaccen/Awesome-Gaussian-Skills. 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.
When should I use 3dgs Compression Deploy?
3dgs Compression Deploy fits situations like: : compressing 3DGS models; deploying 3DGS to web/mobile/edge; selecting quantization bit-width; designing streaming pipelines.
How do I install 3dgs Compression Deploy in Claude Code?
Run `npx skills add jaccen/Awesome-Gaussian-Skills --skill 3dgs-compression-deploy -a claude-code`. Or copy the skill folder (skills/3dgs-compression-deploy in jaccen/Awesome-Gaussian-Skills) into .claude/skills/3dgs-compression-deploy in your project. Claude Code loads it when a task matches its description.
How do I install 3dgs Compression Deploy in Codex?
Run `npx skills add jaccen/Awesome-Gaussian-Skills --skill 3dgs-compression-deploy -a codex`. Or copy the skill folder (skills/3dgs-compression-deploy in jaccen/Awesome-Gaussian-Skills) into .agents/skills/3dgs-compression-deploy in your project. Codex loads it when a task matches its description.
Can I use 3dgs Compression Deploy in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add jaccen/Awesome-Gaussian-Skills --skill 3dgs-compression-deploy -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/3dgs-compression-deploy, .gemini/skills/3dgs-compression-deploy, .github/skills/3dgs-compression-deploy and .opencode/skills/3dgs-compression-deploy in your project.
What does 3dgs Compression Deploy need to run?
SKILL.md names no scripts, command-line tools or credentials: 3dgs Compression Deploy is instructions for the agent only.
Does 3dgs Compression Deploy access the network?
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Is 3dgs Compression Deploy safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
What licence does 3dgs Compression Deploy use?
3dgs Compression Deploy is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does 3dgs Compression Deploy use?
About 5.5k tokens (SKILL.md is roughly 22k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 4.7k tokens, read only when the agent opens those files.
What are the alternatives to 3dgs Compression Deploy?
Skills that share tags, products or a category with 3dgs Compression Deploy: SageMaker Serving Image Selection (huggingface/skills, 11k stars), Hugging Face Local Model Evals (huggingface/skills, 11k stars), Triton Kernel Writing (guqiong96/Lvllm, 464 stars) and Nemotron Nano3 (NVIDIA-NeMo/Nemotron, 2.1k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains 3dgs Compression Deploy?
jaccen (a GitHub user) maintains it in jaccen/Awesome-Gaussian-Skills, which has 161 GitHub stars. The repository holds 13 skills in this directory. The repository was last updated on October 8, 2026.
Source: jaccen/Awesome-Gaussian-Skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.