GaussianCity is an efficient borderless 3D city generation framework proposed by Nanyang Technological University's S-Lab. It is based on 3D Gaussian splattering (3D-GS) and compact BEV-Point representation. Compared with CityDreamer, it is 60 times faster, has constant memory consumption, and supports urban scene generation from drone and street view perspectives.

GaussianCity’s 3D city generation framework

Core parameters and statistics

Project	Details
Product Name	GaussianCity
Product Type	3D Generative Framework (Academic Research)
Delivery Form	Open Source Code (Python + CUDA)
Core Technology	3D Gaussian Splatting, BEV-Point
Paper Conference	CVPR 2025
GitHub Stars	336 (as of mid-2025)
Development Team	Nanyang Technological University S-Lab
Open Source License	NTU S-Lab License 1.0
Supported platforms	Linux (requires NVIDIA GPU + CUDA)

The core breakthrough of GaussianCity is to expand 3D-GS from limited-scale object/human body generation to infinite-scale 3D city generation. Traditional approaches such as CityDreamer face memory explosion issues in large-scale scenarios - a 10km² city requires hundreds of GB of VRAM. GaussianCity completely breaks this bottleneck by maintaining graphics memory consumption at a constant level through BEV-Point compact representation. In terms of inference speed, GaussianCity reaches 10.72 FPS, which is 60 times that of CityDreamer (0.18 FPS), which is a qualitative leap.

User and market recognition

GaussianCity was included in CVPR 2025 and is a cutting-edge research result in the field of 3D generation. Its Hugging Face online demonstration was rated as Top 8 Spaces in the 11th week of 2025, and later rose to Top 1 Space, indicating that it has received widespread attention in both academia and industry. The GitHub repository received 336 stars and 19 Forks, and its community activity is outstanding among similar CVPR paper implementations.

This work was continued by the same team of CityDreamer (NTU S-Lab), and the follow-up work CityDreamer4D has a public page, indicating that this technical route has continued research vitality.

Cost advantage

GaussianCity is a completely open source academic research project with no payment threshold:

Cost Dimension	Description
Open source code	GitHub repository is fully public, based on NTU S-Lab License 1.0
Pre-trained model	Provides pre-trained weights for Background Generator and Building Generator
Online experience	Hugging Face Spaces provides free online demo
Hardware cost	You need to bring your own NVIDIA GPU (CUDA 11.8+), 8×GPU multi-card configuration is recommended for training

For researchers and developers, the real cost lies in the hardware investment. Training Background Generator recommends torchrun --nnodes=1 --nproc_per_node=8 for multi-card configuration. Single-card inference requires a GPU with at least 8GB VRAM. This is a conventional configuration in the field of large model/AIGC research, but the threshold is higher for individual enthusiasts.

Main functions

• Borderless 3D city generation: Supports diverse urban scene generation from a drone's bird's-eye view to a street view. The scene scale is not limited by video memory and can theoretically reach any city size.
• BEV-Point Compact Representation: Decompose points in the 3D scene into position attributes and style attributes, and implement compression through Bird's Eye View and style lookup tables, so that VRAM consumption does not increase with the scene size.
• Spatial-aware BEV-Point Decoder: Based on Point Serializer and Point Transformer, it captures the structural and contextual relationships between BEV points and generates high-quality 3D Gaussian attributes.
• Dual Generator Architecture: The Background Generator is responsible for background elements such as the sky and the ground, and the Building Generator focuses on the generation of buildings. The two work together to complete a complete urban scene.
• Real-time rendering and interaction: An efficient rasterization pipeline based on 3D-GS supports real-time rendering; Hugging Face Demo provides an online interactive experience.

Model and version evolution

Version	Date	Description
Warehouse creation	2024-05-24	Initial warehouse creation, the code has not yet been made public
Training/test code release	2025-02-27	Complete training and inference code, pre-training weights release
Hugging Face Demo	2025-03-02	Online Demo launched, won Top 8 Spaces (Week 11), and subsequently rose to Top 1
CVPR 2025 included	2025-06	The paper was accepted by CVPR 2025 and officially published

GaussianCity's version history is clear: from the initialization of the warehouse in May 2024 to the complete open source code in February 2025, to the launch of Hugging Face Demo in March and received high popularity from the community, the overall rhythm is compact. The paper's inclusion in CVPR 2025 means that the work has passed peer review at the top conference. The code is currently still under maintenance, and an enhanced version may be launched based on the same technical route in the future (refer to the CityDreamer4D of the same team).

Technical advantages

GaussianCity’s technological leadership is reflected in three levels:

• BEV-Point Compact Representation: The core innovation lies in decomposing 3D scene points into position attributes and style attributes, and achieving constant graphics memory consumption through BEV space quantization + style lookup table. Compared with CityDreamer's voxel/grid representation, BEV-Point avoids the exponential growth of graphics memory when the scene scale is expanded, making it possible to generate a 10km² level city.
• 60x speed improvement: In the same scenario, GaussianCity's inference speed reaches 10.72 FPS, while CityDreamer only has 0.18 FPS. The speed advantage comes from 3D-GS’s GPU-efficient rasterization pipeline + BEV-Point’s compact data structure. The combination of the two significantly reduces the rendering cost of each frame.
• Spatial Aware Decoder: The architectural design of Point Serializer + Point Transformer enables the spatial context between BEV points to be effectively captured, avoiding geometric inconsistencies caused by independent point generation, making the output city layout reasonable and rich in architectural details.

How to use

GaussianCity provides three ways to use it:

Entry	Type	Description
GitHub source code	Self-deployment	Clone repository → Install dependencies → Download pre-trained model → Run inference
Hugging Face Demo	Online experience	Open the browser and use it directly, without any installation configuration
Paper/Project page	References	arXiv papers, project introductions, Citation, etc.

Get started quickly with local deployment

# 1. Clone the repository
git clone https://github.com/hzxie/GaussianCity
cd GaussianCity

# 2. Install PyTorch (CUDA 11.8 example)
pip install torch==2.4.1 torchvision==0.19.1 --index-url https://download.pytorch.org/whl/cu118

# 3. Install Python dependencies
pip install -r requirements.txt

# 4. Compile CUDA extension
GCITY_HOME=`pwd`
cd $GCITY_HOME/extensions
for e in `ls -d */`
do
  cd $GCITY_HOME/extensions/$e
  pip install .
done

# 5. Download the pre-trained model to the output/ directory and run inference
python3 scripts/inference.py

Note: The inference speed is limited by the CPU-side footprint_extruder in inference.py. If you need the fastest performance, please use the GPU implementation of Hugging Face Demo.

Hugging Face online experience

Visit https://huggingface.co/spaces/hzxie/gaussian-city to experience it directly without any configuration.

Product Pricing

GaussianCity is a completely open source academic project, released based on the NTU S-Lab License 1.0 agreement, without any charging plan:

• Open source code: GitHub repository is completely open and free to use.
• Pre-trained model: Background Generator and Building Generator weights free download.
• Online Demo: Free trial of Hugging Face Spaces.
• Commercial License: Based on NTU S-Lab License 1.0, commercial use must comply with the terms of the agreement. It is recommended to consult the NTU team.

The actual cost comes mainly from hardware:

• Single card inference: minimum 8GB VRAM GPU (16GB+ recommended)
• Complete training: 8×GPU multi-card cluster recommended (A100 or equivalent)

Application scenarios

• Games and Virtual Reality: Quickly generate realistic and borderless 3D city contexts for use in open-world game VR roaming and other scenarios, significantly reducing manual modeling costs.
• Film and TV Animation Production: Efficiently generate complex urban scenes as background or special effects materials, support stylized rendering, and improve the efficiency of the production pipeline.
• Urban Planning and Architectural Design: Quickly convert GIS data into 3D visualization scenes to assist urban layout planning, building block elaboration and design plan display.
• Autonomous Driving Simulation: Generate diversified realistic urban traffic scenes for perception and planning testing of autonomous driving algorithms, supplementing long-tail situations that are difficult to cover with conventional simulation data sets.
• Geographic Information System (GIS): Automatically upgrade 2D geographical data to 3D city models, supporting early visual verification of applications such as digital twins and smart cities.

Applicable people

• Computer Vision/AIGC Researcher: GaussianCity provides a cutting-edge baseline of 3D-GS generation at the urban scale, suitable for use as a starting point for comparison of methods or further improvements.
• Game and Film and Television Developers: Technical artists and developers who need to quickly generate urban background assets in batches can use open source code and pre-trained models to accelerate the asset pipeline.
• Autonomous Driving Simulation Engineer: Engineers who need diverse urban scene data for algorithm verification can generate supplementary training data based on GaussianCity.
• Not applicable to people:
  • Individual users who lack GPU computing power (no NVIDIA GPU or VRAM < 8GB) are not recommended to try local deployment.
  • Not suitable for scenarios that require instant commercial-grade SaaS products (one-click generation, no coding required) - GaussianCity is a research framework, and its use requires a Python/CUDA foundation.
  • Expecting the output of structured city data (buildings, roads, traffic flows with semantic tags) - GaussianCity generates visual renderings, not GIS structured data.

Summary and Outlook

GaussianCity is an important breakthrough in 3D city generation. It expands the capabilities of 3D-GS from limited-scale objects/human bodies to infinite-scale city-level scenes, and solves the memory bottleneck problem that has long plagued the field through BEV-Point compact representation. The 60x speed increase and the endorsement of CVPR 2025 make it an unavoidable baseline method in this direction.

However, GaussianCity is positioned as a research framework rather than a mass production tool: it requires a GPU-enabled Python programming foundation and an understanding of the 3D-GS technology stack. The current version is mainly for researchers and developers with technical capabilities, and there is currently no direct commercial SaaS version.

Procurement/Adoption Risk Assessment: For individual enthusiasts, the hardware threshold (NVIDIA GPU + CUDA + at least 8GB VRAM) is the largest hidden investment. For enterprise users, the commercial terms of NTU S-Lab License 1.0 need to be reviewed carefully. It is recommended to confirm the scope of authorization with the NTU team before commercial use. The project is currently maintained by an individual researcher (Haozhe Xie). The long-term iteration rhythm depends on the continued investment of the academic team, and there is a certain degree of uncertainty. It is recommended to use GaussianCity as a research verification or rapid prototyping tool. Production-level scenarios still need to be combined with the CityDreamer series or other commercial solutions for comparative evaluation.

Related tools: midjourney, stable-diffusion

Version Info

• CVPR 2025 official version ：The training and testing code is fully released, supporting OSM and GoogleEarth data sets; Hugging Face Demo is online (2025/03/02). （2025-02-27）
• Warehouse creation ：The initial repository is created, the code is not yet public. （2024-05-24）