@wentorai/research-plugins 1.1.0 → 1.2.0

package/skills/domains/chemistry/chemeagle-guide/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: chemeagle-guide
+description: "Multi-agent system for chemical literature information extraction"
+metadata:
+  openclaw:
+    emoji: "🦅"
+    category: "domains"
+    subcategory: "chemistry"
+    keywords: ["ChemEagle", "chemical extraction", "literature mining", "reaction extraction", "chemistry NLP", "multi-agent"]
+    source: "https://github.com/CYF2000127/ChemEagle"
+---
+
+# ChemEagle Guide
+
+## Overview
+
+ChemEagle is a multi-agent system for extracting structured chemical information from scientific literature. It uses specialized agents for recognizing chemical entities, extracting reaction conditions, identifying product yields, and building structured databases from unstructured chemistry papers. Particularly useful for building reaction databases and automating systematic reviews in chemistry.
+
+## Agent Pipeline
+
+```
+Chemistry Paper (PDF/text)
+         ↓
+   Document Parser Agent (section identification)
+         ↓
+   Chemical NER Agent
+   ├── Compound names → SMILES/InChI
+   ├── Reagents and catalysts
+   ├── Solvents and conditions
+   └── Product identification
+         ↓
+   Reaction Extraction Agent
+   ├── Reactants → Products mapping
+   ├── Reaction conditions (T, P, time)
+   ├── Yields and selectivity
+   └── Procedure steps
+         ↓
+   Validation Agent (cross-check extracted data)
+         ↓
+   Structured Output (JSON, CSV, database)
+```
+
+## Usage
+
+```python
+from chemeagle import ChemEagle
+
+eagle = ChemEagle(llm_provider="anthropic")
+
+# Extract from a chemistry paper
+result = eagle.extract("paper.pdf")
+
+# Extracted reactions
+for rxn in result.reactions:
+    print(f"\nReaction {rxn.id}:")
+    print(f"  Reactants: {rxn.reactants}")
+    print(f"  Products: {rxn.products}")
+    print(f"  Catalyst: {rxn.catalyst}")
+    print(f"  Solvent: {rxn.solvent}")
+    print(f"  Temperature: {rxn.temperature}")
+    print(f"  Time: {rxn.time}")
+    print(f"  Yield: {rxn.yield_percent}%")
+    print(f"  SMILES: {rxn.product_smiles}")
+
+# Extracted compounds
+for compound in result.compounds:
+    print(f"{compound.name}: {compound.smiles}")
+```
+
+## Batch Processing
+
+```python
+# Process multiple papers
+results = eagle.extract_batch(
+    input_dir="chemistry_papers/",
+    output_format="csv",
+    output_file="reactions_database.csv",
+)
+
+print(f"Papers processed: {results.papers_processed}")
+print(f"Reactions extracted: {results.total_reactions}")
+print(f"Unique compounds: {results.unique_compounds}")
+```
+
+## Chemical Entity Recognition
+
+```python
+# Standalone NER
+entities = eagle.recognize_entities(
+    "The Suzuki coupling of 4-bromoanisole with phenylboronic "
+    "acid using Pd(PPh3)4 catalyst in THF/water at 80°C "
+    "gave 4-methoxybiphenyl in 95% yield."
+)
+
+for entity in entities:
+    print(f"  [{entity.type}] {entity.text}")
+    if entity.smiles:
+        print(f"    SMILES: {entity.smiles}")
+
+# Output:
+# [REACTANT] 4-bromoanisole — SMILES: COc1ccc(Br)cc1
+# [REACTANT] phenylboronic acid — SMILES: OB(O)c1ccccc1
+# [CATALYST] Pd(PPh3)4
+# [SOLVENT] THF/water
+# [CONDITION] 80°C
+# [PRODUCT] 4-methoxybiphenyl — SMILES: COc1ccc(-c2ccccc2)cc1
+# [YIELD] 95%
+```
+
+## Database Building
+
+```python
+# Build a searchable reaction database
+from chemeagle import ReactionDatabase
+
+db = ReactionDatabase("reactions.db")
+
+# Add extracted reactions
+db.add_from_extraction(result)
+
+# Search by substrate
+hits = db.search(reactant="bromoanisole", reaction_type="coupling")
+for hit in hits:
+    print(f"{hit.reactants} → {hit.products} ({hit.yield_percent}%)")
+    print(f"  Source: {hit.paper_doi}")
+
+# Search by conditions
+hits = db.search(catalyst="palladium", temperature_max=100)
+
+# Export
+db.export_csv("all_reactions.csv")
+db.export_json("all_reactions.json")
+```
+
+## Use Cases
+
+1. **Reaction mining**: Extract reactions from chemistry literature
+2. **Database building**: Automated reaction database construction
+3. **Systematic reviews**: Structured data from chemistry papers
+4. **Synthesis planning**: Search conditions for target reactions
+5. **Trend analysis**: Track reaction methodology evolution
+
+## References
+
+- [ChemEagle GitHub](https://github.com/CYF2000127/ChemEagle)
+- [RDKit](https://www.rdkit.org/) — Chemistry toolkit
+- [PubChem](https://pubchem.ncbi.nlm.nih.gov/) — Chemical database

package/skills/domains/chemistry/chemgraph-agent-guide/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: chemgraph-agent-guide
+description: "Automate molecular simulations with the ChemGraph agentic framework"
+metadata:
+  openclaw:
+    emoji: "⚗️"
+    category: "domains"
+    subcategory: "chemistry"
+    keywords: ["ChemGraph", "molecular simulation", "computational chemistry", "DFT", "LangGraph", "ASE"]
+    source: "https://github.com/argonne-lcf/ChemGraph"
+---
+
+# ChemGraph Agent Guide
+
+## Overview
+
+ChemGraph is an agentic framework from Argonne National Lab that automates molecular simulation workflows using LLMs. Built on LangGraph and ASE (Atomic Simulation Environment), it enables natural language control of computational chemistry tasks — structure generation, geometry optimization, thermochemistry, and more. Supports DFT (NWChem, ORCA), semi-empirical (xTB), and ML potentials (MACE).
+
+## Installation
+
+```bash
+pip install chemgraph
+
+# Or via Docker
+docker pull ghcr.io/argonne-lcf/chemgraph:latest
+```
+
+## Core Capabilities
+
+### Natural Language Chemistry
+
+```python
+from chemgraph import ChemGraphAgent
+
+agent = ChemGraphAgent(
+    llm_provider="anthropic",
+    calculator="xtb",  # fast semi-empirical
+)
+
+# Natural language molecular tasks
+result = agent.run("Optimize the geometry of caffeine and calculate its vibrational frequencies")
+print(result.energy)
+print(result.frequencies)
+
+# Thermochemistry
+result = agent.run("Calculate the enthalpy of formation of ethanol at 298K")
+print(f"ΔHf = {result.enthalpy:.2f} kJ/mol")
+```
+
+### Supported Calculators
+
+| Calculator | Type | Speed | Accuracy |
+|-----------|------|-------|----------|
+| xTB (TBLite) | Semi-empirical | Fast | Moderate |
+| MACE | ML potential | Fast | Good |
+| NWChem | Ab initio DFT | Slow | High |
+| ORCA | Ab initio/DFT | Slow | High |
+| UMA | Universal ML | Fast | Good |
+
+### Workflow Automation
+
+```python
+# Multi-step workflow
+workflow = agent.create_workflow([
+    "Generate 3D structure of aspirin from SMILES",
+    "Optimize geometry with DFT/B3LYP/6-31G*",
+    "Calculate IR spectrum",
+    "Identify key functional group vibrations",
+])
+results = workflow.execute()
+
+# Reaction pathway
+pathway = agent.run(
+    "Find the transition state for the Diels-Alder reaction "
+    "between butadiene and ethylene"
+)
+```
+
+### Integration with ASE
+
+```python
+from ase.io import read
+from chemgraph.calculators import get_calculator
+
+# Use ChemGraph's calculator with ASE directly
+atoms = read("molecule.xyz")
+calc = get_calculator("xtb")
+atoms.calc = calc
+
+energy = atoms.get_potential_energy()
+forces = atoms.get_forces()
+```
+
+## Agent Architecture
+
+ChemGraph uses LangGraph's state machine to orchestrate:
+
+1. **Parser Agent** — Interprets natural language into chemistry tasks
+2. **Structure Agent** — Generates/retrieves molecular structures (SMILES, PDB, CIF)
+3. **Calculator Agent** — Selects and runs appropriate simulation backend
+4. **Analysis Agent** — Processes results and generates reports
+
+## Use Cases
+
+1. **High-throughput screening**: Automated property calculation for molecular libraries
+2. **Reaction discovery**: Transition state finding and reaction pathway analysis
+3. **Materials design**: Optimize structures for target properties
+4. **Education**: Natural language interface for learning computational chemistry
+
+## Requirements
+
+- Python 3.10+
+- At least one calculator backend (xTB recommended for getting started)
+- LLM API key (Anthropic, OpenAI, or local)
+
+## References
+
+- [ChemGraph GitHub](https://github.com/argonne-lcf/ChemGraph)
+- [ASE Documentation](https://wiki.fysik.dtu.dk/ase/)
+- [LangGraph](https://github.com/langchain-ai/langgraph)

package/skills/domains/cs/ai-security-papers-guide/SKILL.md

@@ -0,0 +1,103 @@
+---
+name: ai-security-papers-guide
+description: "AI security papers from top-4 security conferences"
+metadata:
+  openclaw:
+    emoji: "🛡️"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["AI security", "adversarial ML", "model attacks", "S&P", "CCS", "USENIX", "NDSS"]
+    source: "https://github.com/Zhou-Zi7/Awesome-AI-Security-BIG4"
+---
+
+# AI Security Papers Guide (BIG4 Venues)
+
+## Overview
+
+A curated collection of AI security papers from the top-4 security conferences: IEEE S&P, ACM CCS, USENIX Security, and NDSS. Covers adversarial attacks, model stealing, data poisoning, privacy attacks, deepfake detection, and LLM security. Organized by year and venue, focusing exclusively on peer-reviewed work from these prestigious venues.
+
+## Venues
+
+| Venue | Full Name | Focus |
+|-------|-----------|-------|
+| **S&P** | IEEE Symposium on Security and Privacy | Broad security + privacy |
+| **CCS** | ACM Conference on Computer and Communications Security | Systems security |
+| **USENIX** | USENIX Security Symposium | Systems + network security |
+| **NDSS** | Network and Distributed System Security | Network security |
+
+## Topic Categories
+
+```
+AI Security (BIG4)
+├── Adversarial ML
+│   ├── Evasion attacks (adversarial examples)
+│   ├── Poisoning attacks (backdoors, trojans)
+│   ├── Model stealing (extraction, distillation)
+│   └── Defenses (certified robustness, detection)
+├── Privacy Attacks
+│   ├── Membership inference
+│   ├── Model inversion
+│   ├── Attribute inference
+│   └── Training data extraction
+├── LLM Security
+│   ├── Prompt injection
+│   ├── Jailbreaking
+│   ├── Data leakage
+│   └── Alignment attacks
+├── Deepfakes
+│   ├── Generation methods
+│   ├── Detection techniques
+│   └── Watermarking
+└── Federated Learning Security
+    ├── Byzantine attacks
+    ├── Gradient leakage
+    └── Secure aggregation
+```
+
+## Key Papers by Year
+
+```python
+# Recent highlights
+papers_2024_2025 = [
+    {"title": "Not What You've Signed Up For: "
+              "Compromising Real-World LLM-Integrated Applications",
+     "venue": "S&P 2024", "topic": "LLM security"},
+    {"title": "Prompt Stealing Attacks Against "
+              "Text-to-Image Generation Models",
+     "venue": "S&P 2024", "topic": "Prompt extraction"},
+    {"title": "Backdoor Attacks on Language Models",
+     "venue": "CCS 2024", "topic": "NLP backdoors"},
+    {"title": "Membership Inference in LLMs",
+     "venue": "USENIX 2024", "topic": "Privacy"},
+]
+
+for p in papers_2024_2025:
+    print(f"[{p['venue']}] {p['title']}")
+    print(f"  Topic: {p['topic']}")
+```
+
+## Research Trends
+
+```markdown
+### Emerging Areas (2024-2025)
+1. **LLM security** — Jailbreaking, prompt injection, agent attacks
+2. **Supply chain attacks** — Poisoned models, malicious packages
+3. **Multi-modal attacks** — Cross-modal adversarial examples
+4. **Agent security** — Attacks on LLM-based autonomous systems
+5. **Watermarking** — LLM output detection, IP protection
+6. **Unlearning** — Machine unlearning verification and attacks
+```
+
+## Use Cases
+
+1. **Security research**: Find state-of-the-art attack/defense methods
+2. **Threat modeling**: Understand AI system vulnerabilities
+3. **Literature review**: Systematic coverage of BIG4 AI security
+4. **Course material**: Graduate-level AI security curriculum
+5. **Red teaming**: Learn evaluation techniques for AI systems
+
+## References
+
+- [Awesome-AI-Security-BIG4](https://github.com/Zhou-Zi7/Awesome-AI-Security-BIG4)
+- [IEEE S&P](https://www.ieee-security.org/TC/SP-Index.html)
+- [ACM CCS](https://www.sigsac.org/ccs/)

package/skills/domains/cs/code-llm-papers-guide/SKILL.md

@@ -0,0 +1,131 @@
+---
+name: code-llm-papers-guide
+description: "Survey and paper collection on LLMs for code generation"
+metadata:
+  openclaw:
+    emoji: "💻"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["Code LLM", "code generation", "program synthesis", "Codex", "code intelligence", "software engineering"]
+    source: "https://github.com/codefuse-ai/Awesome-Code-LLM"
+---
+
+# Code LLM Papers Guide
+
+## Overview
+
+This curated collection covers LLMs for code — from foundational models (Codex, CodeGen, StarCoder) through code generation, completion, repair, translation, and understanding. Accompanies a TMLR survey paper providing systematic categorization. Tracks 500+ papers across pre-training, fine-tuning, evaluation, and application of code-focused language models.
+
+## Taxonomy
+
+```
+Code LLMs
+├── Pre-training
+│   ├── Encoder-only (CodeBERT, GraphCodeBERT)
+│   ├── Decoder-only (Codex, CodeGen, StarCoder, DeepSeek-Coder)
+│   └── Encoder-Decoder (CodeT5, PLBART)
+├── Fine-tuning & Alignment
+│   ├── Instruction tuning (WizardCoder, Magicoder)
+│   ├── RLHF for code (CodeRL)
+│   └── Self-play (AlphaCode)
+├── Applications
+│   ├── Code generation (NL → Code)
+│   ├── Code completion (infilling)
+│   ├── Code repair (bug fixing)
+│   ├── Code translation (language conversion)
+│   ├── Code summarization (Code → NL)
+│   ├── Test generation
+│   └── Code review
+└── Evaluation
+    ├── Benchmarks (HumanEval, MBPP, SWE-bench)
+    ├── Metrics (pass@k, CodeBLEU)
+    └── Security analysis
+```
+
+## Key Models Timeline
+
+| Model | Year | Organization | Parameters | Key Innovation |
+|-------|------|-------------|------------|----------------|
+| **CodeBERT** | 2020 | Microsoft | 125M | Bimodal NL-PL pre-training |
+| **Codex** | 2021 | OpenAI | 12B | GPT-3 fine-tuned on GitHub |
+| **AlphaCode** | 2022 | DeepMind | 41B | Competitive programming |
+| **StarCoder** | 2023 | BigCode | 15B | Fill-in-the-middle, 1T tokens |
+| **CodeLlama** | 2023 | Meta | 34B | Llama 2 + code specialization |
+| **DeepSeek-Coder** | 2024 | DeepSeek | 33B | 2T token project-level training |
+| **Qwen2.5-Coder** | 2024 | Alibaba | 32B | 5.5T tokens, multi-language |
+
+## Benchmark Tracking
+
+```python
+# Track model performance on HumanEval
+humaneval_scores = {
+    "GPT-4": {"pass_at_1": 67.0, "pass_at_10": 86.0},
+    "Claude 3.5 Sonnet": {"pass_at_1": 64.0},
+    "DeepSeek-Coder-33B": {"pass_at_1": 56.1},
+    "CodeLlama-34B": {"pass_at_1": 48.8},
+    "StarCoder2-15B": {"pass_at_1": 46.3},
+    "GPT-3.5-Turbo": {"pass_at_1": 48.1},
+}
+
+print(f"{'Model':<25} {'pass@1':>8} {'pass@10':>8}")
+print("-" * 43)
+for model, scores in sorted(
+    humaneval_scores.items(),
+    key=lambda x: x[1].get("pass_at_1", 0),
+    reverse=True,
+):
+    p1 = scores.get("pass_at_1", "—")
+    p10 = scores.get("pass_at_10", "—")
+    print(f"{model:<25} {str(p1):>8} {str(p10):>8}")
+```
+
+## Research Directions
+
+```markdown
+### Active Areas (2024-2025)
+1. **Repository-level generation** — Understanding full codebases
+2. **Agentic coding** — LLMs using tools (debugger, terminal)
+3. **Formal verification** — Proving correctness of generated code
+4. **Multi-language** — Cross-language transfer and translation
+5. **Security** — Detecting and avoiding vulnerable code
+6. **Long context** — Processing large codebases (100k+ tokens)
+7. **Code editing** — Natural language instructions for code changes
+```
+
+## Paper Search
+
+```python
+import arxiv
+
+def find_code_llm_papers(topic="code generation", max_results=20):
+    """Find recent Code LLM papers on arXiv."""
+    query = f"abs:{topic} AND (abs:large language model OR abs:LLM)"
+
+    search = arxiv.Search(
+        query=query,
+        max_results=max_results,
+        sort_by=arxiv.SortCriterion.SubmittedDate,
+    )
+
+    for result in search.results():
+        print(f"[{result.published.strftime('%Y-%m-%d')}] "
+              f"{result.title}")
+
+find_code_llm_papers("code generation")
+find_code_llm_papers("automated program repair")
+```
+
+## Use Cases
+
+1. **Literature survey**: Map the Code LLM research landscape
+2. **Model selection**: Compare code models for specific tasks
+3. **Benchmark analysis**: Track state-of-the-art on standard benchmarks
+4. **Research planning**: Identify open problems and trends
+5. **Course material**: Teach software engineering + AI intersection
+
+## References
+
+- [Awesome-Code-LLM](https://github.com/codefuse-ai/Awesome-Code-LLM)
+- [TMLR Survey Paper](https://arxiv.org/abs/2311.07989)
+- [HumanEval](https://github.com/openai/human-eval)
+- [SWE-bench](https://www.swebench.com/)

package/skills/domains/cs/gaussian-splatting-papers-guide/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: gaussian-splatting-papers-guide
+description: "Curated papers and resources for 3D Gaussian Splatting"
+metadata:
+  openclaw:
+    emoji: "🔮"
+    category: "domains"
+    subcategory: "cs"
+    keywords: ["3D Gaussian Splatting", "3DGS", "neural rendering", "NeRF", "novel view synthesis", "point cloud"]
+    source: "https://github.com/MrNeRF/awesome-3D-gaussian-splatting"
+---
+
+# 3D Gaussian Splatting Papers Guide
+
+## Overview
+
+3D Gaussian Splatting (3DGS) is a breakthrough technique for real-time radiance field rendering that represents scenes as collections of 3D Gaussians. This curated collection tracks the rapidly evolving 3DGS literature — from the original paper through extensions for dynamic scenes, generation, compression, SLAM, avatars, and more. Essential for researchers in computer vision, graphics, and neural rendering.
+
+## Core Paper
+
+```bibtex
+@inproceedings{kerbl3Dgaussians,
+  title={3D Gaussian Splatting for Real-Time Radiance Field Rendering},
+  author={Kerbl, Bernhard and Kopanas, Georgios and Leimk{\"u}hler, Thomas
+          and Drettakis, George},
+  booktitle={ACM SIGGRAPH 2023},
+  year={2023}
+}
+```
+
+### Key Idea
+
+```
+Input: Multi-view images + SfM point cloud
+  ↓
+Initialize 3D Gaussians (position, covariance, color, opacity)
+  ↓
+Differentiable splatting (project Gaussians → image plane)
+  ↓
+Optimize via photometric loss
+  ↓
+Adaptive density control (clone, split, prune)
+  ↓
+Output: Real-time renderable 3D scene (100+ FPS)
+```
+
+## Research Landscape
+
+### Category Map
+
+| Category | Focus | Key Papers |
+|----------|-------|------------|
+| **Static Scenes** | Quality, compression, anti-aliasing | Mip-Splatting, Compact3D |
+| **Dynamic Scenes** | Deformable, 4D, temporal | Dynamic3DGS, 4DGS, Deformable3DGS |
+| **Generation** | Text/image to 3D | DreamGaussian, GaussianDreamer, LGM |
+| **SLAM** | Real-time mapping | SplaTAM, Gaussian-SLAM, MonoGS |
+| **Avatars** | Human body/face | GaussianAvatar, HUGS, SplatFace |
+| **Autonomous Driving** | Street scenes | StreetGaussians, DriveGS |
+| **Compression** | Storage efficiency | LightGaussian, CompGS |
+| **Editing** | Scene manipulation | GaussianEditor, GSEditor |
+| **Physics** | Simulation, deformation | PhysGaussian, Gaussian Splashing |
+| **Language** | 3D understanding | LangSplat, LEGaussians |
+
+## Tracking New Papers
+
+```python
+import requests
+from datetime import datetime, timedelta
+
+# Search arXiv for recent 3DGS papers
+def search_3dgs_papers(days_back=7):
+    """Find recent 3D Gaussian Splatting papers on arXiv."""
+    import arxiv
+
+    query = (
+        "ti:gaussian splatting OR "
+        "abs:3D gaussian splatting OR "
+        "abs:3DGS"
+    )
+
+    search = arxiv.Search(
+        query=query,
+        max_results=50,
+        sort_by=arxiv.SortCriterion.SubmittedDate,
+    )
+
+    cutoff = datetime.now() - timedelta(days=days_back)
+    papers = []
+    for result in search.results():
+        if result.published.replace(tzinfo=None) > cutoff:
+            papers.append({
+                "title": result.title,
+                "authors": [a.name for a in result.authors[:3]],
+                "url": result.entry_id,
+                "published": result.published.strftime("%Y-%m-%d"),
+                "categories": result.categories,
+            })
+    return papers
+
+recent = search_3dgs_papers(days_back=14)
+for p in recent:
+    print(f"[{p['published']}] {p['title']}")
+    print(f"  {', '.join(p['authors'])} | {p['url']}")
+```
+
+## Key Methods Comparison
+
+```python
+# Performance comparison (from original benchmarks)
+methods = {
+    "NeRF": {"psnr": 31.01, "fps": 0.03, "train_time": "hours"},
+    "Instant-NGP": {"psnr": 33.18, "fps": 9.43, "train_time": "5 min"},
+    "3DGS": {"psnr": 33.31, "fps": 134, "train_time": "6 min"},
+    "Mip-Splatting": {"psnr": 33.46, "fps": 120, "train_time": "7 min"},
+}
+
+print(f"{'Method':<16} {'PSNR':>6} {'FPS':>8} {'Training':>10}")
+print("-" * 44)
+for name, m in methods.items():
+    print(f"{name:<16} {m['psnr']:>6.2f} {m['fps']:>8.2f} "
+          f"{m['train_time']:>10}")
+```
+
+## Implementation Resources
+
+```bash
+# Original implementation
+git clone https://github.com/graphdeco-inria/gaussian-splatting
+cd gaussian-splatting
+pip install -r requirements.txt
+
+# Train on custom scene
+python train.py -s path/to/colmap/data
+
+# Real-time viewer
+./SIBR_viewers/bin/SIBR_gaussianViewer_app \
+  -m output/trained_model
+```
+
+## Survey Papers
+
+1. **"A Survey on 3D Gaussian Splatting"** (Chen et al., 2024) — comprehensive taxonomy
+2. **"3DGS: Recent Developments and Applications"** (Wu et al., 2024) — application-focused
+3. **"Gaussian Splatting: A Survey"** (Fei et al., 2024) — technical deep dive
+
+## Use Cases
+
+1. **Novel view synthesis**: Photo-realistic rendering from sparse views
+2. **Real-time visualization**: Interactive 3D scene exploration
+3. **Digital twins**: Rapid scene reconstruction for simulation
+4. **VR/AR content**: Real-time immersive experiences
+5. **Autonomous driving**: Street-level scene understanding
+
+## References
+
+- [awesome-3D-gaussian-splatting](https://github.com/MrNeRF/awesome-3D-gaussian-splatting)
+- [Original 3DGS](https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/)
+- [3DGS Papers Collection](https://3dgaussians.github.io/)