CompGS: Unleashing 2D Compositionality for Compositional Text-to-3D via Dynamically Optimizing 3D Gaussians

## Abstract

Abstract Recent breakthroughs in text-guided image generation have significantly advanced the field of 3D generation. While generating a single high-quality 3D object is now feasible, generating multiple objects with reasonable interactions within a 3D space, a.k.a. compositional 3D generation, presents substantial challenges.
This paper introduces CompGS , a novel generative framework that employs 3D Gaussian Splatting (GS) for efficient, compositional text-to-3D content generation.
To achieve this goal, two core designs are proposed:
(1) 3D Gaussians Initialization with 2D compositionality : We transfer the well-established 2D compositionality to initialize the Gaussian parameters on an entity-by-entity basis, ensuring both consistent 3D priors for each entity and reasonable interactions among multiple entities;
(2) Dynamic Optimization : We propose a dynamic strategy to optimize 3D Gaussians using Score Distillation Sampling (SDS) loss. CompGS first automatically decomposes 3D Gaussians into distinct entity parts, enabling optimization at both the entity and composition levels. Additionally, CompGS optimizes across objects of varying scales by dynamically adjusting the spatial parameters of each entity, enhancing the generation of fine-grained details, particularly in smaller entities.
Qualitative comparisons and quantitative evaluations on T 3 superscript T 3 \mathrm{T}^{3} roman_T start_POSTSUPERSCRIPT 3 end_POSTSUPERSCRIPT Bench demonstrate the effectiveness of CompGS in generating compositional 3D objects with superior image quality and semantic alignment over existing methods. CompGS can also be easily extended to controllable 3D editing, facilitating complex scene generation. We hope CompGS will provide new insights to the compositional 3D generation. Project page: https://chongjiange.github.io/compgs.html .

## 1 Introduction

3D content creation is essential to the modern media industry, yet it has traditionally been labour-intensive and necessitated professional expertise.
Typically, designing a single 3D object takes several hours for an experienced designer, and creating complex scenes with multiple 3D objects (as shown in Fig. 1) requires even more effort.
Inspired by the recent success of diffusion models in the text-to-image generation Ho et al. (); Song et al. (); Rombach et al. (); Podell et al. (), much research has focused on exploring 2D diffusion models for text-to-3D generation.
Previous work can be divided into two main methodologies:
(1) Feed-forward generation Li et al. (); Hong et al. (); Xu et al. (), which entails training generalizable diffusion models on 3D data;
and (2) Optimization-based generation Poole et al. (); Lin et al. (); Metzer et al. (); Chen et al. (); Wang et al. (; ), which utilizes the pretrained 2D diffusion guidance to optimize 3D representations via Score Distillation Sampling (SDS) Poole et al. ().

Figure: Figure 1: Illustration of compositional 3D Generation and CompGS. All the contents are generated by CompGS. Top row: CompGS is capable of generating either a single object (e.g., a butterfly) or generating compositional objects with reasonable interactions (e.g., the rightmost figure in the top row). Middle row: Beyond text-to-3D generation, CompGS can be easily extend to 3D editing by progressively adding objects. The colored texts (e.g., ‘a branch’, ‘a pinecone’, ‘a rat’ in the rightmost figure) denote the added part compared to its previous asset. Bottom row: CompGS achieves compositional text-to-3D by transferring 2D compositionality to initialize 3D Gaussians. CompGS is further trained with dynamic SDS optimization to produce plausible results.
Refer to caption: x1.png

While existing work has demonstrated the feasibility of generating single 3D objects, they often struggle to produce compositional 3D content with multiple objects and complex interactions.
For example, (1) Feed-forward generation methods struggle in generalizing to complex textual descriptions since the amount of 3D training data is extremely limited Deitke et al. (; ), and most of the data contains only one object;
(2) Optimization-based generation methods face significant challenges with current 2D diffusion guidance when optimizing compositional 3D objects. Typically, using 2D diffusion guidance to optimize a single object is feasible, as it’s easy to incorporate various attributes into a single object. However, in compositional 3D generation, 2D guidance struggles to accurately compose multiple objects with different attributes and relationships into a coherent scene Huang et al. (). For example, given the prompt ‘a blue bench on the left of a green car,’ distinguishing different attributes within the implicit 2D diffusion priors is challenging, resulting in misaligning attributes to different objects or generating incorrect spatial relationships.
Thus, optimization-based compositional generation with standard 2D guidance often causes problems like 3D inconsistencies, multi-faced objects, semantic drift, etc Shi et al. (); He et al. ().

In this work, we propose CompGS, a generative system based on 3D Gaussian Splatting (GS) Kerbl et al. () for compositional text-to-3D generation. To achieve this, we introduce two core designs:

3D Gaussians Initialization with 2D Compositionality
Unlike the implicit representation, i.e., NeRF Mildenhall et al. (), CompGS uses 3D Gaussians as the representation, which helps to achieve feasible parameter initialization with a coarse 3D shape Jun & Nichol (); Yi et al. ().
As shown in the bottom row of Fig. 1, we first apply a text-to-image model Betker et al. (); Ramesh et al. (); Chen et al. () to generate an image that accurately captures the compositionality of multiple objects.
Then the image is segmented into different sub-objects (a.k.a. entities) according to the entity information in the given prompt.
These segmented entities are processed through an image-to-3D model Hong et al. (); Tochilkin et al. () to obtain coarse 3D shapes, which are used to roughly initialize the Gaussian parameters in 3D space, thereby transferring the 2D compositionality to 3D representations.

Dynamic Optimization.
Current 2D guidance Poole et al. (); Lin et al. (); Metzer et al. () struggles with optimizing multiple 3D objects simultaneously in a scene, often leading to 3D inconsistencies and semantic shifts.
To address these issues, we introduce a dynamic optimization strategy based on Score Distillation Sampling (SDS) loss, consisting of two key components:
(1) CompGS dynamically divides the training process to optimize different parts of 3D Gaussians. Specifically, it alternates between optimizing a single object (entity-level optimization) and the entire scene (composition-level optimization).
This is achieved by labeling and filtering the Gaussian parameters for inference, and updating them through masking gradients.
(2) CompGS dynamically trains the entity-level Gaussians within a normalized 3D space, crucial for compositional 3D generation where object sizes vary.
This is particularly challenging when dealing with very small objects, as optimizing Gaussian parameters in a limited 3D space may not adequately capture detailed textures.
To mitigate this, we first scale the subspace of each entity to a predefined, standardized volume.
Following each training iteration within these standardized volumes, we rescale the Gaussian parameters back to their original sizes.
This method dynamically maintains volume consistency throughout the training process, thereby facilitating the capture of fine details within smaller objects.

With these designs, CompGS is capable of generating high-quality compositional 3D objects (as shown in the first row of Fig. 1) and progressive 3D editing (as shown in the second row of Fig. 1).
We demonstrate the effectiveness of CompGS both qualitatively and quantitatively.
Qualitative comparisons through our user study indicate that CompGS offers superior image quality and semantic alignment compared to existing models (e.g., Fantasia3D Chen et al. (), ProlificDreamer Wang et al. (), VP3D Chen et al. (), etc.).
Besides, CompGS’s performance on $\mathrm{T}^{3}$Bench He et al. () quantitatively highlights its advantages in both semantic control and high-fidelity generation.
We hope CompGS can provide valuable insights into the research of compositional 3D generation.

The contributions of this work are as follows:
(1) We introduce CompGS, a user-friendly generative system framework for compositional 3D generation based on 3D Gaussians, which produces high-quality multiple 3D objects with complex interactions.
(2) CompGS transfers 2D compositionality to facilitate composed 3D generation and incorporates dynamic SDS optimization to address challenges in maintaining 3D consistency, generating plausible shapes and textures, and formulating reasonable object interactions.
(3) CompGS demonstrates superior performance compared to previous methods in compositional text-to-3D generation, both quantitatively and qualitatively, and can be easily extended to progressive 3D editing.

## 2 Related Work

Multi-modality 3D Generation Multi-modality 3D generation can basically categorized into the feed-forward system and optimization-based system. The former one is trained end-to-end on multi-view dataset Chang et al. (); Deitke et al. () for zero-shot generation, typically based on 3D representations, including NeRF Hong et al. (); Tochilkin et al. (), 3D Gaussians Xu et al. (); Tang et al. (), tri-planes  Shue et al. (); Wang et al. () and feature grids Karnewar et al. (). Despite the excellent performance achieved, the single-object training data Deitke et al. (); Luo et al. (); Deitke et al. (); Chang et al. () limits their generative abilities in scenarios involving multiple objects. Optimization-based 3D systems lift 2D diffusion priors Rombach et al. (; ); Podell et al. (); Chen et al. (; ) for 3D generation, and typically train 3D representations on a prompt-by-prompt basis.
For example, DreamFusion Poole et al. () introduces Score Distillation Sampling (SDS) loss to transfer 2D diffusion models into the 3D domain. Magic3D Qian et al. () employs a coarse-to-fine scheme to improve both efficiency and effectiveness, while Fantasia3D Chen et al. () decouples the modelling of geometry and appearance.
Despite the advancements of these methods addressing various challenges, they also usually struggle with compositional 3D generation.
$\mathrm{T}^{3}$bench’s examination of ten prominent optimization-based models Poole et al. (); Lin et al. (); Metzer et al. (); Wang et al. (; ); Chen et al. (); Shi et al. (); Yi et al. () revealed frequent issues in compositional generation.
The implicit 2D diffusion guidance used in these methods Poole et al. (); Shi et al. (); Wang et al. (); Chen et al. () often fails to maintain 3D consistency across different views, leading to significant discrepancies in compositional 3D scenes.

Compositional Generation
Compositional generation involves creating content involving multiple objects with logical interactions. These interactions include, but are not limited to, concept relations Liu et al. (), attribute association with colors Chefer et al. (); Feng et al. (); Park et al. (), and spatial relationships between objects Wu et al. (); Chen et al. ().
There is considerable focus on various aspects of compositional 2D generation, such as learning from human feedback Zhang et al. (); Lee et al. (); Dong et al. (); Yang et al. (), enhancing image captions Chen et al. (; ); Betker et al. (); Dai et al. (), designing effective networks Liu et al. (), and etc.
T2I-CompBench Huang et al. () further proposed a comprehensive benchmark and boosted the compositionality of text-to-image models. Compared to 2D compositional generation, its 3D counterpart is under-explored due to 3D geometry and appearance complexities.
For example, Set-the-Scene Cohen-Bar et al. () and Scenewiz3d Zhang et al. () propose to adopt object layouts to generate compositional scenes. However, they are mainly based on the implicit NeRF representations, so the features between objects cannot be well decoupled, resulting in a relatively blurred rendering effect. VP3D Chen et al. () takes a different strategy to employ visual features for compositional generation. However, its visual features are only used as implicit supervision, which does not adequately ensure 3D consistency or address the Janus problems Shi et al. (). Besides, LucidDreaming Wang et al. () requires human-annotated layout priors for local optimization, which is labour-intensive and inaccurate; while GraphDreamer Gao et al. () optimizes all interactive objects from scratch, which is time-consuming and difficult to optimize.
The most concurrent works, GALA3D Zhou et al. (), propose optimizing the spatial relationships of well-trained Gaussians for compositional generation. Though it achieves plausible spatial interactions, it is inefficient in generating complex mutual interactions among objects. More comparisons are in the appendix. We propose CompGS to address the above challenges, emphasizing efficient optimization and the generation of complex interactions.

## 3 Methodology

In this section, we revisit 3D Gaussian Splatting Kerbl et al. () and diffusion priors for 3D generation.
We then provide an overview of CompGS, which includes initializing 3D Gaussians to incorporate compositionality priors and dynamic SDS optimization to generate high-fidelity, 3D consistent objects with complex interactions. The notations used in this section are also detailed in Appendix A.1 for clarity.

### 3.1 Preliminaries

3D Gaussian Splatting (GS) Kerbl et al. () has recently revolutionized novel-view synthesis of objects/scenes by its real-time rendering.
Specifically, GS represents the 3D objects/scenes by $\mathit{N}$ explicit anisotropic Gaussians with center positions $\mu_{i}$, covariances $\Sigma_{i}$, opacities $\alpha_{i}$ and colors $c_{i}$, where $i\in N$.
The color $\mathcal{C}(\mathbf{p})$ of image pixel $\mathbf{p}$ can be calculated through point-based volume rendering Kopanas et al. (; ) by integrating the color and density of the 3D Gaussians intersected by a ray, as follows:

$$ $\displaystyle\mathcal{C}(\mathbf{p})$ $\displaystyle=\sum_{i=1}^{N}c_{i}\sigma_{i}\prod^{i-1}_{j=1}\left(1-\sigma_{j} \right),$ (1) $\displaystyle\sigma_{i}$ $\displaystyle=\alpha_{i}\,\textrm{exp}\left[-\frac{1}{2}\left(\mathbf{p}-\hat{ \bm{\mu}}_{i}\right)^{\top}\hat{\Sigma}^{-1}_{i}\left(\mathbf{p}-\hat{\bm{\mu} }_{i}\right)\right],$ (2) $$

where $\hat{\bm{\mu}}_{i}$ and $\hat{\Sigma}_{i}$ denote the projected center positions and covariances of the 2D Gaussians, transformed from 3D space to the 2D camera’s image plane. The image plane can be segmented into tiles during rendering for parallel processing.
Unlike implicit representations, such as NeRF Mildenhall et al. (); Barron et al. (); Müller et al. (), GS offers two key advantages for compositional 3D generation:
(1) 3D Gaussians facilitate localized rendering, allowing for the rendering of object A in one specific sub-space and object B in another, thus enabling global compositional generation on a divide-and-conquer basis;
(2) 3D Gaussians enable direct parameter initialization, simplifying the integration of compositional priors at the initialization stage.

Diffusion Priors for 3D Generation Diffusion-based generative models (DMs) Dhariwal & Nichol (); Sohl-Dickstein et al. (); Song et al. () have been widely utilized to provide implicit priors for 3D object generation via score distillation sampling (SDS) Poole et al. ().
Specifically, given a 3D model whose parameters are $\theta$, a differentiable rendering process $\mathit{g}$, the rendered images could be obtained via $\mathrm{x}=\mathit{g}(\theta)$. To ensure the rendered images resemble those generated by the DM $\phi$, SDS first formulates the sampled noise $\hat{\epsilon}_{\phi}(\mathrm{z}_{t};v,t)$ with the noisy image $\mathrm{z}_{t}$, text embedding $v$, and noise level $t$.
By comparing the difference between the added Gaussian noise $\epsilon$ and the predicted noise $\hat{\epsilon}_{\phi}$, SDS constructs gradients that could be back-propagated to update $\theta$ via:

$$ $\nabla_{\theta}\mathcal{L}_{\textrm{SDS}}(\phi,\mathrm{x}=g(\theta))\triangleq \mathbb{E}_{t,{\epsilon}}\left[w(t)\left(\hat{{\epsilon}}_{\phi}(\mathbf{z}_{t },v,t)-{\epsilon}\right)\frac{\partial\mathrm{x}}{\partial{\theta}}\right],$ (3) $$

where $w(t)$ is a weighting function, and the Classifier-free guidance (CFG) Ho & Salimans () typically amplifies the text conditioning $\mathit{v}$.

### 3.2 CompGS

We propose CompGS for efficiently transferring the 2D compositionality to facilitate compositional 3D generation with 3D Gaussians. The overall framework of CompGS is shown in Fig. 2. We first generate a well-composed image from the given complex prompt. After extracting the sub-object (also named entity) information within the prompt by LLM, we utilize the entity prompt to segment the composed image into different parts. Each part will be adopted to initialize a specific space of Gaussians.
During the training stage, we propose a dynamic SDS optimization strategy. This strategy first automatically decomposes the training to optimize either entity-level Gaussians or composition-level Gaussians. Then, it employs a volume-adaptive strategy to dynamically optimize varying-sized entities within a consistent 3D space. We detail the initialization process and dynamic SDS optimization in the following sections.

Figure: Figure 2: Overall pipeline of CompGS. Given a compositional prompt $V$, we first use an LLM to decompose it into entity-level prompts $\{v_{l}\}$, guiding the segmentation of each entity from the compositional image generated by T2I models. The segmented images initialize entity-level 3D Gaussians via image-to-3D models Tochilkin et al. (); Hong et al. (). CompGS employs a dynamic optimization strategy, alternating between composition-level optimization of $\theta$ and entity-level optimization of $\{\theta_{l}\}$. For entity-level optimization, COMPGS dynamically maintains volume consistency to refine the details of each objects, particularly the small one.
Refer to caption: x2.png

#### 3.2.1 3D Gaussians Initialization with 2D Compositionality

Unlike the implicit NeRF Mildenhall et al. () representations, explicit 3D Gaussians can be easily initialized with 3D shapes and colors, which facilitates introducing rough 3D priors to ensure 3D consistency Yi et al. ().
Although existing text-to-3D or image-to-3D models can generate a single 3D object, they struggle with compositional 3D generation as mentioned in Sec. 2, which hinders the creation of compositional 3D priors needed for initialization.
Considering this, we propose initializing the compositional Gaussians on an entity-by-entity basis.

As shown in Fig. 2 (left), given a complex prompt $V$, (e.g., ‘an owl perches on a branch near a pinecone’), we first adopt a 2D diffusion model Betker et al. () to generate a composed image $I$ that faithfully captures the compositionality of multiple objects. We extract each entity information in prompt $V$ by prompting LLM to obtain $L$ different entity-level prompts (i.e., $L=3$ for $v_{1}$ ‘an owl’ , $v_{2}$ ‘a branch’ , and $v_{3}$ ‘a pinecone’ ). These prompts are adopted in a text-guided segmentation model Kirillov et al. () to decompose image $I$ into various parts $\{I_{l}\}$. Until now, each segmented image has only one entity, facilitating using existing image-based 3D generation models Tochilkin et al. () to predict a rough triangle mesh $m_{l}(l\in L)$ of the corresponding 3D entity $l$. To initialize 3D Gaussians $\theta_{l}$, we index $N$ points from each mesh; the center positions $\mu^{l}_{i}\in\mathbb{R}^{3}(i\in N,l\in L)$ are the centers of each vertex of $m_{l}$, and the texture colors $c^{l}_{i}\in\mathbb{R}^{3}(i\in N,l\in L)$ are queried from each vertex of $m_{l}$. During the image-to-3D process, we did not perform any cropping or padding on the image $I_{l}$, ensuring that the spatial positions of each mesh $m_{l}$ correspond to their 2D spatial positions.
Additionally, we have marked the 3D layouts of each entity asset with 3D bounding boxes $\mathrm{bbox}_{l}$ for subsequent optimization. The bounding box coordinates are determined by the outer-most center positions of the entity Gaussian.

#### 3.2.2 Dynamic SDS Optimization

As mentioned in Sec. 2, existing SDS methods  Poole et al. (); Shi et al. (); Wang et al. (); Chen et al. () struggle in optimizing compositional 3D scenes due to the challenges of using implicit diffusion priors to maintain multi-objects consistency and interactions. To address this, we introduce dynamic SDS optimization to enable existing SDS losses to remain effective in compositional generation. Dynamic SDS optimization is performed through the following two procedures.

Automatically Decomposing Optimization to Different Levels
We adopt the Decomposed Optimization (DO) strategy that divides the entire training into $L+1$ stages, including $L$ stages for entity-level optimization to ensure 3D consistency of each $L$ entities, and one stage for composition-level optimization to refine inter-entity interactions. In each training iteration, we randomly render either (1) an entity Gaussian $\theta_{l}(l\in L)$ to obtain the entity image $\mathrm{x}_{l}=g(\theta_{l})$ ($\theta_{l}\in\mathrm{bbox}_{l}$), or (2) the composed Gaussians $\theta$ to obtain the composed image $\mathrm{x}=g(\theta)$. Here $g$ denotes the Gaussian Splatting rendering  Kerbl et al. () described in Eq. 1.

To update Gaussian parameters, we apply Eq. 3 for gradients backpropagation. Specifically, for entity-level optimization, we substitute the text embedding $v$ by $v_{l}$ and parameters $\theta$ by $\theta_{l}$ in Eq. 3 to optimize entity Gaussian. We adopt MVDream Shi et al. () as $\phi$, which provides multi-view diffusion priors that can better maintain consistency in 3D entity modelling. To ensure that other entity’s parameters remain unchanged, we mask the gradients that are not within the corresponding 3D bounding boxes $\mathrm{bbox}_{l}$ when updating $\theta_{l}$.
Besides, for composition-level optimization, we integrate both 2D Rombach et al. () and 3D diffusion priors Shi et al. () to jointly optimize the overall Gaussian parameters $\theta$. The rationale is that 2D priors promote geometry exploration Qian et al. (), which enhances the generation of plausible interactions between different entities.

Volume-adaptively Optimizing Entity-level Gaussians
Compared to the single object generation, compositional 3D generation using SDS presents additional challenges. Specifically, when objects vary in size, optimizing directly in the original 3D space often results in suboptimal generation for smaller objects, as shown the ‘pinecone’ in Fig. 2. To mitigate this issue, we propose a Volume-adaptive Optimization (VAO) strategy that enhances optimization across objects of varying sizes by dynamically standardizing each entity’s space to a standardized volumetric scale. This approach is especially beneficial for improving the generation of fine-grained texture details in smaller entities.

To scale the 3D bounding box of an entity Gaussian $\theta_{l}$ with a standardized volumetric space $\mathrm{bbox}_{std}$, we first determine the necessary transformations for the centre positions $\mu$. Specifically, we calculate the shift parameters $\beta$, and scale parameters $\lambda$, as follows:

$$ $\beta=\mathrm{Mean}(\mathrm{bbox}_{l});\quad\lambda=\mathrm{bbox}_{std}/ \mathrm{bbox}_{l},$ (4) $$

where $\mathrm{Mean}$ computes the center coordinates of the given bounding box, and $\mathrm{bbox}_{std}$ is the target standardized space. Then, we zoom-in the entity Gaussian on its center positions by $\hat{\mu}=\lambda(\mu-\beta)$, where $\hat{\mu}$ denotes the transformed center positions of entity Gaussian. We substitute all $\mu$ to $\hat{\mu}$ in Eq. 1 for SDS optimization. After each training iteration, we perform zooming-back via $\mu=\hat{\mu}/\lambda+\beta$. The proposed transformation ensures dynamically conducting SDS optimization on each entity Gaussian at a standardized and consistent scale. Experiments in Sec. 4.3 demonstrate its effectiveness in generating high-quality 3D assets.

### 3.3 Progressive Editing with CompGS

The dynamic SDS optimization enables CompGS to explicitly control the generation of different parts in the 3D scene. This capability can be utilized for progressive 3D editing in compositional generation. Specifically, given well-trained 3D Gaussians $\theta$, we begin by rendering an image from the front view, denoted as $\mathrm{x}=g(\theta)$. Unlike previous works that directly edit 3D objects Cheng et al. (), we adopt MagicBrush Zhang et al. () to edit the 2D rendered image $\mathrm{x}$. The edited 2D image can then be utilized to initialize new Gaussians $\hat{\theta}$ in the original 3D space. We further train the added 3D Gaussians to finally introduce new objects into the compositional scenes. For example, as shown in Fig. 1, given well-trained 3D Gaussians (e.g., ‘an owl’), we progressively edit the 2D images to add new objects, such as the ‘branch’ and ‘pinecone.’ We then train the corresponding 3D Gaussians via dynamic SDS optimization to incorporate these new elements into the 3D scenes.

## 4 Experiments

### 4.1 Experimental Settings

Implementation Details
We implemented CompGS using ThreeStudio Guo et al. ().
We use DALL·E Betker et al. () to generate the well-established 2D compositionality, LangSAM Medeiros () to segment the entity image, and TripoSR Tochilkin et al. () to generate a preliminary 3D prior (i.e., mesh) from each entity image, respectively.
During the training, we employed MVDream Shi et al. () to optimize entity-level Gaussians, and both MVDream Shi et al. () and stabilityai/stablediffusion-2-1-base Rombach et al. () to optimize composition-level Gaussians. The guidance scale for diffusion models was set as 50. Timestamps were uniformly selected from 0.02 to 0.55 for the first 1,000 iterations and then adjusted to a range from 0.02 to 0.15 for subsequent iterations. We initialized the Gaussian points at $N=10k$, and progressively increased the density to a maximum of $1000k$ points.
We optimized the overall compositional scenes through 10k iterations to achieve optimal results. However, it is worth noting that we empirically found that training with 5k iterations already produces plausible 3D assets. The learning rates are detailed in Appendix A.3. We set the camera parameters, including radius, azimuth, elevation and FoV (field of view) to be the same as  Shi et al. (). Experiments were conducted on NVIDIA A100 GPUs(40G).

Evaluation Metrics
In addition to user studies and qualitative comparisons, we utilize T^3Bench He et al. () to render 300 prompts in order to evaluate compositional 3D generation on two criteria: (1) the visual quality of the 3D objects and (2) the alignment between the 3D objects and the input prompt.
For quality evaluation, we captured multi-focal and multi-view images and sent them to text-image scoring models, CLIP Radford et al. (), to obtain an average quality score of the generated 3D scene.
Regarding the textual alignment, we first followed Luo et al. () to perform 3D captioning via BLIP Li et al. () and GPT4, and then computed the recall of the original prompt within the generated caption via ROUGE-L Lin ().

Figure: Figure 3: Qualitative comparisons between CompGS and other text-to-3D models on $\mathrm{T}^{3}$Bench (multiple objects track). Compared to others, CompGS is better at generating highly-composed, high-quality 3D contents that strictly align with the given texts. Watch the animations by clicking them (Not all PDF readers support playing animations. Best viewed in Acrobat/Foxit Reader).

### 4.2 Performance Comparisons and Analysis

Qualitative Evaluation
In Fig. 3, we present qualitative comparisons of compositional 3D generation. Our model, CompGS, is compared with several open-source methods, including DreamFusion Poole et al. (), Magic3D Qian et al. (), Latent-NeRF Metzer et al. (), Fantasia3D Chen et al. (), SJC Wang et al. (), and ProlificDreamer Wang et al. (), as well as methods specifically designed to handle intricate text prompts, VP3D Chen et al. () in Fig. 3. The results demonstrate that CompGS generates compositional 3D objects with superior quality, greater consistency, and more plausible interactions. DreamFusion, for example, fails to generate reasonable multi-objects from compositional prompts, revealing limitations in SDS loss for optimizing multiple objects simultaneously. Magic3D and Latent-NeRF, though guided by a 3D mesh prior, struggle with generating complex and compositional 3D geometry. Despite employing advanced SDS loss, Fantasia3D, SJC, and ProlificDreamer only improve the appearance of the content but do not fundamentally address multi-object generation. Notably, VP3D employs features from compositional images and human feedback to guide compositional 3D generation. However, it often produces unexpected artifacts (e.g., redundant dots in the top two rows of Fig. 3) or less plausible interactions (e.g., strange spatial relationships in the fourth row). This is likely due to the insufficient utilization of 2D compositionality, as VP3D adopts the implicit image features to guide optimization. In contrast, CompGS generates high-quality and composed content that strictly aligns with the given complex prompts, demonstrating its effectiveness over others. We provide more visual comparisons with both the close-source and open-source methods (including GALA3D Zhou et al. () in Fig. 9, GraphDreamer Gao et al. (), DreamGaussian Tang et al. () in Fig. 10, etc.) in Appendix A.4 as well as the attached video.

Figure: Figure 4: More generated samples by CompGS. Four views are shown. CompGS can generate high-quality contents with reasonable interactions given two, three or more entities.
Refer to caption: x3.png

We also demonstrate CompGS’s capabilities in generating more diverse contents in Fig. 4. CompGS accurately generates both simple spatial relationships (shown in the first row), and more complex interactions, where objects should react to each other (shown in the second row). Besides, CompGS is not limited to generating just two objects, it can generate multiple objects by expanding the number of entity-level Gaussians. For example, in the third row, CompGS generates scenes with three and four entities, each with high-quality 3D shapes and textures.

We conduct a user study for further evaluation. We randomly selected 15 prompts in $\mathrm{T}^{3}$Bench, and collected the 3D assets generated by different models. These collected 3D assets were then distributed to individuals for ranking the models based on (1) 3D visual quality and (3) text-3D alignment. We average the ranking of different models as their scores. Results in Tab. 1 show that representative optimization-based models received relatively low average scores, highlighting their limitations in compositional generation. VP3D Chen et al. () outperforms its predecessors due to the incorporation of image features but still ranks lower than CompGS, which further validates our effectiveness.

**Table 1: Quantitative comparisons on T^3Bench He et al. () and user studies show CompGS outperforms feed-forward, optimization-based, and compositional generation models.**
| Method | $\mathrm{T}^{3}$Bench (*Multiple Objects*) | User Study |  |  |
| --- | --- | --- | --- | --- |
| Quality$\uparrow$ | Alignment$\uparrow$ | Average$\uparrow$ | Ranking Score$\uparrow$ |  |
| OpenLRM Hong et al. () | 15.2 | 25.5 | 20.4 | - |
| TripoSR  Tochilkin et al. () | 16.7 | 28.6 | 22.7 | - |
| DreamFusion Poole et al. () | 17.3 | 14.8 | 16.1 | 4.54 |
| SJC Wang et al. () | 17.7 | 5.8 | 11.7 | 3.08 |
| LatentNeRF Metzer et al. () | 21.7 | 19.5 | 20.6 | 4.14 |
| Fantasia3D Chen et al. () | 22.7 | 14.3 | 18.5 | 2.43 |
| ProlificDreamer Wang et al. () | 45.7 | 25.8 | 35.8 | 3.56 |
| Magic3D Lin et al. () | 26.6 | 24.8 | 25.7 | 4.30 |
| Set-the-Scene Cohen-Bar et al. () | 20.8 | 29.9 | 25.4 | - |
| VP3D Chen et al. () | 49.1 | 31.5 | 40.3 | 6.71 |
| CompGS (ours) | 54.2 (+5.1) | 37.9(+6.4) | 46.1(+5.8) | 7.23 |

Quantitative Evaluation
In Tab. 1, we benchmark the representative models on $\mathrm{T}^{3}$Bench, focusing on the multi-objects track. Results indicate CompGS achieves superior performance in both quality and textual alignment.
Compared with feed-forward methods in the first block, CompGS significantly improves the generation quality by a large margin. Though CompGS is initialized from the 3D priors obtained from  Tochilkin et al. (), CompGS still enhances text-3D alignment, likely due to the dynamic optimization on composition-level Gaussians.
Furthermore, compared with the optimization-based methods, CompGS shows significant advantages in both two metrics.
Even when compared to methods specifically designed for compositional generation, e.g., VP3D Chen et al. () and Set-the-Scene Cohen-Bar et al. (), CompGS demonstrates clear improvements, indicating the effectiveness of our designs.
Note that CompGS is not limited to compositional generation; the results in the track of single-object generation are included in Appendix A.4.

Runtime Comparisons
Though CompGS is trained with 10k steps, we observed that training
the model for 5k iterations already produces high-quality content with minimal loss of texture details.
We show runtime comparisons with other models in Tab. 2. In fact, compositional 3D generation (left) requires a longer training time than single-object generation (right) due to its complexity. Compositional 3D involves optimizing individual objects and ensuring the consistency of compositional scenes, making them more intricate. The runtime is generally relative to the number of objects involved. Compared to open-source compositional 3D methods such as Set-the-Scene Cohen-Bar et al. (), Progressive3D Cheng et al. (), and GraphDraemer Gao et al. (), our proposed CompGS is more efficient in training. For instance, given the prompt "a parrot talks beside a perch and two bowls," Progressive3D takes approximately 250 minutes for 3D generation, while Set-the-Scene requires around 110 minutes. Since many compositional scene generation methods are not open-sourced, we also present the training steps listed in the papers for straightforward comparisons.
In addition, CompGS demonstrates comparable and even superior efficiency over other methods in text-to-single object generation. For example, methods such as Magic3D Lin et al. () and Fantastic3D Chen et al. () require over five hours to optimize a single object. In contrast, CompGS can achieve the same task in approximately 30 minutes.

**Table 2: Runtime comparisons on both compositional generation and single object generation show the efficiency of CompGS.**
| Compositional Generation | Single Object Generation |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Method | Open-source | 3D<br>Representations | Training<br>Steps | Training Time<br>(minutes) | Method | Open-source | 3D<br>Representations | Training<br>Steps | Training Time<br>(minutes) |
| Progressive3D Cheng et al. () | $\checkmark$ | NeRF | 40,000 | 220 | DreamFusion Poole et al. () | $\checkmark$ | NeRF | - | 360 |
| Set-the-scene Cohen-Bar et al. () | $\checkmark$ | NeRF | 15,000 | 110 | Magic3D Lin et al. () | $\checkmark$ | NeRF | - | 340 |
| CompNeRF Driess et al. () | $\times$ | NeRF | 13,000 | - | Fantastic3D Chen et al. () | $\checkmark$ | NeRF | - | 380 |
| SceneWiz3D Zhang et al. () | $\times$ | NeRF | 20,000 | 420 | ProlificDreamer Wang et al. () | $\checkmark$ | NeRF | - | 520 |
| GraphDreamer Gao et al. () | $\checkmark$ | NeRF | 20,000 | 420 | GaussianDreamer Yi et al. () | $\checkmark$ | 3D Gaussians | - | 14 |
| CompGS-10k (Ours) | - | 3D Gaussians | 10,000 | 70 | CompGS-10k (Ours) | - | 3D Gaussians | 10,000 | 70 |
| CompGS-5k (Ours) | - | 3D Gaussians | 5,000 | 30 | CompGS-5k (Ours) | - | 3D Gaussians | 5,000 | 30 |

Figure: Figure 5: 3D Editing examples of CompGS. More examples could be found in Appendix A.9.
Refer to caption: x4.png

Extended Applications: 3D Editing
CompGS allows progressive 3D editing for compositional scenes. We present 3D editing examples in Fig. 6. These examples demonstrate that by transferring edited 2D compositionality and employing dynamic SDS optimization, CompGS can progressively incorporate new 3D entities into the original 3D scenes. For example, CompGS can generate the ‘chair’, ‘panda’, ‘hat’ and ‘plant’ step by step as shown in Fig. 6.

### 4.3 Ablation Study

We conduct ablation studies to validate the effectiveness of three key designs in CompGS: Gaussian parameters initialization, decomposed optimization (DO), and volume-adaptive optimization (VAO). We randomly choose 20 prompts from $\mathrm{T}^{3}$Bench for the quantitative evaluation. Meanwhile, we use Fig. 6 to visualize the effect of each component.

**Table 3: Ablation Studies on T^3Bench He et al. ().**
| Component | Quality | Alignment | Average |
| --- | --- | --- | --- |
| Full Setting | 53.8 | 38.0 | 45.9 |
| - w/o GS Init. | 22.8 | 18.7 | 20.8 |
| - w/o DO Strategy | 46.8 | 35.2 | 41.0 |
| - w/o VAO Strategy | 50.8 | 36.4 | 43.6 |

Initialization
Instead of initializing Gaussian parameters using 2D compositionality, we conduct random initialization within a predefined 3D bounding box for each entity Gaussian. A significant decrease in the quality and alignment metric is observed in Tab. 3. Besides, the visualization in Fig. 6 confirms that training from random initialization with predefined layouts may result in low-quality textures (e.g., owl’s face) and missing entities (e.g., the branch).

Decomposed Optimization We analyze the decomposed training by discarding the entity-level optimization.
Results in Tab. 3 and Fig 6 both indicate that removing decomposed training leads to low-fidelity generation. For example, in Fig. 6, optimizing composition-level Gaussians results in a relatively blurred generation on the owl’s fur and the pinecone, validating that optimization on each single entity is necessary to effectively leverage 2D diffusion priors to guide 3D generation.

Volume-adaptive Optimization To evaluate the effectiveness of volume-adaptive optimization, we choose to optimize the entity Gaussians in their original 3D space. We observed that optimizing different entities within varying sizes of 3D space slightly decreased in quality and alignment, which is noticeable for smaller objects in the compositional scene. For instance, the ‘pinecone’ and ‘branch’ trained without volume-adaptive optimization exhibited fewer fine-grained details, shown as the green leaves on the branch and the shadow on the pinecone in Fig. 6.

## 5 Conclusion

In this paper, we introduced CompGS, a user-friendly, optimization-based framework, which achieves compositional text-to-3D generation utilizing Gaussian Splatting. Our three core designs, including initializing 3D Gaussians with 2D compositionality, decomposed optimization for either entity-level or composition-level Gaussians, and volume-adaptive optimization, contribute to the success of CompGS. Through both qualitative and quantitative experiments, we demonstrate CompGS is capable of generating complex
interactions between multiple entities in 3D scene. We hope that our work inspires further innovation and advancements in the compositional 3D generation.

Impacts and Limitations As a text-to-3D model, we do not
foresee obvious undesirable ethical/social impacts. One limitation is that when the given prompt includes backgrounds (e.g., ground, sky), CompGS may fail to generate these elements adequately. This is due to the current text-guided segmentation model’s inability to segment such abstract concepts.
We leave it for future exploration.

## Appendix A Appendix / supplemental material

In this supplementary material, we first clarify the notations used in this paper and then revisit the proposed CompGS in Algorithms 1. The training details of CompGS will also be provided. Besides, we provide more numerical and visual evaluations to further validate the effectiveness of our model. We have provided a demo video in the attachment to display more visual comparisons between CompGS and other methods. We will make code public.

### A.1 Notations

We compile a comprehensive list of all the notations utilized in this paper, as shown in Table 4.

**Table 4: Notations.**
| Notation | Description |
| --- | --- |
| $L$ | Total number of entities |
| $V$ | Complex prompt (e.g., ’an owl perches on a branch near a pinecone’) |
| $I$ | Composed image generated by the 2D diffusion model |
| $v_{l}$ | Entity-level prompt for entity $l,(l\in L)$ |
| $I_{l}$ | Segmented image containing entity $l,(l\in L)$ |
| $m_{l}$ | Rough triangle mesh of the 3D entity $l,(l\in L)$ |
| $\theta_{l}$ | 3D Gaussians for the entity $l,(l\in L)$ |
| $\theta$ | Composed 3D Gaussians $l$ |
| $N$ | Number of points indexed from each mesh |
| $\mu_{i}^{l}$ | Center positions of each vertex of mesh $m_{l}$ in $\mathbb{R}^{3}$ |
| $c_{i}^{l}$ | Texture colors queried from each vertex of mesh $m_{l}$ in $\mathbb{R}^{3}$ |
| $\mathrm{bbox}_{l}$ | 3D bounding box for entity $l$, used for optimization |
| $\mathrm{bbox}_{std}$ | Standardized volumetric space for scaling |
| $\mu$ | Center positions of each vertex in the original 3D space |
| $\hat{\mu}$ | Transformed center positions of entity Gaussian after scaling |
| $\beta$ | Shift parameters for the center positions of the bounding box |
| $\lambda$ | Scale parameters for standardizing the volumetric space |
| $\mathrm{x}$ | Rendered image from 3D Gaussians |
| $g(\cdot)$ | Gaussian Splatting rendering function |
| $\beta$ | the shift parameters for volume-adaptive optimization |
| $\lambda$ | the scale parameters for volume-adaptive optimization |
| $\mathrm{Mean}(\cdot)$ | the operator computing the center coordinates of the given bounding box |
| $\hat{\theta}$ | New Gaussians initialized from the edited 2D image |

### A.2 Algorithm

We provide pseudocode in Algorithm 1. Two core designs, including 3D Gaussian initialization with 2D compositionality and dynamic SDS optimization, are detailed.

Figure: Algorithm 1 CompGS: 3D Gaussian Initialization and Dynamic SDS Optimization $V,\{v_{l}\}(l\in L)$: Input prompt and entity-level prompts. $\{m_{l}\}(l\in L)$: Entity-level meshes. $\theta,\{\theta_{l}\}(l\in L)$: Composition-level Gaussian parameters and entity-level Gaussian parameters. $\mathrm{bbox}_{std}$: Standardized volumetric space. $L$: The number of entities. $N$: The number of Gaussian parameters. $\mathrm{T2I}$: Text-to-Image models. $\mathrm{TGS}$: Text-guided segmentation models. $\mathrm{I2M}$: Image-to-Mesh models. $\mathrm{Zoom}^{\uparrow}$, $\mathrm{Zoom}^{\downarrow}$: Zoom-in and Zoom-back operators in Eq. 4. $\eta$: Learning rate. $T$: Total training iterations.

Figure: Figure 7: Qualitative comparisons between CompGS and other text-to-3D models on $\mathrm{T}^{3}$Bench (multiple objects track). CompGS is better at generating highly-composed, high-quality 3D contents that strictly align with the given texts. Watch the animations by clicking them (Not all PDF readers support playing animations. Best viewed in Acrobat/Foxit Reader).

Figure: Figure 8: Qualitative comparisons between CompGS and other text-to-3D models on $\mathrm{T}^{3}$Bench (single object track). CompGS is better at generating high-quality 3D assets that strictly align with the given texts. Watch the animations by clicking them (Not all PDF readers support playing animations. Best viewed in Acrobat/Foxit Reader).

### A.3 Additional Training Details

CompGS is implemented in ThreeStudio Guo et al. (). We use DALL·E 3 Betker et al. (), LangSAM Medeiros () and TripoSR Tochilkin et al. () to implement the text-to-image, text-guided segmentation, and image-to-mesh, respectively. For entity-level optimization, we adopt MVDream Shi et al. () as the 3D diffusion prior; while for composition-level optimization, we employ stabilityai/stablediffusion-2-1-base Rombach et al. () as the 2D diffusion prior. We set all the diffusion guidance as 50. For all Gaussian parameters, we linearly decreased the learning rate for position $\mu$ from $10^{-3}$ to $10^{-5}$, for scale from $10^{-2}$ to $10^{-3}$, and for color $c$ from $10^{-2}$ to $10^{-3}$, respectively. Besides, we fixed the learning rate for opacity $a$ to be 0.05, and for rotation to be 0.001. Additionally, we use a consistent batch size of 4 for both training and test, and a rendered resolution fixed at $1024\times 1024$. Camera settings during training are set with distances ranging from 0.8 to 1.0 relative units, a field of view between 15 and 60 degrees, and elevation ranging up to 30 degrees.
Additionally, there are no perturbations applied to camera position, center, or orientation, maintaining a controlled imaging environment.
For test, we set the resolution of rendered image as $1024\times 1024$ with specific camera distance and field of view for validation set to 3.5 units and 40 degrees, respectively.
For each prompt, we train the model on an NVIDIA A100 GPU (40G) for 10,000 iterations, which takes approximately 70 minutes. We observed that training the model for 5,000 iterations already produces high-quality content with minimal loss of texture details. This indicates that the training duration can be shortened to around 30 minutes. However, to achieve high-quality 3D textures, we use 10,000 iterations for training in this paper, unless otherwise specified.

### A.4 Extended Experiments on Qualitative Comparisons

Qualitative Model Comparisons on Multi-objects Generation
Fig. 7 showcases additional 3D assets produced by CompGS. The prompts are selected from $\mathrm{T}^{3}$Bench (multiple objects track). Compared to previous methods, CompGS not only generates multiple objects but also produces more plausible interactions while maintaining 3D consistency among the objects. For example, in the first row, previous methods such as DreamFusion, Magic3D, LatentNeRF, Fantasia3D, SJC, and ProlificDreamer all fail to generate the canvas described in the given prompt. Although both VP3D and CompGS can generate the two entities (paintbrush and canvas), VP3D fails to maintain 3D consistency, as the back view of the canvas is not visually plausible. In this case, CompGS successfully captures both the key entities described in the prompt and generates reasonable spatial relationships and interactions between the two objects. This phenomenon can also be observed in other cases, such as the key and lock in the third row, and the fisherman in the sea in the fifth row, and so on. Besides the issue of 3D consistency, we found that CompGS performs better in texture alignment. For example, in the second-to-last row, other methods failed to display the combination of chessboard, king, and queen. Specifically, VP3D did not recognize the king and queen as chess pieces. In contrast, CompGS generates these entity details more accurately.
Overall, the comparisons in both visual quality and textural alignment with previous methods demonstrate the effectiveness of the proposed CompGS.

**Table 5: Quantitative comparisons with baselines on T^3Bench He et al. () (all three tracks). CompGS is compared with feed-forward models, optimization-based models, and models specifically designed for compositional generation.**
| Method | *Single Object* | *Single Object with Surroundings* | *Multiple Objects* |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Quality | Alignment | Average | Quality | Alignment | Average | Quality | Alignment | Average |  |
| LRM Hong et al. () | 29.4 | 38.2 | 33.8 | 20.3 | 35.1 | 27.7 | 15.2 | 25.5 | 20.4 |
| TripoSR  Tochilkin et al. () | 34.3 | 38.9 | 36.6 | 21.8 | 37.2 | 29.5 | 16.7 | 28.6 | 22.7 |
| DreamFusion Poole et al. () | 24.9 | 24.0 | 24.4 | 19.3 | 29.8 | 24.6 | 17.3 | 14.8 | 16.1 |
| SJC Wang et al. () | 26.3 | 23.0 | 24.7 | 17.3 | 22.3 | 19.8 | 17.7 | 5.8 | 11.7 |
| LatentNeRF Metzer et al. () | 34.2 | 32.0 | 33.1 | 23.7 | 37.5 | 30.6 | 21.7 | 19.5 | 20.6 |
| Fantasia3D Chen et al. () | 29.2 | 23.5 | 26.4 | 21.9 | 32.0 | 27.0 | 22.7 | 14.3 | 18.5 |
| ProlificDreamer Wang et al. () | 51.1 | 47.8 | 49.4 | 42.5 | 47.0 | 44.8 | 45.7 | 25.8 | 35.8 |
| Magic3D Lin et al. () | 38.7 | 35.3 | 37.0 | 29.8 | 41.0 | 35.4 | 26.6 | 24.8 | 25.7 |
| Set-the-Scene Cohen-Bar et al. () | 32.9 | 31.9 | 32.4 | 30.2 | 45.8 | 35.5 | 20.8 | 29.9 | 25.4 |
| VP3D Chen et al. () | 54.8 | 52.2 | 53.5 | 45.4 | 50.8 | 48.1 | 49.1 | 31.5 | 40.3 |
| CompGS | 55.1 | 52.5 | 53.8 | 43.2 | 46.8 | 45.0 | 54.2 | 37.9 | 46.1 |

Qualitative Model Comparisons on Single-object Generation
Though CompGS is specifically designed for compositional generation, it can naturally handle single-object generation as well. We present the qualitative comparisons between CompGS and previous works in Fig. 8. It is observed that CompGS performs better in maintaining multi-view consistency and generating fine-grained details of the object. For example, in the last row of Fig. 8, CompGS is capable of generating a 3D consistent candle holder, including detailed copper textures. In contrast, other methods either fail to produce the corresponding shape Chen et al. (), only generate rough outlines without detailed textures Poole et al. (); Lin et al. (); Metzer et al. (); Wang et al. (), or produce 3D patterns with discontinuities Wang et al. (); Chen et al. ().

Qualitative Model Comparisons with Scene-generation Methods
We also compare CompGS with closed-source models Zhou et al. (); Cohen-Bar et al. () that generate 3D scenes. Figures were selected from  Zhou et al. () and are presented in Fig. 9. The results indicate that CompGS excels in generating high-fidelity texture details and complex interactions. In the second row of Fig. 9, CompGS produces more detailed textures for table legs and rabbit fur. Regarding interaction generation, Set-the-Scene Cohen-Bar et al. () fails to create complex spatial relationships, as shown with the dog and the Great Pyramid in the first row. Although GALA3D can generate reasonable spatial relationships, it fails to incorporate mutual interactions between objects. This is because it performs compositional generation by optimizing the layout of each object individually, neglecting other inter-interactions such as the rabbit’s mouth on the cake and the dog’s paw on the plate. In contrast, CompGS generates higher-fidelity textures (e.g., the table body, rabbit fur) and more realistic interactions among objects (e.g., the dog’s paw hanging off the plate rather than just resting on top).

Qualitative Model Comparisons with Other Compositional Generation Methods In the main paper, we have compared CompGS with both open-sourced compositional 3D generation baselines (Set-the-scene and VP3D) in Table 1, and close-sourced baselines (GALA3D) in Figure 9. Results show that the 3D assets generated by CompGS are not only high-quality in appearance, but also align with the given prompts more strictly. We have included qualitative comparisons with both GraphDreamer Gao et al. () and DreamGaussian Tang et al. () in Fig. 10. Results show that CompGS demonstrates superior performance on both generation quality and text-3d alignment.

Figure: Figure 9: Qualitative Comparisons Between CompGS and 3D Scene Generation Methods. We selected the figures from Zhou et al. () for these comparisons due to the unavailability of the code. CompGS performs better in generating object textures and complex interactions.
Refer to caption: x6.png

Figure: Figure 10: Extended comparisons with GraphDreamer Gao et al. () and DreamGaussian Tang et al. ().
Refer to caption: x9.png

### A.5 Quantitative Model Comparisons

Tab. 5 presents the complete quantitative comparisons on all three tracks of $\mathrm{T}^{3}$Bench. The results indicate that CompGS achieved state-of-the-art performance in compositional generation and slightly outperformed competitors in the single object track. For instance, in the multiple object track, our model surpassed the second-best work Chen et al. () by 5.1 in quality and 6.4 in texture alignment. In the single object track, our model also slightly outperformed the second-best work Chen et al. () by 0.3 in both quality and alignment.

However, it is worth noting that our model did not achieve state-of-the-art performance in generating single objects with surroundings. This is attributed to the text-guided segmentation model we use, which does not effectively segment the background (e.g., ground, sky, etc.). We have explained this in Sec. 5 and leave it for future improvement. Despite a slight decline in our texture alignment metric in this track, our model still performed significantly better than other methods Tochilkin et al. (); Hong et al. (); Poole et al. (); Wang et al. (); Metzer et al. (); Chen et al. (); Wang et al. (); Lin et al. (); Cohen-Bar et al. (), except for VP3D.

### A.6 Examples in User Study

We provide examples of images and scenes used in our user study. In particular, we present concatenated rendering videos and ask participants to rank the eight methods shown in the video based on the overall quality of the 3D objects and the alignment between the text and the 3D models. We average the rank number as its ranking score for comparisons in Tab. 1.

Figure: Figure 11: Examples used in our user study.
Refer to caption: extracted/5958231/figures/user_study_1.png

### A.7 Robustness

We empirically found that CompGS demonstrates the ability to address certain deficits caused by off-the-shelf model priors (e.g., T2I and segmentation priors). Here are some illustrative examples: (1) If certain parts of the target objects are not correctly segmented, CompGS can complete the unsegmented part with correct 3D information. This is demonstrated in Fig. ???12(left), where the swing has not been segmented but has been generated by CompGS correctly. This is facilitated through the Entity-level Optimization procedure proposed in the DO strategy. (2) If the T2I models fail to generate proper intra-object interactions, CompGS can correct the multi-object interactions. This is shown in Fig. ???12(right), where the spatial relationships in the given image are incorrect and then corrected in the text-to-3D process. This is achieved by the Composition-level Optimization in the proposed DO strategy.

Figure: Figure 12: CompGS demonstrates the ability to address certain deficits caused by off-the-shelf priors.
Refer to caption: x11.png

### A.8 Failure Cases

Figure: Figure 13: Failure Cases of CompGS in background generation When text-guided segmentation mode fails to segment the backgrounds, CompGS may generate background with poor visual quality or fails to generate background.
Refer to caption: x12.png

As discussed in Sec. 5, CompGS exhibits limitations in generating backgrounds, such as ground and sky. This is likely due to the current text-guided segmentation model’s inability to effectively segment these abstract concepts. When the background is not well-segmented, we lose the corresponding 2D compositionality needed for initializing 3D Gaussians. This leads to two failure cases: (1) the absence of background in the compositional 3D scenes, as seen with the missing grass in the second column of Fig. 13, or (2) background generation of poor visual quality, such as the vague and unclear depiction of grass in the first column of Fig. 13. It’s crucial to note that such limitations, whilst exist, are not the focus of this work. These shortcomings can be overcome by enhancing the capabilities of off-the-shelf models, effectively mitigating the manifested issues.

### A.9 3D Editing Examples

CompGS offers a user-friendly approach to progressively conduct 3D editing for compositional 3D generation. More visual examples are presented in Fig. ???14. For instance, given a compositional prompt such as ‘A puppy lying on the iron plate on the top of the Great Pyramid, with a pharaoh nearby’, we divide the generation process into four stages. Initially, we generate ‘the Great Pyramid’ on the left, then progressively add ‘the plate’, ‘the puppy’, and ‘the pharaoh’ to complete the 3D scene. Notably, both the interactions and texture details can be well-produced during the editing pipeline of CompGS.

Figure: Figure 14: More examples of 3D Editing. CompGS provides a user-friendly way to progressively edit on 3D scenes for compositional generation.
Refer to caption: x14.png

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 6
presentation: 4
questions: 1. Can CompGS generate large-scale scenes, such as a beach, a cityscape, or a cozy bedroom?
2. Why did the authors choose Score Distillation Sampling (SDS) as the loss function for optimization instead of Variational Score Distillation (VSD)? Is there empirical evidence that SDS produces better results than VSD in this setting?
soundness: 4
strengths: 1. The innovative use of 2D compositionality to inform 3D initialization allows for the efficient and consistent generation of multi-object 3D scenes.
2. Dynamic optimization based on Score Distillation Sampling enables effective control over both fine-grained and large-scale details in 3D objects.
3. Quantitative and qualitative evaluations on T3Bench indicate high compositional integrity and visual quality, marking an improvement over existing compositional 3D methods.
4. The paper is well-structured and easy to follow, with a clear description of the models employed.
summary: This paper presents CompGS, a novel framework for compositional text-to-3D generation leveraging 3D Gaussian Splatting (GS) and Score Distillation Sampling (SDS) optimization. CompGS enables the generation of 3D content with multiple objects and complex interactions by decomposing and optimizing objects at both entity and composition levels, achieving enhanced detail in smaller objects through dynamic parameter adjustments.

Key contributions include transferring 2D compositionality from text-to-image models to initialize 3D Gaussian parameters, along with a dynamic optimization strategy based on Score Distillation Sampling (SDS) to maintain 3D consistency across objects.

CompGS demonstrates superior performance in compositional quality and semantic alignment compared to existing methods on the T3Bench dataset, also offering potential for controllable 3D editing.
weaknesses: 1. The paper lacks experiments that test small objects generation, such as creating a scene with a castle and a figure standing on it, where the model captures fine details in smaller objects.
2. The paper does not address scenarios involving scenes with a high density of entities, such as a garden with hundreds of entities. While generating scenes with only a few entities can be done manually by positioning objects individually, testing whether the model can generate large-scale scenes that align with the text description would better demonstrate its robustness.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: See the weaknesses section.
soundness: 3
strengths: The paper is well written and easy to follow. The generated results are significantly better than existing work。
summary: This paper introduce a text-to-3D scene generation method called CompGS, where a compositional optimization strategy is proposed to improve the generation of multiple objects.
weaknesses: 1. Object scale. This paper introduces a reasonable improvement by using rescaling during the entity-stage optimization. However, it does not address the scale relationship of the final generated objects. For instance, in Figure 1, the soccer ball and butterfly appear disproportionately large in the scene. I am curious if this is a bias introduced during training, as such issues do not typically arise in the inialization of text-to-image models. This could indicate a potential limitation in the current approach’s handling of object scaling.
2. Decomposing optimization: The decomposition approach does not consider the relationships between objects. The decompositional text embedding v_l may conflict with the actual 3D scene. For example, in Figure 4, the use of “a girl” as the text prompt to guide the SDS optimization generally results in a standing figure, which does not align with the curled posture of the girl in the scene. This discrepancy might impact the quality of the generated output, as evidenced by the slightly unnatural appearance of the girl in Figure 4.
3. Evaluation metrics: I think that CLIP can only evaluate the alignment between the generated output and the input text, but it does not adequately reflect the quality of the generation. The authors might consider incorporating aesthetic evaluation metrics, e.g., LAION Aesthetics Predictor [1] and PickScore [2], to provide a more comprehensive assessment of the aesthetic quality of the generated results.

[1] https://laion.ai/blog/laion-aesthetics. [2] Pick-a-Pic: An Open Dataset of User Preferences for Text-to-Image Generation.

---

confidence: 5
contribution: 2
initial_rating: 5
presentation: 3
questions: All questions are listed above in the weakness section. 
Overall:
- unclear component description regarding the LLM part and editing part.
- Insufficient comparisons to Gala3D.
- Limitations not discussed. 
- Some parts of the contributions not discussed enough.
soundness: 4
strengths: Overall, the paper is well-written and easy to follow. Most of the components are clearly described and explained. The visual results shown are of high quality. Reasonable quantitative comparisons and ablations are provided.
summary: This paper targets at compositional 3D object generation. The paper proposes an optimization-based pipeline to take advantage on off-the-shelf models like 2D generation model, image-to-3D model, LLM, and explicit 3DGS representation.
weaknesses: # Unclear components
- LLM: Using LLM to provide priors for compositional generation is currently a common approach (the most similar use case to this paper is SceneWiz3D ). However, some details are still desirable. For examples, what is the prompt? What is the usual success rate? Any failure case? 
- Editing: Is every component trained or only the added part? If they are all trained, how to keep the existing content unchanged? If only the added part trained, how to make sure it is compatible to existing components (as some editing might change existing part)?


# Comparison to Gala3D
- The paper mentioned the code/weight are not available. However, Gala3D does provide the code/weight via application.
- In L1061, the paper states "(Gala3D) fails to incorporate mutual interaction". I have reservations about the statement. For example, their teaser sample where an astronaut sitting on a couch, the interaction between the people and the couch is not trivial. 
-  One straightforward adaptation and ablation is to replace the LLM-provided 3D bounding boxes with the 2D+img-to-3D bounding boxes, w/ and w/o using the 3D as initialization.

# Limitation/Issues of the pipeline
There are some evident limitations not discussed.
- Semantic leak due to 2D model
1. Fig 9, last row: the leaf leaks to the hat, panda, and the couch
- 3D inconsistency and blurry boundary, due to image-to-3D and optimization
1. Fig 9, the rabbit: The blurring stuff under the table. And it looks very 3d inconsistent.
2. Fig 4, top-left: the left-most viewpoint, the boundary between the cake and the gift is blurred. Also, it looks very 3d inconsistent.
- Occlusion due to  2d/3d ambiguity
1. Fig3, last row: what does two silken look like separately? 
- Number of objects: The samples provided have number of objects less the five. In comparisons, Gala3D showed quite some samples with a larger amount of objects. Are there any hard constraint preventing the author to try the same prompts?

# Contribution: 
- Explicit representation: Replacing the representation itself it not a contribution. 
1. For example, how would set-the-scene perform if we replace its representation to GS?
2. L162 mentions SceneWiz3D is based on NeRF. However, they use NeRF for background and use meshes for foreground objects. 
- local-global optimization: It is not new in composition-aware generation, for example, set-the-scene adopt similar strategy. Some discussions and comparison are desirable. 

# MISC:
- Runtime in table 2: Are these results calibrates by number of object? Moreover, some of these methods include background, which is definitely an important factor to distinguish object-level and scene-level. This factor should also be considered in the table.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: After getting the image by T2I model, how do you initialize the center position for each object? Also, do you optimize object's position, scale, and rotation during optimization?
soundness: 3
strengths: (1) The paper is well-written and easy to follow.
(2) The proposed method is simple and easy to understand. Sufficient details are provided for the readers.
summary: This paper introduces CompGS, a method for compositional text-to-3D scene generation. It features 3D Gaussian Initialization combined with 2D compositionality and Dynamic Optimization to improve performance. Experimental results demonstrate that this approach outperforms the baselines.
weaknesses: (1) My concern about this paper is its limited novelty. While the results appear promising, I feel this paper may not provide substantial new insights for the readers.

(2) There is a lack of discussion regarding object interactions. In scenes with multiple objects, interactions are inevitable; however, the paper does not address how to manage complex interactions. For instance, if one object is obstructed by another in the image generated by T2I method, how should we effectively initialize and optimize the obstructed object?

(3) Some blurriness is noticeable in the results (for example, "An artistis painting on a blank canvas" in Fig 3, "a student is typing on his laptop" in Fig 4). The image quality falls short compared to other image-to-3D works, such as DreamCraft3D and DreamCraft3D++.

---

confidence: 3
contribution: 2
initial_rating: 5
presentation: 4
questions: 1. In the initialization of 3D Gaussians with 2D compositionality, how is the depth of entities determined, i.e., how is the distance from the entities to the screen calculated?
2. For entity-level optimization, in Equation (4), it seems that only translation and scaling are performed. Is rotation applied? How does CompGS handle entity-level optimization when the front view of an entity is not facing the front of the scene, or when the front views of two objects in the same scene differ by more than 90 degrees?
soundness: 3
strengths: 1. CompGS transfers 2D compositionality to facilitate composed 3D generation. Unlike previous methods such as GALA3D, which directly use LLM to provide layouts, this approach is more beneficial for initializing the Gaussians of objects with complex mutual interactions.
2. The proposed method is well-explained, and the experimental details are clearly presented. The approach is well-motivated, addressing real issues such as generating complex mutual interactions among objects and optimizing small objects during compositional 3D generation.
3. The experimental results are impressive, particularly the generated 3D humans and animals, which do not seem to suffer from the multi-view Janus Problem.
summary: This paper introduces CompGS, a method for generating 3D scenes involving multiple objects with complex interactions. The core design includes the initialization of 3D Gaussians with transferred 2D compositionality, alternating between entity-level and composition-level optimization, and dynamically maintaining volume consistency during entity-level optimization.
weaknesses: 1. The paper may not introduce many novel insights compared to previous methods. The dynamic optimization strategy of CompGS and the compositional optimization strategy in GALA3D[1] appear to be similar. Both alternate between composition-level optimization and entity-level optimization. GALA3D optimizes a single entity with a dynamic camera radius of $\frac{3}{4}\left\|\left(h_i, w_i, l_i\right)\right\|_2$ , which has an effect similar to the Volume-adaptively Optimizing Entity-level Gaussians in CompGS. Furthermore, the initialization of 3D Gaussians with 2D compositionality, compared to methods like REPARO[2] and ComboVerse[3], seems to add only an additional step. This step involves using 2D diffusion models to generate a well-composed image from a given prompt and obtaining entity-level prompts via LLM.

2. Semantic drift and pattern leakage: In Figure 5 of the appendix, the chair and hat exhibit leaf-like patterns similar to those of the ficus in a pot.

References:

[1] Zhou, Xiaoyu, et al. "Gala3d: Towards text-to-3d complex scene generation via layout-guided generative gaussian splatting." arXiv preprint arXiv:2402.07207 (2024).

[2] Han, Haonan, et al. "REPARO: Compositional 3D Assets Generation with Differentiable 3D Layout Alignment." arXiv preprint arXiv:2405.18525 (2024).

[3] Chen, Yongwei, et al. "Comboverse: Compositional 3d assets creation using spatially-aware diffusion guidance." arXiv preprint arXiv:2403.12409 (2024).