acceptodds
Under review as a conference paper at ICLR 2027

Gaussifier: Fast 2D Gaussian Decomposition

Abstract

2D Gaussians render images at thousands of frames per second. However, fitting an image takes seconds of optimization. This confines 2D Gaussians to offline use. Feedforward methods are faster but less accurate without per-image fine-tuning. We present Gaussifier, a lightweight feedforward framework for 2D Gaussian decomposition. We learn a density map of Gaussian centers from per-image fitting data. Equal-mass Voronoi places Gaussians so that each Voronoi cell holds approximately equal density. A stateless, reusable network then refines the output in a few iterations. Gaussifier reaches 40.73/38.61 dB PSNR on Kodak-24/DIV2K at over 60 FPS. At the same Gaussian count, it exceeds every feedforward baseline by 3.0 to 15.6 dB in PSNR. With fewer Gaussians than any baseline, it still leads the strongest one by 2.5 to 3.5 dB. At the same count, baselines with their own per-image fitting need 26 to 326 times longer to reach its PSNR. Gaussifier makes high-fidelity 2D Gaussian images fast and light enough for real-time applications.

Primary area:
unsupervised, self-supervised, semi-supervised, and supervised representation learning
Keywords:
Image Representation, 2D Gaussian Splatting, Feed-forward Prediction

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_o2K3OpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper introduces a feedforward method to git 2D Gaussians to images, without the tedious and slow optimization process. It uses a U-Net to predict 3 Gaussian attributes: density, log-covariance, and color. Then it uses mass-equal Voronoi to map the smooth density (due to the supervision) to proper Gaussian centers. Finally, a shared refinement network updates the Gaussian attributes using rendering residuals. Experiments show the effectiveness and fast fitting speed of the proposed method.

Critical strengths

Overall, the paper is well-written. Strengths:

  1. comprehensive experiments show this method is both faster and producing higher quality than previous gaussian image fitting methods.
  2. the use of classical Voronoi is elegant and an intuitive way to derive Gaussian centers from the smoothly-predicted density map. And the authors provide a fast implementation for it.
  3. training a feedforward network to directly predict Gaussians is a good way to avoid slow optimization-based fitting, which has been a trend in 3DGS. Here the authors follow the same principle and greatly improve the quality and speed of fitting 2DGS for an image, which is a meaningful contribution to this field.
Critical weaknesses
  1. The practical use of this work need to be explained in more detail. From the paper it seems using 2D Gaussians to fit an image does not decrease the storage size. In such case this technology's benefit remains unclear.
  2. Evaluation coverage is limited. The main results use 512 x 512 crops from two relatively small benchmarks. Does the method perform well on high-resolution images? And how does it perform on in-the-wild images?
Questions for authors
  1. Can the predicted Gaussians be integrated into an existing codec or downstream task to demonstrate an end-to-end benefit? For example from the perspective of compression, could you report actual bitrate–distortion results after quantization and coding, together with encoding and decoding costs?

  2. Can the authors evaluate their method on more diverse datasets, including maybe internet photos, to show that the method can actually generalize beyond the training distribution?

4 comments

We thank the reviewer for the positive assessment and the concrete suggestions.

Practical benefit and storage size. 2D Gaussian image compression depends mainly on the representation itself and its codec (quantization, entropy coding, etc.). How the Gaussians are produced, either by per-image fitting or feedforward, has limited effect on compression. Gaussifier targets a different problem that is orthogonal to compression.

  • The benefit we claim is speed and quality in producing Gaussian images.

    • Fitting cost is a recognized bottleneck. GaussianImage++ notes that its "encoding time is far from realtime". GSVC calls its encoding cost "a key limitation" and points to feed-forward 2D Gaussian reconstruction as the remedy. ContinuousSR (Peng et al., 2025, https://arxiv.org/abs/2503.06617) spent over 700 GPU-hours converting about 40k images into Gaussians to build its prior. GaussianVision replaces RGB pixels with 2D Gaussians as the visual input of vision-language models (VLMs). It fits all 12.8M training images, but with only 400–3,136 Gaussians per image. At Gaussifier's quality, the fitting time above adds up to about 2,100–16,000 GPU-hours for 12.8M images, against about 50 GPU-hours using Gaussifier. With Gaussifier, Gaussian-native models, such as Gaussian tokenizers for VLMs, are no longer limited by the fitting budget or the amount of data.
    • A downstream example in media content. To explore practical value, we extend Gaussifier to media content creation. A Gaussifier variant predicts high-fidelity planar 3D Gaussians from a single image in milliseconds. The result can be placed in existing 3DGS scenes as a 3D asset, e.g., for scene editing or logo/advertisement insertion in the media industry. We add a demo (https://gaussifier.github.io/demo3d/) at the anonymous repository in our reproducibility statement.
  • The count is learned, and the user can set it. The predicted 42.6k–72.2k Gaussian count is learned from our per-image fit data which reaches a median of 42.3 dB PSNR: it targets fidelity rather than compactness. Additionally, users can set the count, e.g., 20k in Table 1 or 1k to 10k in the codec study below.

Integration into the GaussianImage codec. In the study below, we follow GaussianImage's pipeline but replace its image overfitting stage with Gaussifier's prediction. We then apply GaussianImage's codec: FP16 positions, 6-bit Cholesky factors, 2-stage residual vector quantization of colors, quantization-aware fine-tuning, and entropy coding. We run both Gaussifier and GaussianImage at six Gaussian counts from 1k to 10k (0.23–2.1 bpp), and every rate is a real file size. BD-rate is the percentage of extra bits Gaussifier needs relative to GaussianImage for the same PSNR, averaged over the PSNR range the two methods share (the lower the better).

MethodBD-rate vs. GaussianImage, Kodak / DIV2KPSNR (dB) at 0.5 / 1 / 2 bpp, Kodak
GaussianImage0 / 027.32 / 29.37 / 31.82
Gaussifier−6.5% / −3.4%27.26 / 29.91 / 33.01

Per 512×512 image near 1 bpp on one L40S, encoding takes 48 s for GaussianImage and 1.8 s for Gaussifier, and both decode in 1.1 ms. Both encoding times include GaussianImage's quantization-aware fine-tuning stage, which needs 7k instead of 50k iterations when starting from Gaussifier. Gaussifier thus makes GaussianImage about 27× faster to encode, by replacing its costly image overfitting stage and shortening its fine-tuning. In addition, Gaussifier needs 6.5%/3.4% fewer bits than GaussianImage. We attribute this to Gaussifier's density-adaptive EMV placement, which GaussianImage's optimization from random positions does not recover.

In-the-wild and high-resolution images. Following the reviewer's suggestion, we add four datasets of in-the-wild images, including internet photos, at 512×512 (protocol of Table 1): COCO val2017 (Lin et al., 2014), CLIC2020 (Toderici et al., 2020), Urban100 (Huang et al., 2015), and Manga109 (Matsui et al., 2017). Gaussifier predicts how many Gaussians each image needs, while each baseline uses its own count. For a comparison at equal Gaussian count, we also run Gaussifier with exactly as many Gaussians as the baseline used on each image (the "Ours @" columns). At equal count, Gaussifier leads every baseline in the four new datasets, by 6.4–8.1 dB over AIR and Instant-GI and by 14.8–17.3 dB over Fast-2DGS, so the gain does not come from using more Gaussians.

Dataset (PSNR, dB)Ours (predicted N)AIROurs @ AIR's NInstant-GIOurs @ Instant-GI's NFast-2DGS (70k)Ours @ 70k
COCO val2017 (500 internet photos)40.6933.4240.2931.6038.7227.6343.12
CLIC2020 (41 professional photos)39.9330.8837.9130.0036.3626.6841.46
Urban100 (100, buildings)39.8528.0136.0627.5334.4222.5939.90
Manga109 (109, drawings)39.1628.8436.2527.2734.9823.0539.36

We also add full-resolution frames up to 2K. Since Fast-2DGS cannot choose its own count and 70k (set for 512×512) is small at 2K, we run it with Gaussifier's per-image count. Gaussifier stays above 40.7 dB on all three datasets, and at equal Gaussian count it still leads AIR and Instant-GI by 5.8–7.8 dB and Fast-2DGS by 14.6–17.0 dB.

Dataset (PSNR, dB)Ours (predicted N)AIROurs @ AIR's NInstant-GIOurs @ Instant-GI's NFast-2DGS @ Ours' N
Kodak-24 (768×512)40.7832.1739.9430.6737.8825.65
DIV2K valid (100, longest side 2040)40.9133.2340.0232.0638.5623.94
CLIC2020 (41, longest side 2048)40.7434.4140.2232.8138.6026.18

The reviewer is welcome to try Gaussifier on their photos in the browser, using the WebGPU demo at the anonymous link in our reproducibility statement.

Thank you for the additional experiments. The codec integration and broader evaluations address my main concerns. While wider downstream benefits remain unverified, I find the gains in Gaussian decomposition quality and speed meaningful. Please clarify the conditions of the real-time claim. I will maintain my score.

We thank Reviewer o2K3 for the follow-up and for finding the gains in quality and speed meaningful.

Conditions of the real-time claim. The paper reports about 14 ms per 512×512 image (73/68 FPS on Kodak-24/DIV2K) on one RTX 5090. This uses FP16 with TensorRT/AOTInductor compilation and the adaptive Gaussian count, at about 40 dB PSNR. The time covers the full pipeline from the input image to the final Gaussians, measured after warm-up passes. At 1280×720 the paper reports 20 FPS.

Faster implementation. Since submission, we further removed bottlenecks, fused the update kernels, froze the group normalization and captured the pipeline with CUDA graphs. The model is about 4× faster than the submitted implementation and recovered some precision loss (enables shorter refinement). The table reports the new timings on L40S and RTX 5090, with 5 and 7 refinement steps.

L40S (sm89):

ResolutionK=5 Latency (ms)K=5 FPSK=5 PSNR (dB)K=7 Latency (ms)K=7 FPSK=7 PSNR (dB)
512×5123.429240.234.621640.82
768×5124.920640.116.715040.82
1280×72012.97740.6118.75441.28
1920×108030.73341.0643.42341.65

RTX 5090 (sm120):

ResolutionK=5 Latency (ms)K=5 FPSK=5 PSNR (dB)K=7 Latency (ms)K=7 FPSK=7 PSNR (dB)
512×5122.343140.233.132140.82
768×5123.131840.114.323440.82
1280×7207.912640.6111.19041.28
1920×108017.55741.0624.54141.66

Gaussifier now runs >30 FPS at 1080p at >40 PSNR at one L40S (57 FPS at one RTX 5090). At the current processing speed, Gaussifier becomes a promising tool as a on-the-fly real-time processing tool for training, inference and other graphic applications. We will state these conditions in the revised manuscript and update the numbers.

The updated implementation is in the anonymous repository (https://github.com/Gaussifier/gaussifier).

Reviewer_SesAOpenReview ↗
Rating
1(−1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

The paper proposes Gaussifier, a lightweight feedforward method to decompose an input image to a set of 2D Gaussians withotu requiring optimization (more precisely, without requiring costly gradient backpropagation). The method consists of two main parts. First, a U-Net predicts pixel-wise density map of Gaussian centers/covariances/colors. An Equal-Mass Voronoi (EMV) sampling algorithm then partitions the normalized density into N Voronoi cells of approximately equal density mass. Next, a feedforward ReSplat-like optimizer predicts corrections in multiple steps that lead to improving the initial Gaussians. The method outperforms baselines and runs in real time on 512x512 images.

Critical strengths
  • The method achieves a significant PSNR improvement over existing feedforward 2DGS baselines (Instant-GI, AIR, Fast-2DGS) at matched or adaptive Gaussian counts, while running in real time (~14 ms per 512x512 image).
  • Formulating Gaussian center placement as an Equal-Mass Voronoi coverage problem (oversampling by 1.5N, merging lightest cells, and running 3 steps of Lloyd relaxation) effectively prevents clumping and gaps, outperforming standard dithering, random sampling, and pure Lloyd relaxation in ablations (Table 4). Essentially, this makes sure that we have a uniform coverage over the image which is intuitive and makes sense to me.
Critical weaknesses
  • I am very much uncertain about the practical value of the paper. While it motivates 2D Gaussians via downstream tasks (tokenization for VLMs, restoration, video coding), the experiments exclusively evaluate raw image reconstruction. As a representation/compression format, the numbers in Table 1 do not show an actual reduction in data size. Specifically, on a 512x512 image (262,144 pixels, or ~786 KB uncompressed at 24 bpp), Gaussifier uses an average of 42.6k to 72.2k Gaussians. Since each 2D Gaussian requires at least 8 float parameters, storing 42.6k-72.2k unquantized FP16/FP32 Gaussians requires more memory than the raw uncompressed RGB image. Even with heavy quantization, the paper provides no bits-per-pixel (bpp) rate-distortion curves or comparisons against standard image codecs (e.g., JPEG, WebP, ...) or neural codecs to justify why reconstructing an image with 70k Gaussians is advantageous over standard representations. This is a significant practical drawback that makes me hesitant to recommend acceptance. The authors must demonstrate some practice advantage that their method provides. I am also aware that this comment may hold for the baselines too, but it does not change the point.
  • I believe latency should scale linearly with pixel count (?) which would explain dropping from 68 FPS at 512x512 to 8 FPS at 1080p (Table 7). Furthermore, the headline 70 FPS speed comes from running on an NVIDIA RTX 5090 with TensorRT/AOTInductor FP16 compilation. With PyTorch FP32, the method runs at ~20 FPS (50 ms), where Fast-2DGS is 8x faster (6.3 ms, Table 6). So being real time is a little bit of a stretch. This is, in general, fine but this should be made very clear in the beginning that real time is real time on a top hardware and small images.
Questions for authors
  • What is the practical benefit of representing a 512x512 image (262k pixels) with 42.6k to 72.2k Gaussians (~340k to 577k scalar parameters)? In terms of storage size, this representation is not reduced and in unquantized form, is larger than the raw pixel grid. How does Gaussifier compare on a rate-distortion (PSNR vs. bits-per-pixel) curve with standard image compression techniques (e.g., JPEG2000, WebP, ...) to preserve resolution/sharpness/etc.?
  • A potential advantage of continuous 2D Gaussians over discrete pixel grids is the resolution-free rendering. How do the Gaussians predicted by the proposed method at 512x512 perform when rendered at 2x or 4x resolution compared to bicubic interpolation/super-resolution baselines?
6 comments

We thank the reviewer for the detailed review and for recognizing the PSNR gains and the role of EMV.

Practical benefit and storage size. 2D Gaussian image compression depends mainly on the representation itself and its codec (quantization, entropy coding, etc.). How the Gaussians are produced, either by per-image fitting or feedforward, has limited effect on compression. Gaussifier targets a different problem that is orthogonal to compression.

  • The benefit we claim is speed and quality in producing Gaussian images.

    • Fitting cost is a recognized bottleneck. GaussianImage++ notes that its "encoding time is far from realtime". GSVC calls its encoding cost "a key limitation" and points to feed-forward 2D Gaussian reconstruction as the remedy. ContinuousSR (Peng et al., 2025, https://arxiv.org/abs/2503.06617) spent over 700 GPU-hours converting about 40k images into Gaussians to build its prior. GaussianVision replaces RGB pixels with 2D Gaussians as the visual input of vision-language models (VLMs). It fits all 12.8M training images, but with only 400–3,136 Gaussians per image. At Gaussifier's quality, the fitting time above adds up to about 2,100–16,000 GPU-hours for 12.8M images, against about 50 GPU-hours using Gaussifier. With Gaussifier, Gaussian-native models, such as Gaussian tokenizers for VLMs, are no longer limited by the fitting budget or the amount of data.
    • A downstream example in media content. To explore practical value, we extend Gaussifier to media content creation. A Gaussifier variant predicts high-fidelity planar 3D Gaussians from a single image in milliseconds. The result can be placed in existing 3DGS scenes as a 3D asset, e.g., for scene editing or logo/advertisement insertion in the media industry. We add a demo (https://gaussifier.github.io/demo3d/) at the anonymous repository in our reproducibility statement.
  • The count is learned, and the user can set it. The predicted 42.6k–72.2k Gaussian count is learned from our per-image fit data which reaches a median of 42.3 dB PSNR: it targets fidelity rather than compactness. Additionally, users can set the count, e.g., 20k in Table 1 or 1k to 10k in the following rate–distortion study.

Rate–distortion study. As the reviewer anticipated, rate–distortion is a property of the Gaussian representation and its codec, including the baselines. In the study below, we follow GaussianImage's pipeline but replace its image overfitting stage with Gaussifier's prediction. We also apply GaussianImage's codec: FP16 positions, 6-bit Cholesky factors, 2-stage residual vector quantization of colors, quantization-aware fine-tuning, and entropy coding.

We run Gaussifier at six Gaussian counts from 1k to 10k (0.23–2.1 bpp), and every rate is a real file size. Published Gaussian codecs report gains over JPEG at low rates, and our measurements confirm this. At 0.25 bpp, Gaussifier reaches 25.01 dB on Kodak and 21.37 dB on DIV2K, 0.7 and 0.9 dB above JPEG (24.35 and 20.48 dB), and stays ahead up to about 0.29 and 0.32 bpp. At higher rates, JPEG and other standard and neural codecs remain ahead of Gaussian methods. The full comparison is shown below. BD-rate is the percentage of extra bits for the same PSNR, averaged over the PSNR range each method shares with JPEG (the lower the better).

MethodBD-rate vs. JPEG, Kodak / DIV2K
JPEG0 / 0
JPEG2000− 12% / −15%
WebP−38% / −36%
Hyperprior (Ballé et al., 2018)−54% / −47%
Mean-scale (Minnen et al., 2018)−57% / −49%
GaussianImage+51% / +33%
Gaussifier+41% / +27%

Within 2D Gaussians, Gaussifier needs 6.5%/3.4% fewer bits than GaussianImage. We attribute this to Gaussifier's density-adaptive EMV placement, which GaussianImage's optimization from random positions does not recover.

Resolution-free rendering. As the reviewer points out, this is an advantage of 2D Gaussians over discrete pixel grids: like vector graphics, they are a continuous representation. An image is decomposed once, and the same Gaussians can then be rendered at any resolution.

We test resolution-free rendering on 100 unseen DIV8K (Gu et al., 2019) images, comparing against bicubic, SwinIR (Liang et al., 2021), a learned super-resolution model, AIR, Instant-GI, and Fast-2DGS. All methods take the same 512×512 input, downsampled from a 2048×2048 crop. PSNR and SSIM are computed on the Y channel with a ⌈s⌉-pixel border shave, as is conventional in super-resolution.

Method×2 PSNR / SSIM×3 PSNR / SSIM×4 PSNR / SSIM
Gaussifier32.76 / 0.89930.86 / 0.83429.63 / 0.782
Bicubic32.64 / 0.89730.79 / 0.83429.56 / 0.784
AIR29.94 / 0.81728.76 / 0.75927.92 / 0.725
Instant-GI29.46 / 0.82028.38 / 0.76327.59 / 0.729
Fast-2DGS26.54 / 0.68625.91 / 0.66725.41 / 0.659
SwinIR36.27 / 0.94933.70 / 0.90031.90 / 0.853

Gaussifier is slightly better than bicubic in PSNR at every scale (+0.07 to +0.12 dB), and 1.7–6.2 dB above the other feedforward baselines. SwinIR, a network trained specifically for super-resolution, remains 2.3–3.5 dB higher, as expected. However, Gaussifier decomposes once and renders all six tested scales (×1.5 to ×4) in 62 ms, while SwinIR takes 4 s (both eager PyTorch FP32 on one NVIDIA L40S).

Real-time claim and latency. We will add "512×512 on an RTX 5090 with TensorRT/AOTInductor FP16", with the eager PyTorch FP32 number next to it in the revised paper.

  • Scaling. Yes, latency grows about linearly with pixel count. From 512×512 to 1280×720 to 1920×1080, pixels grow 3.5× and 7.9×, and latency grows 3.5× and 8.5×.

  • Fast-2DGS. Fast-2DGS is about 8× faster than Gaussifier in both runtimes: 6.3 vs. 49.6 ms in PyTorch FP32, and 1.7 vs. 13.7 ms compiled. This speed comes with a large quality gap. At its 50k/70k count, Fast-2DGS is 15.6/15.1 dB below Gaussifier. With a single update, Gaussifier takes about 4.5 ms (roughly one-third of 13.7 ms) against 1.7 ms for Fast-2DGS (both compiled), and is 8.3–9.5 dB higher (Table 9). With all methods compiled and the same per-image Gaussian count as each baseline, a single Gaussifier update already matches or exceeds the PSNR of AIR and Instant-GI, 2.7–7.3× faster than these baselines. Only AIR ps7 on DIV2K needs a second update, which takes 6.1 ms and is still 2.0× faster (Table 9). Gaussifier thus combines high fidelity with interactive rates.

I thank the authors for running the rate-distortion and multi-scale rendering experiments and for the clarifycation. While I appreciate the effort, the new results actually confirm my main concern rather than resolving it: there is still no demonstrated practical benefit to representing a 2D image with tens of thousands of Gaussians.

Compression & Upscaling Show No Practical Gain: The rebuttal experiments rule out the two most natural advantages of a continuous 2D representation:

  • Compression: If I understand correctly, Gaussifier requires +27% to +41% more bits (BD-rate) than standard JPEG for the same quality, and sits dramatically behind WebP (−36% to −38%) and neural codecs (−47% to −57%).
  • Resolution-Free Rendering: At x2 to x4 upscaling, Gaussifier performs essentially identically to bicubic interpolation (+0.07 to +0.12 dB PSNR, and 0.782 vs. 0.784 SSIM at x4), while trailing SwinIR by 2.3-3.5 dB.

The Pivot to Downstream Preprocessing Is Unvalidated: Since compression and upscaling are uncompetitive, the rebuttal pivots to speed in generating training inputs for "Gaussian-native" models (e.g., VLM tokenizers or SR priors) and planar 3D asset insertion. However, none of these downstream tasks are quantitatively evaluated in the paper:

  • GPU-hour estimates on external datasets do not demonstrate that replacing pixels (or compact 400-3k per-image fits) with Gaussifier's predictions actually preserves or improves downstream VLM or restoration accuracy.
  • Inserting a flat 2D logo or poster into a 3D scene is trivially handled by a standard textured quad or billboarding without requiring tens of thousands of planar Gaussians.

The rebuttal confirms that the representation fails to beat basic baselines (JPEG, bicubic) on standard image tasks while leaving its claimed downstream utility untested. Since I see now clearly demonstrated practical value enabled by the proposed method, I am lowering my score to a clear reject.

Reviewer_2Vs6OpenReview ↗
Rating
3
Confidence
4
Informativeness
3
Presentation
2
Soundness
3
Read review
Paper summary

This paper introduces a feed-forward framework which decomposes an img into many 2D Gaussian primitives (position, covariance, color etc) in real time, thus does not require the long per-image optimization that previous methods may need. It has 3 steps:

  • A small U-Net predicts a Gaussian-center density map,
  • EMV( equal-mass Voronoi) sampling turns that density map into N initial 2D gaussians
  • A stateless refinement U-Net iteratively corrects all Gaussians from the rendering residual in 6 forward passes.

The method has good results. The author claims that it " leads the strongest [previous method] by 2.5 to 3.5 dB", or " leads every baseline by over 8 dB", depending on different metrics.

Critical strengths
  • This method replaces long per-image optimization with a trained feedforward pipeline, and the 3-step pipeline of the method seems reasonable. The design is technically clean and straight-forward. CVT/EMV-like geometric method provides good stability of predicted GS positions.

The technical soundness is good. The reported speed of EMV aligns with my experiences in geometry processing.

  • The method has great results: (at matched gaussian counts) it exceeds feedforward baselines by 3.0–15.6 dB. The method runs at 60+ FPS, and baseline methods need 26–326× longer with their own fitting to reach the same PSNR.

  • I do appreciate the authors for providing the open-source code & demo.

Critical weaknesses

NA - see questions

Questions for authors

I am good with most technical contributions. However, this paper looks (a little little bit) like combining two blocks of ReSplat and Instant-GI. Giving some more clarification would be great.

This method deals with 2D images. While I like Gaussifer, I have to say that the task it self, converting 2D img to 2D GS, is relatively trivial. Some other work (e.g., CVT-GS, https://arxiv.org/pdf/2609.08730) already used CVT/EMV for gaussaians (and even in 3D). I wonder if the authors could discuss more about the potential of extending Gaussifier to 3D.

2 comments

We thank the reviewer for the positive assessment, and in particular for confirming that the EMV runtime matches their experience in geometry processing.

Relation to ReSplat and Instant-GI.

Gaussifier differs from both works in each of its three components: how the count is set, where Gaussians are placed, and how they are refined.

Instant-GIReSplat (3D)Gaussifier
Densityper-pixel probability in [0,1]—expected count per pixel (Poisson loss), its sum is the count N
Count controlinteger max-pooling kernel size k before ditheringfixed by input pixelsany N, predicted or user-set
Placementdithering on a k×k block grid, one Gaussian per Delaunay trianglepixel-aligned (subsampled)equal-mass Voronoi
Refinement—recurrent, per-Gaussian hidden state, kNN attention over neighborsstateless image-space U-Net (0.75M parameters), no hidden state
Cost per update—grows with Nnetwork cost independent of N

Dithering in Instant-GI matches the local count, but its cells hold unequal density mass. EMV approximately equalizes it and gains 2.59/2.20 dB over error-diffusion sampling on Kodak-24/DIV2K. Unlike ReSplat, our refinement keeps no per-Gaussian state, so the model serves any N at a cost independent of N.

CVT-GS and extension to 3D.

While representing 2D signals with 2D primitives is conceptually intuitive, achieving real-time, high-fidelity decomposition without per-image optimization has been a challenge. Before this work, feedforward methods stayed far below per-image fitting.

Thank you for pointing us to the concurrent CVT-GS at https://arxiv.org/pdf/2609.08730. We will cite it to provide a more comprehensive discussion of the related work. The two methods use Voronoi cells for different purposes:

  • CVT-GS simplifies a trained 3DGS scene. It clusters the existing Gaussian centers with five iterations of opacity-weighted Lloyd relaxation, and a learned network merges each cell into one Gaussian.

  • EMV places new Gaussians from a density map ρ predicted from the image. It approximately equalizes the density mass per cell, which matches our density's meaning as an expected count to represent the image. Standard Lloyd relaxation does not equalize mass. In 2D it spreads centers in proportion to ρ^(1/2) and under-serves detailed regions.

Three components in Gaussifier should carry over to 3D:

  1. Learned allocation. Pixel-aligned models (pixelSplat, MVSplat, GS-LRM) allocate a fixed number of Gaussians per pixel regardless of content. A per-view predicted density map with its sum setting the count would give each scene and region an adaptive budget.

  2. EMV. It can run in each view's image space, with depth predicted per Gaussian, or in 3D on a voxel grid, since jump flooding extends to 3D. CVT-GS shows that Voronoi partitions over 3D Gaussian centers are practical at scene scale.

  3. Stateless refinement. Render each input view, compute residuals, and let an image-space network predict Gaussian updates. Without per-Gaussian state, the cost mainly scales with the number of views and pixels, not with N.

However, some parts do not transfer directly. For example, 3DGS uses alpha compositing rather than additive rendering in 2D, so a Gaussian's effect depends on depth order and occlusion. Our cell-mass color weighting relies on additivity and would need an opacity-based counterpart.

Thank you to the authors for tte detailed response, which has largely addressed my concerns. However, I agree with Reviewer SesA that the practical utility and downstream applications of the proposed method remain questionable compared to traditional approaches. Therefore, I am unable to raise my score, and will maintain my current borderline accept rating. As an additional suggestion, (as we have discussed previously) exploring a similar task in 3D might be a more meaningful direction that has better downstream tasks.

Comments on the paper

4 comments
AuthorsOpenReview ↗

General Response

We thank all reviewers for their careful reading and constructive suggestions. All three reviewers recognized the gains in quality and speed and found the equal-mass Voronoi placement intuitive. Reviewers SesA and o2K3 asked about storage size and compression, and Reviewer SesA further questioned the practical value of 2D Gaussian images. We answer both briefly here and give the details in the individual responses.

Compression is not what this paper claims. The submission makes no compression claim. Gaussifier addresses how fast and how faithfully Gaussian images are produced. Rate–distortion depends mainly on the representation and its codec, not on how the Gaussians are produced. With GaussianImage's codec, the representation is ahead of JPEG only at low rates (below about 0.3 bpp). We agree that 2D Gaussians are not yet competitive with standard codecs for storage. They serve as a working representation, not a storage format.

The practical value lies in properties that a pixel grid lacks. 2D Gaussians are explicit, continuous, and content-adaptive point cloud. Published work uses them as visual tokens (GaussianVision, GPSToken, GViT), for restoration and super-resolution (LL-GaussianImage, GaussianSR, ContinuousSR), for editing (MiraGe), and for rendering at over 1,000 FPS (GaussianImage, GSVC). The representation is recent, and its use has been bottlenecked by slow per-image fitting and by the quality gap of feedforward prediction.

We address both bottlenecks, fitting speed and the quality gap. Gaussifier produces Gaussians of optimization-level quality in under 15 ms at any user-set count. At the same Gaussian count, it exceeds every feedforward baseline by 3.0 to 15.6 dB, and baselines with per-image fitting need 26× to 326× longer to reach its PSNR. This enables the real-time and large-scale uses of 2D Gaussians that were impractical before.

New experimental results in the individual responses.

  • Integration into GaussianImage's codec, with 27× faster encoding, 6.5%/3.4% fewer bits, and comparisons against JPEG, JPEG2000, WebP, and two neural codecs.
  • Four more datasets (COCO, CLIC2020, Urban100, Manga109) and full-resolution images up to 2K.
  • (NEW) Demonstrated resolution-free rendering and meaningful super-resolution capability. Gains 3.0 &1.9 dB over bicubic at x2 & x4 on SR datasets
  • (NEW) Further improved the inference speed by 4x with a native CUDA inference engine, achieving video rate at 1080p resolution.

Dear Authors,

All reviewers raise the question about the practical value of this work. Could you clearly illustrate the concrete downstream tasks benefited from this representation?

Could you show some evidence, like some successful cases reported in existing literature?

Thank you for calling a discussion on practical value and downstream tasks of gaussian image representation. Published work already uses them for vision-language models, editing, restoration, super-resolution, etc (Lines 026-028 and 076-085). Gaussian images have many advantageous properties. Fitting speed is a draw back of all existing methods, which we address here.

Vision-language models - Gaussians efficiently encode location and appearance

  • GaussianVision (CVPR 2026 Highlight) feeds 2D Gaussians instead of pixels to CLIP, trained on 12.8M 224x224 images fitted to 400-3136 Gaussians each. It is competitive in zero-shot accuracy on 38 datasets with 3x to 23.5x smaller inputs, and with half the tokens it exceeds the RGB model (Table 5). In a LLaVA-style VLM, it outperforms the RGB baseline on 6 VQA benchmarks. The authors call Gaussians "a promising representational layer for multimodal learning". They state that existing 2DGS pipelines are still too slow (Sec. 4.1) and they list this cost as a limitation (Sec. 6). Gaussifier outputs the same format in a few milliseconds, which could move data prep from offline pre-fitting to on-the-fly inference.
  • The model is not yet released, so we could not test it.
  • We tested their released batched per-image fitting code. At equal quality, Gaussifier decomposes 56x more images, essentially eliminating the need for preprocessing.
    60 s on one L40SGaussifierGaussianVision fitter
    Equal quality (30.8 dB PSNR)57,371 images1,024 images
    Equal count (~57k images)30.8 dB20.7 dB

Image super-resolution - Gaussian images are continuous distribution and fast to render

  • Pixel to Gaussian (ContinuousSR, ICLR 2026) predicts a 2D Gaussian field from a low-resolution image in one pass. It reports SOTA results on seven benchmarks and a 19.5x speedup across 40 scales, rendering each scale in 1 ms. It avoids per-image fitting, which it calls "impractical for real-world applications" (App. A.4). To train this model, its prior fits 40k Gaussian images optimized in over 700 GPU-hours (Sec. 4.2), a step the authors call labor-intensive (Sec. 6). Gaussifier fits this amount of images in minutes, building training datasets much more quickly.
  • Gaussifier also demonstrates some super-resolution (SR) capability. In a preliminary study suggested by reviewer, fine-tuning Gaussifier for SR with 24000 steps improved PSNR over bicubic by 3.0/1.9 dB at x2/x4, averaged over Set5, Set14, B100 and Urban100.
  • Demo: https://gaussifier.github.io/demosr/
  • Code: https://github.com/Gaussifier/gaussifier-sr

Color dequantization and editing - Gaussian images are dequantized (uint8 > float) and differentiable

  • Dehaze-GaussianImage (2026) fits 2D Gaussians to hazy images by per-image optimization, then dehazes in Gaussian space. Slow per-image fitting was listed as a limitation.
  • For a preliminary demo using the released code, we replaced the fitting with Gaussifier and left other released code unchanged. On 100 SOTS-outdoor images: Fitting time: 112 s → 0.07 s. End-to-end: 182 s → 69 s (2.7x faster). Dehazing PSNR: 18.47 → 20.51 dB. SSIM: 0.790 → 0.842. We believe the better PSNR attribute to a better distribution/initiation of the gaussians.

Editing and simulation - Gaussians are editable point clouds

  • MiraGe (ICML 2025) encodes images as flat Gaussians. Users can edit the gaussians directly and drive them with physics engines. MiraGe took ~7-21 minutes per image to train (Table 2). Our planar 3D variant produces the same result instantly. Like vector shapes, Gaussians are explicit primitives, so they directly support instruction-based editing by frontier LLMs without image generation.
  • We prototyped MiraGe-Gaussifier-MCP to demo this utility, and validated the concept with opus 5.5 making edits.
  • Demo/Code: https://github.com/Gaussifier/mirage-gaussifier-mcp

Scientific visualization - Gaussian voxels for rendering

  • Luxar (CZ Biohub, 2026) https://github.com/royerlab/luxar is a tool for 3D scientific data visualization. It decomposes a 3D voxel grid directly into Gaussians, as we do for a 2D pixel grid (not from camera views as in 3DGS). A 3.6 GB microscopy volume becomes 2.0 MB and renders in a browser. Its fitting is slow and offline.
  • A fast decomposer would allow streaming of large 3D data during a live session or process data without a high-end GPU.
  • Gaussifier framework can extend to voxel grids by training on volumetric data, which we are now exploring.

In summary, Gaussian image representation is very new. Early work focused on compression, and we feel this has hidden their real value. Their beauty is in properties that pixels do not have. They are sparse, continuous, and differentiable. Almost every work above shows that slow fitting is a bottleneck. Gaussifier makes the process realtime and enables broader, larger scale downstream applications.

Dear Reviewers,

Before DDL, maybe you can leave some comments and questions for authors?

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.