{"slug": "gaussiangpt-generating-3d-scenes-autoregressively-with-gaussian-splatting", "title": "GaussianGPT: Generating 3D scenes autoregressively with Gaussian Splatting", "summary": "Researchers from the Technical University of Munich introduced GaussianGPT, a transformer-based model that generates 3D scenes autoregressively via next-token prediction on Gaussian splatting tokens, accepted as an oral presentation at ECCV 2026. The model compresses 3D Gaussians into discrete tokens using a sparse 3D convolutional VQ-VAE and generates scenes step-by-step, supporting completion, outpainting, and controllable sampling. The full training and inference code, along with pre-trained checkpoints, were released on GitHub.", "body_md": "**Nicolas von Lützow · Barbara Rössle · Katharina Schmid · Matthias Nießner**\n\n[Project Page](https://nicolasvonluetzow.github.io/GaussianGPT/) · [arXiv](https://arxiv.org/abs/2603.26661) · [Paper](https://arxiv.org/pdf/2603.26661) · [Video](https://youtu.be/zVnMHkFzHDg)\n\nMost recent advances in 3D generative modeling rely on diffusion or flow-matching formulations. We instead explore a fully autoregressive alternative and introduce GaussianGPT, a transformer-based model that directly generates 3D Gaussians via next-token prediction, thus facilitating full 3D scene generation. We first compress Gaussian primitives into a discrete latent grid using a sparse 3D convolutional autoencoder with vector quantization. The resulting tokens are serialized and modeled using a causal transformer with 3D rotary positional embedding, enabling sequential generation of spatial structure and appearance. Unlike diffusion-based methods that refine scenes holistically, our formulation constructs scenes step-by-step, naturally supporting completion, outpainting, controllable sampling via temperature, and flexible generation horizons. This formulation leverages the compositional inductive biases and scalability of autoregressive modeling while operating on explicit representations compatible with modern neural rendering pipelines, positioning autoregressive transformers as a complementary paradigm for controllable and context-aware 3D generation.\n\n**2026-08-05**- GaussianGPT selected for an oral presentation!** 2026-07-12**- Object-level (PhotoShape)[checkpoints](#checkpoints)released.** 2026-07-02**- Camera-ready paper now available on[arXiv](https://arxiv.org/abs/2603.26661).** 2026-07-01**- Pre-trained scene-level VQ-VAE and GPT[checkpoints](#checkpoints)released.** 2026-06-19**- Training and inference code released.** 2026-06-18**- GaussianGPT accepted to ECCV 2026!\n\nThis repository contains the full training and inference code for GaussianGPT. The pipeline is two trained models connected by a tokenization step:\n\n**VQ-VAE**(`train_ae.py`\n\n) — a sparse 3D CNN with vector quantization that compresses per-voxel Gaussians into discrete tokens, supervised by a`gsplat`\n\nre-rendering loss.**Tokenization**(`tokenize_dataset.py`\n\n) — runs the trained encoder over the dataset and writes per-scene token streams to disk.**GPT**(`train_gpt.py`\n\n) — an autoregressive transformer with 3D rotary embeddings that models the token streams via next-token prediction.**Inference**— sample from the GPT and decode through the frozen VQ-VAE to generate, complete, or tile Gaussian scenes, then render them.\n\n``` php\nGaussians --VQ-VAE--> tokens --GPT--> sampled tokens --decode--> Gaussians --render-->\n```\n\nEverything is configured with [Hydra](https://hydra.cc/); override any field on\nthe CLI as `key=value`\n\n.\n\nIf you find GaussianGPT useful, please consider citing:\n\n```\n@inproceedings{vonluetzow2026gaussiangpt,\n  title     = {GaussianGPT: Towards Autoregressive 3D Gaussian Scene Generation},\n  author    = {von L{\\\"u}tzow, Nicolas and R{\\\"o}{\\ss}le, Barbara and Schmid, Katharina and Nie{\\ss}ner, Matthias},\n  booktitle = {European Conference on Computer Vision (ECCV)},\n  year      = {2026},\n}\n```\n\nThe environment is built around CUDA 12.9 and PyTorch 2.8. Several dependencies are compiled from source, so make sure a GPU is visible during installation for correct CUDA support.\n\nSet the target architectures before any from-source build. Refer to the\n[NVIDIA GPU feature list](https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#gpu-feature-list)\nfor your hardware.\n\n```\nexport TORCH_CUDA_ARCH_LIST=\"8.6;8.0\"   # e.g. Ampere (3090, A6000, A100)\nconda create -n gaussiangpt python=3.10 nvidia::cuda-toolkit=12.9 conda-forge::glm ninja\nconda activate gaussiangpt\n\n# Point CUDA_HOME at the conda toolkit (persist for future sessions and apply now).\nln -s \"$CONDA_PREFIX/lib\" \"$CONDA_PREFIX/lib64\"\nconda env config vars set CUDA_HOME=\"$CONDA_PREFIX\"\nexport CUDA_HOME=\"$CONDA_PREFIX\"\n\npip install torch==2.8.0 torchvision torchaudio --index-url https://download.pytorch.org/whl/cu129\npip install --no-build-isolation -r requirements.txt   # compiles several extensions; slow\n```\n\n`requirements.txt`\n\ninstalls two CUDA extensions from pinned git commits that are\n**compiled from source** during this step (hence the GPU-visible requirement and\nthe long build time): [ gsplat](https://github.com/nerfstudio-project/gsplat)\n(the re-rendering loss / renderer) and\n\n[(rotation/quaternion ops in](https://github.com/facebookresearch/pytorch3d)\n\n`pytorch3d`\n\n`utils/transforms.py`\n\n). If the install fails, it is almost always one of\nthese two — build them individually to see the full nvcc error, and make sure\n`TORCH_CUDA_ARCH_LIST`\n\nand `CUDA_HOME`\n\nare set as above.\n\n```\ngit clone https://github.com/Dao-AILab/flash-attention.git\ncd flash-attention\ngit checkout v2.8.2\nMAX_JOBS=4 python setup.py install\n```\n\n## Troubleshooting: `MAX_JOBS=1`\n\nEach nvcc job needs several GB of RAM. Start `MAX_JOBS`\n\nlow and raise it only if\nyou have the RAM to spare; lower it (down to 1) if the build OOMs / gets \"Killed\".\n\n## Optional: `FLASH_ATTN_CUDA_ARCHS=80`\n\nflash-attn compiles its own arch set (sm_80;90;100;120) and ignores\n`TORCH_CUDA_ARCH_LIST`\n\n. Its Ampere kernels are sm_80, which also run on sm_86\n(3090/A6000) via same-major forward-compat, so restricting to sm_80 covers all\nthe target GPUs above and cuts both compile time and per-job RAM substantially.\n\nThe upstream MinkowskiEngine does not build against CUDA 12 without source\npatches. The [alpsaur fork](https://github.com/alpsaur/MinkowskiEngine/tree/cuda12-compat)\nbundles the CUDA 12 fixes, so no manual patching is needed:\n\n```\ngit clone https://github.com/alpsaur/MinkowskiEngine.git --branch cuda12-compat\ncd MinkowskiEngine\nconda install -c conda-forge \"blas=*=openblas\" openblas openblas-devel\npython setup.py install --blas_include_dirs=\"${CONDA_PREFIX}/include\" --blas=openblas\n```\n\n## Compiler note: build with GCC <= 13\n\nMinkowskiEngine does not compile with **GCC >= 14** against PyTorch 2.8's bundled\npybind11 — you'll hit `ambiguous template instantiation`\n\nerrors on the `enum_`\n\nregistrations. Use **GCC <= 13** (GCC 11 is known good). The `openblas-devel`\n\ninstall above can pull a newer GCC from conda-forge into the env, so after running\nit check `${CXX} --version`\n\n; if it reports 14+, pin an older toolchain and\nreactivate so conda repoints `CC`\n\n/`CXX`\n\nbefore building:\n\n```\nconda install -c conda-forge gcc_linux-64=11 gxx_linux-64=11\nconda deactivate && conda activate gaussiangpt   # reactivate to refresh CC/CXX\n```\n\nIf conda balks at re-solving `cuda-toolkit`\n\n, pin it explicitly and freeze the\nrest: `conda install -c nvidia -c conda-forge cuda-toolkit=12.9.2 gcc_linux-64=11 gxx_linux-64=11 --freeze-installed`\n\n.\n\n## Alternative: official repo with manual patches\n\nClone upstream and apply the CUDA 12 source patches yourself, following\n[issue #543](https://github.com/NVIDIA/MinkowskiEngine/issues/543#issuecomment-1773458776):\n\n```\ngit clone https://github.com/NVIDIA/MinkowskiEngine.git\ncd MinkowskiEngine\n# Apply the CUDA 12 source patches from the issue above before building.\nconda install -c conda-forge \"blas=*=openblas\" openblas openblas-devel\npython setup.py install --blas_include_dirs=\"${CONDA_PREFIX}/include\" --blas=openblas\n```\n\n## Optional: per-voxel dedup (`torch_scatter`\n\n)\n\nNot required for the default pipeline. Only needed if you enable\n`model.make_unique=true`\n\n(collapse each voxel to its highest-opacity Gaussian),\nwhich is **off** in the shipped configs. The import is lazy, so the dependency is\nonly touched when that option is turned on. In our tests it gave a negligible\nquality gain for the added compute.\n\n```\npip install --no-build-isolation torch-scatter -f \"https://data.pyg.org/whl/torch-2.8.0+cu129.html\"\n```\n\nWe are grateful to the authors of the following datasets, whose data made this work possible. Please refer to the respective sources for licensing and download instructions.\n\n| Dataset | Source data | Gaussians |\n|---|---|---|\n| PhotoShape |\n|\n\n[original data](https://www.projectaria.com/datasets/ase/)[SceneSplat-49k](https://huggingface.co/datasets/GaussianWorld/aria_synthetic_envs_mcmc_3dgs_new)[original data](https://tianchi.aliyun.com/specials/promotion/alibaba-3d-scene-dataset)(no longer available)## 3D-FRONT availability\n\nThe original source data is no longer available, but more recent re-releases (e.g.\n[this one](https://huggingface.co/datasets/huanngzh/3D-Front)) should work similarly.\n\n## Data format\n\n**PhotoShape**— standard Inria-style 3DGS`.ply`\n\nfiles (y-up).**3D-FRONT**— PyTorch dicts; easiest to follow the data-loading code directly. The dicts hold the default 3DGS attributes, but split position into`anchor`\n\n(3D anchor positions) and`offset`\n\n.`f_dc`\n\n/`f_rest`\n\nhold the SH coefficients; all other attributes are stored**pre-activation**(logits).\n\n## Voxel-GS preprocessing\n\nVoxel-GS is the simplified [Scaffold-GS](https://city-super.github.io/scaffold-gs/) from\n[L3DG](https://barbararoessle.github.io/l3dg/) — no MLP, one Gaussian per voxel, no hierarchy.\n\n**PhotoShape**— L3DG Voxel-GS as-is (paper Secs. 3.2.1, 3.4).** 3D-FRONT**— same, with: point cloud from back-projected depth maps; no scene normalization; 2.5 cm voxels; anchor densification off; 60k iterations; SH degree capped at 1; scales bounded by`2 * voxel_size * sigmoid()`\n\n.\n\nTraining is a two-stage pipeline (VQ-VAE, then GPT) with a tokenization step in\nbetween. Checkpoints and logs land under `experiment.log_dir`\n\n(`logs/`\n\nby\ndefault), organized by `experiment.name`\n\n.\n\nThe dataset configs reference scene-name lists under `data_splits/`\n\n. Two\nstandalone helpers under `scripts/`\n\nbuild them in two steps — scan once to\nproduce a per-scene stats CSV, then filter that CSV into train/val splits\n(re-run the cheap second step with different thresholds without re-scanning):\n\n```\npython scripts/dataset_quick_stats.py \\\n    --data-root <gaussians_root> --transforms-root <transforms_root> \\\n    --output logs/stats.csv\n\npython scripts/dataset_split_from_quick_stats.py \\\n    --input logs/stats.csv \\\n    --train-split data_splits/train.txt --val-split data_splits/val.txt \\\n    --min-images 100 --max-points 5000000 \\\n    --min-extent-x 3.2 --max-extent-x 25 \\\n    --min-extent-y 3.2 --max-extent-y 25 --max-extent-z 4\n```\n\nAll filters default to off; pass `--help`\n\non either script for the full set.\n\nTrains the sparse-CNN autoencoder with vector quantization that compresses\nper-voxel Gaussians into discrete tokens. Reconstruction is supervised by a\nre-rendering loss (`gsplat`\n\n).\n\n```\npython train_ae.py \\\n    data=vfront_houses \\\n    experiment.name=my_vqvae\n```\n\n- Top-level config:\n`conf/vqvae.yaml`\n\n(`data=vfront_houses`\n\n,`model=vqvae_cnn`\n\n,`training=vqvae`\n\n). Swap the dataset with`data=photoshape`\n\n,`data=ase`\n\n,`data=spp_v2`\n\n, etc. - Loss weights live in\n`conf/training/vqvae.yaml`\n\n; the defaults target VFront/ASE, and the file notes the PhotoShape overrides. - PhotoShape additionally needs\n`model=vqvae_photoshape`\n\n(finer voxels, view-dependent color). The training overrides are listed at the top of that config. `max_epochs`\n\nis a deliberate overestimate — stop the run by picking a checkpoint rather than waiting for it to finish.- Resume with\n`experiment.checkpoint_path=<ckpt> experiment.continue_mode=resume`\n\n(or`weights_only`\n\nto load only the weights and reset the optimizer/scheduler).\n\nRuns the trained VQ-VAE encoder over the dataset and writes per-scene token\nstreams to disk. The output directory becomes `data.data_path`\n\nfor the GPT\nstage, and the VQ-VAE checkpoint becomes `data.vqvae_path`\n\n.\n\n```\npython tokenize_dataset.py \\\n    data=vfront_houses \\\n    experiment.checkpoint_path=<vqvae.ckpt> \\\n    training.tokenization.output_dir=<tokens_dir>\n```\n\n- Shares the\n`conf/vqvae.yaml`\n\nconfig; only`experiment.checkpoint_path`\n\nand`training.tokenization.output_dir`\n\nare required (both are asserted at startup). `training.tokenization.sort_by`\n\ncontrols latent ordering;`training.tokenization.generate_augmented_samples=true`\n\nwrites 8 variants per scene (4 z-rotations x mirrored/not).\n\nTrains the autoregressive transformer prior over the VQ tokens. The frozen\nVQ-VAE is loaded from `data.vqvae_path`\n\nand used only for decoding during the\ninline evaluation.\n\n```\npython train_gpt.py \\\n    data=tokenized_vfront \\\n    data.data_path=<tokens_dir> \\\n    data.vqvae_path=<vqvae.ckpt> \\\n    experiment.name=my_gpt\n```\n\n- Top-level config:\n`conf/gpt.yaml`\n\n(`data=tokenized_vfront`\n\n,`model=gpt`\n\n,`training=gpt`\n\n). Use`data=tokenized_vfront_ase`\n\nfor the combined VFront+ASE model.`data_path`\n\nand`vqvae_path`\n\nare required (`???`\n\n) in the tokenized data configs and must be supplied. - For the object-level model use\n`data=tokenized_photoshape model=gpt_photoshape`\n\n(GPT-2-small on a 32^3 grid). - Transformer size is set inline via the\n`gpt_size`\n\nblock in`conf/model/gpt.yaml`\n\n(`n_embd`\n\n,`n_layer`\n\n,`n_head`\n\n,`n_kv_head`\n\n). The default (`n_embd=1024`\n\n,`n_layer=24`\n\n) matches GPT-2-medium. - Multi-GPU is auto-detected: the run uses\n`ddp`\n\nwhen more than one GPU is visible. - Evaluation runs\n**inline** via`EvaluateCallback`\n\n, cadenced by`training.output.render_frequency`\n\n.`training.output.eval_data_config`\n\nselects which raw`conf/data/*.yaml`\n\nis composed for the rendering. `experiment.continue_run=true`\n\nauto-finds the latest checkpoint from a prior run with the same`log_dir`\n\n/`name`\n\n.\n\nPre-trained VQ-VAE and GPT checkpoints are hosted at\n`kaldir.vc.cit.tum.de/gaussiangpt`\n\n(sizes and SHA256 checksums in the served\n[README](https://kaldir.vc.cit.tum.de/gaussiangpt/README.md)). Each GPT must be\npaired with the VQ-VAE listed alongside it.\n\n```\n# Trained on 3D-FRONT\nwget https://kaldir.vc.cit.tum.de/gaussiangpt/vqvae_vfront.ckpt\nwget https://kaldir.vc.cit.tum.de/gaussiangpt/gpt_vfront.ckpt\n\n# Pre-trained on 3D-FRONT + ASE, fine-tuned on 3D-FRONT\nwget https://kaldir.vc.cit.tum.de/gaussiangpt/vqvae_both.ckpt\nwget https://kaldir.vc.cit.tum.de/gaussiangpt/gpt_both.ckpt\n\n# Trained on PhotoShape (object-level)\nwget https://kaldir.vc.cit.tum.de/gaussiangpt/vqvae_photoshape.ckpt\nwget https://kaldir.vc.cit.tum.de/gaussiangpt/gpt_photoshape.ckpt\n```\n\nPass them to any inference entry point as `checkpoint=<gpt.ckpt> vqvae_checkpoint=<vqvae.ckpt>`\n\n(see [Inference](#inference)).\n\nAll inference entry points take the trained GPT via `checkpoint=<gpt.ckpt>`\n\nand\nneed a VQ-VAE checkpoint to decode sampled tokens. The VQ-VAE is resolved as\n`vqvae_checkpoint=<vqvae.ckpt>`\n\n(explicit override) → `model.vqvae.checkpoint_path`\n\n→ `data.vqvae_path`\n\nfrom a composed `data=<cfg>`\n\n. The token streams\n(`data.data_path`\n\n) are only read when conditioning on real scenes (completion);\nunconditional sampling does not touch them.\n\nSamples one chunk per scene, decodes through the VQ-VAE, and renders camera\ntrajectories. This module also provides the inline helpers imported by\n`train_gpt.py`\n\n. For object-level models (PhotoShape) a chunk is a whole object,\nso this is the full object-generation pipeline; the completion and multi-chunk\nentry points below are scene-level.\n\n```\n# Unconditional generation: only the GPT and a VQ-VAE checkpoint are needed.\npython generate_chunks.py \\\n    checkpoint=<gpt.ckpt> \\\n    vqvae_checkpoint=<vqvae.ckpt> \\\n    num_samples=4 temperature=1.0\n```\n\nKey options (see `conf/generate_chunks.yaml`\n\n, the config `generate_chunks.py`\n\nloads):\n`num_samples`\n\n, `batch_size`\n\n, `temperature`\n\n/`top_k`\n\n/`top_p`\n\n, `seed`\n\n,\n`store_samples`\n\n, `render_gifs`\n\n(set `render_gifs=false`\n\nto skip GIF rendering,\ne.g. to only dump samples via `store_samples=true`\n\n). Outputs go to `output_dir`\n\n(`outputs/eval`\n\nby default).\n\n## Prompt-conditioned completion (sequence-prefix sanity check)\n\n`generate_chunks.py`\n\ncan also condition on a real scene by enabling\n`completion`\n\n: it keeps the first `prompt_fraction`\n\nof the token sequence and\ncontinues it, producing one completion per scene. This is a quick sanity check\non the prior, used primarily during training. For completion cut by **spatial\nextent**, use `complete_chunks.py`\n\nbelow.\n\n```\npython generate_chunks.py \\\n    checkpoint=<gpt.ckpt> \\\n    data=tokenized_vfront \\\n    data.data_path=<tokens_dir> data.vqvae_path=<vqvae.ckpt> \\\n    completion.enabled=true completion.prompt_fraction=0.5\n```\n\nThe prompts are read from the tokenized `data=<cfg>`\n\n(`completion.split`\n\nselects train/val); `prompt_fraction`\n\nis a continuous float (default 0.5).\n\nConditions on part of a scene and samples the rest — the autoregressive analogue\nof inpainting/outpainting. The prompt is cut by **spatial extent** (e.g. keep\nhalf the room along x) rather than by sequence length, and several completions\nare sampled per scene.\n\n```\npython complete_chunks.py \\\n    checkpoint=<gpt.ckpt> \\\n    data=tokenized_vfront \\\n    data.data_path=<tokens_dir> data.vqvae_path=<vqvae.ckpt> \\\n    prompt_mode=spatial_half_x\n```\n\nKey options (see `conf/complete_chunks.yaml`\n\n): `split`\n\n, `prompt_mode`\n\n,\n`num_completions`\n\n, `num_samples`\n\n, the\nsampling params, and `render_gifs`\n\n/`store_tokens`\n\n. Supports sharding via\n`shard_id`\n\n/`num_shards`\n\n. Outputs go to `outputs/complete_chunks`\n\n.\n\n`generate_scene.py`\n\nautoregressively tiles many chunks into a large scene, then\n`decode_scene.py`\n\nturns the saved token sidecars into renderable Gaussian\npayloads. `generate_scene.py`\n\nshards over the tile grid via the `GAUSS_SHARD_ID`\n\n/ `GAUSS_NUM_SHARDS`\n\nenv vars, so it runs cleanly as a SLURM array — each task\nonly reads/writes its own `rank_XXXX`\n\nshard.\n\n```\n# Sample (single shard shown; for a SLURM array set the two env vars per task).\nGAUSS_SHARD_ID=0 GAUSS_NUM_SHARDS=1 python generate_scene.py \\\n    checkpoint=<gpt.ckpt> \\\n    vqvae_checkpoint=<vqvae.ckpt> \\\n    num_scenes=4 output_dir=<scene_out>\n\n# Decode the token sidecars into Gaussian scenes.\npython decode_scene.py \\\n    --output-dir <scene_out> \\\n    --vqvae-checkpoint <vqvae.ckpt>\n```\n\n`generate_scene.py`\n\ncan decode and render top-down inline (`decode_outputs`\n\n,\n`render_topdown`\n\n, both on by default); see `conf/generate_scene.yaml`\n\nfor the\ntiling (`scene_cols_x/y`\n\n), the bootstrap/outpainting sampling params, and the\nempty-column handling. `decode_scene.py`\n\ninfers the GPT checkpoint from the run\nmanifest, so only `--output-dir`\n\nand `--vqvae-checkpoint`\n\nare required.\n\nStandalone renderers operate on decoded scene `.pt`\n\npayloads (keys `coords`\n\n,\n`sh0`\n\n, `opacities`\n\n, `scales`\n\n, `quats`\n\n, plus optional `sh`\n\nwith higher-order SH\ncoefficients, rendered when present):\n\n```\n# Single top-down PNG.\npython render_topdown.py --input <scene.pt> --quantile 75 --resolution 1024\n\n# Rotating-orbit GIFs for one scene or a directory of scenes.\npython render_orbit_batch.py --input <scene_or_dir> --output-dir <render_out>\n\n# Object samples (PhotoShape) are y-up; keep the full object and orbit from outside.\npython render_topdown.py --input <sample.pt> --up y --quantile 100\npython render_orbit_batch.py --input <samples_dir> --output-dir <render_out> --up y --move-back 1.75\n```\n\nPayloads keep their dataset's native up axis: 3D-FRONT/ASE are z-up (the\ndefault), PhotoShape is y-up (pass `--up y`\n\nto rotate before rendering).\n`render_topdown.py`\n\ndrops points above `--quantile`\n\n(to see through ceilings;\nuse `--quantile 100`\n\nto keep whole objects).\n`render_orbit_batch.py`\n\naccepts a single `.pt`\n\nor\na directory (`--max-files`\n\ncaps how many it processes) and writes per-frame\nimages plus a GIF under `--output-dir`\n\n. Its default `--move-back`\n\norbits from\ninside a room; use ~1.5-3 to orbit around an object.\n\nTo inspect a payload in an external viewer, `scripts/convert_pt_to_ply.py`\n\nconverts a Gaussian `.pt`\n\n/`.pth`\n\npayload to an INRIA-style `.ply`\n\n.\n\nThis work would not have been possible without the following open-source projects, and we thank their authors and contributors.\n\nThis project is released under the MIT License. See [LICENSE](/nicolasvonluetzow/GaussianGPT/blob/main/LICENSE) for details.", "url": "https://wpnews.pro/news/gaussiangpt-generating-3d-scenes-autoregressively-with-gaussian-splatting", "canonical_source": "https://github.com/nicolasvonluetzow/GaussianGPT", "published_at": "2026-08-29 06:43:40+00:00", "updated_at": "2026-08-29 07:18:10.702444+00:00", "lang": "en", "topics": ["artificial-intelligence", "machine-learning", "generative-ai", "computer-vision", "ai-research"], "entities": ["Technical University of Munich", "GaussianGPT", "ECCV 2026", "VQ-VAE", "PyTorch", "CUDA", "Hydra", "gsplat"], "alternates": {"html": "https://wpnews.pro/news/gaussiangpt-generating-3d-scenes-autoregressively-with-gaussian-splatting", "markdown": "https://wpnews.pro/news/gaussiangpt-generating-3d-scenes-autoregressively-with-gaussian-splatting.md", "text": "https://wpnews.pro/news/gaussiangpt-generating-3d-scenes-autoregressively-with-gaussian-splatting.txt", "jsonld": "https://wpnews.pro/news/gaussiangpt-generating-3d-scenes-autoregressively-with-gaussian-splatting.jsonld"}}