GS-TG: 3D Gaussian Splatting Accelerator with Tile Grouping for Reducing Redundant Sorting while Preserving Rasterization Efficiency

Jongsun Park; Joongho Jo

REVIEW 3 major objections 5 minor 1 cited by

GS-TG: 3D Gaussian Splatting Accelerator with Tile Grouping for Reducing Redundant Sorting while Preserving Rasterization Efficiency

T0 review · 3 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A tile-grouping scheme lets 3D Gaussian Splatting sort in large groups but rasterize in small tiles, cutting redundant work without changing the output.

desk verdict Genuinely new tile-grouping idea with real hardware work, but the losslessness claim is never tested and the abstract overstates the speedup. read the letter →

arxiv 2509.00911 v2 pith:ZFXKSTNQ submitted 2025-08-31 cs.AR cs.CV

Joongho Jo , Jongsun Park This is my paper

classification cs.ARcs.CV

keywords 3DGaussianSplattingtilegroupingbitmasksortingrasterizationhardwareacceleratorlosslessrenderingnovelviewsynthesis

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

3D Gaussian Splatting renders scenes tile by tile, and the tile size forces a trade-off: larger tiles repeat fewer sorting operations but force each pixel to test many Gaussians that do not affect it, while smaller tiles do the opposite. GS-TG claims to break this trade-off by sorting once per group of small tiles, as if the group were one large tile, then using a per-Gaussian bitmask to route only the relevant small tiles into rasterization. The paper argues the method is lossless—same pixels as the original pipeline—because the small tiles are perfectly aligned inside the group, so any Gaussian that touches a small tile also touches the group. The payoff would be a 3D-GS accelerator that gets large-tile sorting savings and small-tile rasterization efficiency at the same time, with up to 1.54x speedup over the prior state-of-the-art accelerator.

What carries the argument

Tile grouping with perfect alignment, plus a per-Gaussian bitmask. The group plays the role of a large tile for preprocessing and sorting; the bitmask (16 bits for 16 small tiles) encodes, for each Gaussian, which small tiles it influences, letting the rasterizer reuse the group-sorted order while touching only the relevant small tiles. The alignment condition—small tiles must tile the group exactly—is the property that makes the method lossless, since any Gaussian reaching a small tile must also be in the group's candidate list. The hardware's bitmask generation module and group-wise sorting module run in parallel to hide the added preprocessing.

What would settle it

Run the authors' GS-TG CUDA implementation and the original GSCore release on identical pre-trained models and measure wall-clock FPS; if GS-TG does not beat GSCore on the same six scenes, or if the cycle simulator reproduces measured GPU times only when GSCore is modeled with a handicap, the 1.54x claim fails. A second check: render a scene with and without tile grouping and compare pixel outputs bit-for-bit—any mismatch would falsify the lossless claim.

Watch

Extended reading notes

Core claim

The paper's central claim is that sorting and rasterization do not have to share a tile size. GS-TG groups, say, sixteen 16x16 tiles into a 64x64 group; Gaussians are identified and depth-sorted at the group level, which cuts redundant sorting because far fewer groups exist than small tiles. A 16-bit bitmask per Gaussian records which small tiles in the group it actually touches, and rasterization consumes the group-sorted list only for the bits that are set. Because the small tiles align exactly with the group boundary, the set of Gaussians affecting any small tile is a subset of the group's set, so rasterizing with group-sorted data and bitmask filtering produces output identical to the or

Load-bearing premise

Comparison to GSCore is credible only if the authors' cycle-level simulator implements GSCore's tile-selection logic, memory system, and operating frequency faithfully; the paper does not specify how GSCore is configured inside the simulation.

Editorial extensions

If this is right

The sorting bottleneck of small-tile rendering shifts from per-tile to per-group, so the cost of sorting grows with scene complexity rather than with tile count.
Rasterization stays at small-tile granularity, avoiding the wasted alpha computations that large tiles cause.
The method is drop-in lossless: no retraining or fine-tuning, and it can be combined with compression, densification, or pruning techniques.
A specialized accelerator can hide the bitmask-generation cost behind sorting; the paper reports energy-efficiency gains of 2.12x geometric mean.
Speedups grow with resolution—the largest reported gains (1.58x over baseline, 1.54x over GSCore) appear on the highest-resolution scenes.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The same group-and-bitmask pattern could be applied to other per-tile rendering stages, such as visibility culling or shading, wherever redundant per-tile work tracks tile count.
Group size is a tunable knob: the paper's measurements suggest a 16x16 tile with 64x64 groups is fastest, but adaptive group sizes per region (larger groups in sparse areas) could push further—a testable extension the paper does not explore.
The bitmask is compact only because of alignment; relaxing alignment would require per-Gaussian tile lists and would erode the claimed losslessness without extra bookkeeping.
On a GPU, the paper reports preprocessing slowed because bitmask generation serializes with sorting; if future GPUs expose explicit warp-level overlap, the software path might approach the accelerator's speed without new hardware.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

You should know this paper before anything else: the core idea is real and worth your time. Decoupling sorting tile size from rasterization tile size via grouped sorting plus a per-Gaussian bitmask is a clean trick—I don't see it in GSCore or FlashGS, and it directly attacks a real bottleneck (redundant per-tile sorting). The hardware is also a serious engineering effort: RTL synthesis, area/power numbers, a cycle-level simulator. That part is not hand-wavy.

The trade-off analysis in Section III is genuinely useful and the paper is honest about the GPU implementation's sequential bottleneck, which the accelerator is meant to fix. The compatibility with AABB/OBB/Ellipse boundary methods is a nice property.

Now the soft spots, in proportion. The biggest one: the paper claims losslessness in the abstract, Section IV.B, and conclusion, but never actually shows it. There is no PSNR/SSIM or any image-quality comparison anywhere in the evaluation—only speed and energy. That is not a minor omission; the whole value proposition is that you get speed without changing the output. And the bitmask generation module uses opacity in addition to 2D_XY/2D_Cov, which is not the same as the standard tile-selection criterion used by the baseline. It may be a tighter or looser test, but the paper never specifies, and without a proof or an image comparison, the lossless claim is unsupported. That is a load-bearing gap, but it is fixable: either formalize the BGM condition and prove it subsumes the baseline tile list, or report image quality metrics.

Second, the abstract says "average speed-up of 1.54 times" but the body reports a geometric mean of 1.33x and a max of 1.54x. Those are different claims. The abstract should be corrected. Third, the GSCore baseline is under-specified—just "conventional 3D-GS with Ellipse boundary on the proposed accelerator," with no details on how GSCore's tile-selection logic and memory system are configured. That makes the head-to-head number hard to judge. Fourth, the 16x16/64x64 tile/group choice is made from the same experiments used to report speedups. That is mild self-tuning, but worth flagging as possible optimism.

The paper deserves a serious referee. It has a novel method and real hardware work. A revision that adds image-quality validation and fixes the abstract and baseline description would be a solid contribution to the 3D-GS accelerator subfield. I'd bring it to a reading group only if you work on rendering hardware; otherwise it's a useful reference for the tile-grouping idea.

Referee Report

3 major / 5 minor

Summary. The paper proposes GS-TG, a hardware-software co-design for 3D Gaussian Splatting (3D-GS) rendering. The key idea is to perform tile sorting at a large granularity by grouping small tiles (e.g., 16×16 tiles into 64×64 groups), while rasterizing at the original small-tile granularity using per-Gaussian bitmasks that identify which small tiles are affected. The authors argue this is lossless because small tiles are perfectly aligned within groups, and it avoids the usual trade-off where large tiles reduce sorting cost but increase rasterization waste. They present a GPU implementation, an RTL hardware design with BGM/GSM/RM modules, and evaluation on four/six scenes from Tanks&Temples, Deep Blending, Mill-19, and UrbanScene3D. They report speedups over a GSCore baseline and over a conventional 3D-GS baseline on their own accelerator, with up to 1.54× speedup over GSCore and energy efficiency improvements.

Significance. If the losslessness claim holds, the core idea is a clean and useful systems insight: decouple sorting granularity from rasterization granularity via bitmask filtering. The paper includes a concrete accelerator implementation with synthesis results, power/energy estimates, and a cycle-level simulator, which are valuable contributions. However, the central losslessness claim is not verified: the hardware bitmask generation module uses opacity as an additional input not present in the standard tile-selection definition, and no rendered-image quality comparison is reported anywhere. The GSCore baseline is also under-specified, undermining the headline speedup comparison. These issues are fixable but currently leave the main claims without sufficient support.

major comments (3)

[Sec. IV.B, Sec. V.B, Sec. VI.B/VI.C] The losslessness claim is load-bearing but unverified. Sec. IV.B states that aligned small tiles guarantee lossless results, but Sec. V.B says the BGM determines tile influence using opacity (σ) in addition to 2D_XY and 2D_Cov, whereas the standard tile identification in Sec. II.B uses only 2D_XY and 2D_Cov. The paper does not explain how including opacity preserves the exact per-tile Gaussian lists or the final rendered image. Moreover, Secs. VI.B and VI.C report only speed and energy, with no PSNR/SSIM/max-error or bit-exactness comparison. Please provide either a formal equivalence proof or an empirical rendered-image comparison; otherwise the 'lossless' claim is unsupported.
[Sec. VI.C, Abstract, Conclusion] The GSCore baseline is not described sufficiently to make the speedup comparison reproducible. The text only says the baseline is 'conventional 3D-GS rendering using the Ellipse boundary running on the proposed accelerator'; it does not specify GSCore's tile selection logic, memory system, operating frequency, or how the cycle-level simulator models GSCore. Without this, the 'up to 1.54×' speedup over GSCore cannot be assessed. Additionally, the abstract claims an 'average speed-up of 1.54 times,' while Fig. 14 shows a geometric mean of 1.33× over the baseline and 1.54× only as a maximum in one scene; the conclusion says 'up to 1.54 times.' Please correct the abstract to match the data.
[Sec. VI.B, Fig. 11] The choice of 16×16 tile size and 64×64 group size is based on Fig. 11, which uses the same four scenes later used to report the main speedups. This creates a risk of overfitting the configuration to the benchmark. Please report sensitivity to this choice on held-out scenes, or justify the choice with a separate validation split.

minor comments (5)

[Sec. V.B, Fig. 10] The block diagram is hard to follow: it shows multiple 'Tile Check Unit' instances and repeated bitwise AND/OR blocks, but the text says 'Four tile check units operate in parallel.' Please clarify the exact number of tile check units and how they map to the 16-bit bitmask.
[Sec. VI.B, Fig. 12] The color legend for Fig. 12 is confusingly described. Please clarify the correspondence between colors, boundary methods in the group-identification step, and boundary methods in the bitmask-generation step, preferably with explicit labels like 'AABB+AABB'.
[Sec. IV.B] The claim that GS-TG 'can be seamlessly integrated with previous 3D-GS optimization techniques' is not demonstrated beyond testing AABB/OBB/Ellipse boundary methods. Please either soften the claim or provide an example integration with, e.g., pruning/quantization.
[Sec. VI.A] The text says models are converted from 32-bit to 16-bit floating point. Since the losslessness claim is about the rendering algorithm, please clarify whether the 16-bit conversion is applied equally to baseline and GS-TG, and whether it affects image quality.
[Sec. III.B, Table I] Table I reports only percentages of Gaussians shared with adjacent tiles. It may be more informative to also report the absolute number of redundant sort operations, since that is what the proposed method reduces.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central grouping/bitmask scheme is a constructive set-inclusion method, and the reported speedups are measured simulations rather than fitted parameters renamed as predictions.

full rationale

The paper's only load-bearing derivation is the losslessness argument in Sec. IV.B: when small tiles are perfectly aligned inside a group, any Gaussian influencing a small tile also influences the group, so group-level sorting plus per-tile bitmasks is sufficient. This is a set-inclusion argument from the paper's own definitions, not an equivalence-by-construction between a fitted parameter and a predicted quantity. The bitmask generation does add opacity as an input in the hardware BGM (Sec. V.B) relative to the standard tile-identification inputs in Sec. II.B, and no PSNR/SSIM comparison is reported, so the losslessness claim is under-validated; however, that is an evidence/consistency gap, not circularity. The speedups in Sec. VI are empirical results from a cycle-level simulator and GPU runs; choosing 16x16 tiles with 64x64 groups from the Fig. 11 sweep is design parameter selection, not a fitted input called a prediction. The GSCore baseline is a benchmark comparison; even if the same J. Park is an author of GSCore, that self-citation is not load-bearing for the GS-TG mechanism itself. Therefore the derivation chain is self-contained and the paper does not reduce to its own inputs.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The central claim rests on the tile-grouping algorithmic structure, the alignment property of the tile grid, and the accuracy of the cycle-level simulator used for hardware evaluation. No new physical entities are introduced.

free parameters (3)

tile_size = 16x16
Chosen empirically in Section VI.B; '16+64 yielded the fastest performance in most cases'. It is a design knob that affects all speedup results.
group_size = 64x64
Chosen empirically in Section VI.B. Larger groups reduce sorting but may increase overhead; the value is selected from the same experiment set used to report speedups.
hardware_parallelism = 4 PM instances, 16 RUs, 16 comparators
Architectural parameters described in Section V; they affect area, power, and achievable speedup but are not swept or justified.

assumptions (4)

domain assumption The 3-sigma rule defines the influence range of each Gaussian, as in the original 3D-GS.
Used to determine group membership and bitmask generation; inherited from [1] without re-validation.
domain assumption Small tiles perfectly align within large tile groups, so a Gaussian affecting a small tile also affects its group.
Core to Section IV.B's computational independence argument. If alignment failed, group-level sorting could miss Gaussians needed for a small tile.
domain assumption The cycle-level simulator accurately models DRAM bandwidth and compute timing for both the baseline and GS-TG.
The hardware speedup results in Section VI.C depend entirely on this simulation; no validation against silicon is provided.
standard math Sorting by depth produces the same relative order of Gaussians at group and tile levels.
This is a mathematical fact used to justify losslessness, since depth is a scalar and the subset order is preserved.

how reviews work

0 comments

Cite this review

Pith. "Pith review of GS-TG: 3D Gaussian Splatting Accelerator with Tile Grouping for Reducing Redundant Sorting while Preserving Rasterization Efficiency." pith.science (2026). https://pith.science/paper/ZFXKSTNQ

@misc{pith2026250900911,
  author       = {Pith},
  title        = {Pith review of: GS-TG: 3D Gaussian Splatting Accelerator with Tile Grouping for Reducing Redundant Sorting while Preserving Rasterization Efficiency},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ZFXKSTNQ}},
  note         = {Machine review of arXiv:2509.00911}
}

read the original abstract

3D Gaussian Splatting (3D-GS) has emerged as a promising alternative to neural radiance fields (NeRF) as it offers high speed as well as high image quality in novel view synthesis. Despite these advancements, 3D-GS still struggles to meet the frames per second (FPS) demands of real-time applications. In this paper, we introduce GS-TG, a tile-grouping-based accelerator that enhances 3D-GS rendering speed by reducing redundant sorting operations and preserving rasterization efficiency. GS-TG addresses a critical trade-off issue in 3D-GS rendering: increasing the tile size effectively reduces redundant sorting operations, but it concurrently increases unnecessary rasterization computations. So, during sorting of the proposed approach, GS-TG groups small tiles (for making large tiles) to share sorting operations across tiles within each group, significantly reducing redundant computations. During rasterization, a bitmask assigned to each Gaussian identifies relevant small tiles, to enable efficient sharing of sorting results. Consequently, GS-TG enables sorting to be performed as if a large tile size is used by grouping tiles during the sorting stage, while allowing rasterization to proceed with the original small tiles by using bitmasks in the rasterization stage. GS-TG is a lossless method requiring no retraining or fine-tuning and it can be seamlessly integrated with previous 3D-GS optimization techniques. Experimental results show that GS-TG achieves an average speed-up of 1.54 times over state-of-the-art 3D-GS accelerators.

Figures

Figures reproduced from arXiv: 2509.00911 by the authors.

**Figure 2.** (a) depicts an example of axis-aligned bounding boxes (AABB), where the Gaussian intersects with 16 tiles when using AABB. This approach, adopted in the original 3D-GS, is computationally efficient but fails to account for the shape of the Gaussian, resulting in significant unnecessary computations [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗

**Figure 3.** Runtime breakdown across tile sizes for four scenes at different boundaries: (a) AABB and (b) Ellipse boundary. : Invisible : Visible : Culled Preprocessing : Gaussian Tile-wise Sorting Tile-wise Rasterization Compute Features & Culling Tile Identification Tile-wise Sorting α-Computation α-Blending Tile 0 G1 G0 Pixel N Tile 0 Tile 0 Tile 1 Tile 15 : G0, G1 : G0, G1 : G2, G3 Gaussian Param. 3D_XYZ 3D_Cov SHs σ Tile 0… view at source ↗

Figures from the paper (2 more)

**Figure 5.** Figure 5: Average number of intersecting tiles per Gaussian for various tile sizes in (a) AABB and (b) Ellipse boundary across four scenes. (a) (b) G1 G0 Pixel N G1 G0 α-Computation : Gaussian 0, 1 α-Blending : Gaussian 0 α-Computation : Gaussian 0 α-Blending : Gaussian 0 Pixel …

**Figure 9.** Figure 9: illustrates the overall pipeline of tile grouping-based rendering. First, feature calculations and culling operations are performed similarly to conventional 3D-GS rendering. Group Identification Step. Tiles are grouped based on predefined group size, and the Gaussians…

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

HiGS: A Hierarchical Rendering Architecture for Real-Time 3D Gaussian Splatting
cs.CV 2026-05 unverdicted novelty 7.0 of 10

HiGS achieves up to 15.8x faster real-time 3D Gaussian Splatting by running partitioning at coarse macro-tile scale and rasterization at fine tile scale, issuing work proportional to Gaussians per macro-tile.

Reference graph

Works this paper leans on

17 extracted references · 15 canonical work pages · cited by 1 Pith paper

[1]

3D Gaussian Splatting for Real -Time Radiance Field Rendering.,

B. Kerbl, G. Kopanas, T. Leimkühler, and G. Drettakis, “3D Gaussian Splatting for Real -Time Radiance Field Rendering.,” ACM Trans. Graph., vol. 42, no. 4, pp. 139–1, 2023

work page 2023
[2]

NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis

B. Mildenhall et al, “NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis”, In ECCV, 2020

2020
[3]

Instant neural graphics primitives with a multiresolution hash encoding,

T. Müller, A. Evans, C. Schied, and A. Keller, “Instant neural graphics primitives with a multiresolution hash encoding,” ACM Trans. Graph., vol. 41, no. 4, pp. 1–15, Jul. 2022

work page 2022
[4]

Compressed 3d gaussian splatting for accelerated novel view synthesis,

S. Niedermayr, J. Stumpfegger, and R. Westermann, “Compressed 3d gaussian splatting for accelerated novel view synthesis,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2024, pp. 10349–10358

work page 2024
[5]

Color -cued Efficient Densification Method for 3D Gaussian Splatting,

S. Kim, K. Lee, and Y. Lee, “Color -cued Efficient Densification Method for 3D Gaussian Splatting,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2024, pp. 775–783

work page 2024
[6]

LightGaussian: Unbounded 3D Gaussian Compression with 15x Reduction and 200+ FPS,

Z. Fan, K. Wang, K. Wen, Z. Zhu, D. Xu, and Z. Wang, “LightGaussian: Unbounded 3D Gaussian Compression with 15x Reduction and 200+ FPS,” Mar. 29, 2024, arXiv

work page 2024
[7]

GSCore: Efficient Radiance Field Rendering via Architectural Support for 3D Gaussian Splatting,

J. Lee, S. Lee, J. Lee, J. Park, and J. Sim, “GSCore: Efficient Radiance Field Rendering via Architectural Support for 3D Gaussian Splatting,” in Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), Volume 3, La Jolla CA USA: ACM, Apr. 2024, pp. 497–511

work page 2024
[8]

FlashGS: Efficient 3d Gaussian Splatting for Large-Scale and High-resolution Rendering

Guofeng Feng, Siyan Chen, Rong Fu, Zimu Liao, Y i Wang, Tao Liu, Zhilin Pei, Hengjie Li, Xingcheng Zhang, and Bo Dai. “FlashGS: Efficient 3d Gaussian Splatting for Large-Scale and High-resolution Rendering”, Aug. 15, 2024, arXiv

work page 2024

Show all 17 references

[9]

Tanks and temples: benchmarking large-scale scene reconstruction,

A. Knapitsch, J. Park, Q.-Y. Zhou, and V. Koltun, “Tanks and temples: benchmarking large-scale scene reconstruction,” ACM Trans. Graph., vol. 36, no. 4, pp. 1–13, Aug. 2017

2017
[10]

Deep blending for free -viewpoint image-based rendering,

P. Hedman, J. Philip, T. Price, J. -M. Frahm, G. Drettakis, and G. Brostow, “Deep blending for free -viewpoint image-based rendering,” ACM Trans. Graph., vol. 37, no. 6, pp. 1–15, Dec. 2018

2018
[11]

TensoRF: Tensorial Radiance Fields,

Chen, Z. Xu, A. Geiger, J. Yu, and H. Su, “TensoRF: Tensorial Radiance Fields,” in ECCV, 2022

2022
[12]

Plenoxels: Radiance fields without neural networks,

S. Fridovich -Keil, A. Yu, M. Tancik, Q. Chen, B. Recht, and A. Kanazawa, “Plenoxels: Radiance fields without neural networks,” i n Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2022, pp. 5501–5510

2022
[13]

Neural sparse voxel fields,

L. Liu, J. Gu, K. Zaw Lin, T.-S. Chua, and C. Theobalt, “Neural sparse voxel fields,” Advances in Neural Information Processing Systems, vol. 33, pp. 15651–15663, 2020

2020
[14]

Mega- nerf: Scalable construction of large-scale nerfs for virtual fly-throughs

Haithem Turki, Deva Ramanan, and Mahadev Satyanarayanan. Mega- nerf: Scalable construction of large-scale nerfs for virtual fly-throughs. In CVPR, 2022

2022
[15]

Capturing, reconstructing, and simulating: the urbanscene3d dataset

Liqiang Lin, Yilin Liu, Yue Hu, Xingguang Yan, Ke Xie, and Hui Huang. Capturing, reconstructing, and simulating: the urbanscene3d dataset. In ECCV, 2022

2022
[16]

Energon: Toward efficient acceleration of transformers using dynamic sparse attention,

Z. Zhou, J. Liu, Z. Gu, and G. Sun, “Energon: Toward efficient acceleration of transformers using dynamic sparse attention,” IEEE Transactions on Computer -Aided Design of Integrated Circuits and Systems, vol. 42, no. 1, pp. 136–149, 2022

2022
[17]

Tile -Based Modeling and Rendering,

M. Terai, J. Fujiki, R. Tsuruno, and K. Tomimatsu, “Tile -Based Modeling and Rendering,” in Smart Graphics, vol. 4569

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.

[1] [1]

3D Gaussian Splatting for Real -Time Radiance Field Rendering.,

B. Kerbl, G. Kopanas, T. Leimkühler, and G. Drettakis, “3D Gaussian Splatting for Real -Time Radiance Field Rendering.,” ACM Trans. Graph., vol. 42, no. 4, pp. 139–1, 2023

work page 2023

[2] [2]

NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis

B. Mildenhall et al, “NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis”, In ECCV, 2020

2020

[3] [3]

Instant neural graphics primitives with a multiresolution hash encoding,

T. Müller, A. Evans, C. Schied, and A. Keller, “Instant neural graphics primitives with a multiresolution hash encoding,” ACM Trans. Graph., vol. 41, no. 4, pp. 1–15, Jul. 2022

work page 2022

[4] [4]

Compressed 3d gaussian splatting for accelerated novel view synthesis,

S. Niedermayr, J. Stumpfegger, and R. Westermann, “Compressed 3d gaussian splatting for accelerated novel view synthesis,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2024, pp. 10349–10358

work page 2024

[5] [5]

Color -cued Efficient Densification Method for 3D Gaussian Splatting,

S. Kim, K. Lee, and Y. Lee, “Color -cued Efficient Densification Method for 3D Gaussian Splatting,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2024, pp. 775–783

work page 2024

[6] [6]

LightGaussian: Unbounded 3D Gaussian Compression with 15x Reduction and 200+ FPS,

Z. Fan, K. Wang, K. Wen, Z. Zhu, D. Xu, and Z. Wang, “LightGaussian: Unbounded 3D Gaussian Compression with 15x Reduction and 200+ FPS,” Mar. 29, 2024, arXiv

work page 2024

[7] [7]

GSCore: Efficient Radiance Field Rendering via Architectural Support for 3D Gaussian Splatting,

J. Lee, S. Lee, J. Lee, J. Park, and J. Sim, “GSCore: Efficient Radiance Field Rendering via Architectural Support for 3D Gaussian Splatting,” in Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS), Volume 3, La Jolla CA USA: ACM, Apr. 2024, pp. 497–511

work page 2024

[8] [8]

FlashGS: Efficient 3d Gaussian Splatting for Large-Scale and High-resolution Rendering

Guofeng Feng, Siyan Chen, Rong Fu, Zimu Liao, Y i Wang, Tao Liu, Zhilin Pei, Hengjie Li, Xingcheng Zhang, and Bo Dai. “FlashGS: Efficient 3d Gaussian Splatting for Large-Scale and High-resolution Rendering”, Aug. 15, 2024, arXiv

work page 2024