{"id":"fd1b6220-e813-4229-aa61-aaac0ede95ee","arxiv_id":"2506.19415","paper_version":1,"verdict":"CONDITIONAL","confidence":"MODERATE","novelty_score":6.0,"correctness_risk":"medium","formal_verification":"none","parameter_count":6,"one_line_summary":"A proxy-mesh visibility buffer with page streaming and level of detail lets 3D Gaussian Splatting render scenes larger than GPU memory while culling occluded Gaussians.","lead":"This paper applies virtual memory, the technique behind virtual textures in games, to 3D Gaussian Splatting scenes. It precomputes a coarse proxy mesh, groups Gaussians into pages, and streams only visible pages to the GPU, cutting memory use and speeding up rendering of large scenes on desktop and mobile.","discovery_kind":"new_application","skeptic_critique":{"model":"deepseek-v4-flash","headline":"The visible-page set is computed from an opaque proxy mesh, but 3DGS is rendered with alpha blending; pages behind semi-transparent Gaussians can be visible in the final image yet are culled as occluded, and page linking does not repair this.","rationale":"The reader's weakest assumption identifies two dependencies: a faithful proxy mesh and a page-linking heuristic that catches all relevant overlaps. My concern is a concrete failure mode of the first dependency: the proxy mesh is used as an opaque depth surface, while 3DGS is an alpha-blended point cloud. This is more load-bearing than the approximate-link concern because no amount of additional random sampling or exact ellipsoid-intersection testing can recover pages that are geometrically disjoint from visible pages but visible through a transparent occluder. The paper is honest about the limitation in Section 4.3, which is a point in its favor, but the limitation is not exercised by the evaluation, so the central claim remains conditional. The reported ablations, memory-usage plots, and mobile measurements do provide genuine support for the method on the tested opaque-dominated scenes, and I do not see an internal inconsistency that would justify rejection. The correct disposition is therefore the same conditional acceptance the reader gave: the method is plausible and partly validated, but the general claim that it identifies visible Gaussians and reduces memory without artifacts is not established for scenes with meaningful transparency. A targeted transparent-scene experiment would settle whether this concern lands in practice.","tokens_in":20669,"tokens_out":7426,"duration_ms":93634,"concrete_test":"Render a camera path through a 3DGS scene with a semi-transparent structure (e.g., a chain-link fence or a glass facade) in three configurations: (1) full scene without virtual memory; (2) virtual memory with a buffer large enough to hold every page, so no page is evicted; (3) same as (2) but with page linking disabled. If configuration (2) is missing any background page that is visible in (1) behind the transparent structure, or if PSNR(1,2) drops by more than about 1 dB while PSNR(1,3) does not, the proxy-mesh occlusion test is the cause. If no such real scene is available, construct a synthetic 3DGS scene with a wall of low-opacity Gaussians in front of a high-contrast background and repeat the comparison.","verdict_should_be":"UNCHANGED","load_bearing_attack":"The central claim requires that the page-determination stage returns every page whose Gaussians contribute to the rendered image. Section 4.1 implements this by rendering page IDs on the proxy mesh with ordinary depth testing, so any proxy face behind another face is treated as occluded. This is an opaque-surface model. 3DGS, however, is rendered as an ordered, alpha-blended point cloud: a semi-transparent cluster of Gaussians (foliage, fences, glass, smoke) does not fully hide Gaussians behind it, and those background Gaussians must still be streamed and rendered. Their pages will nevertheless be marked occluded by the proxy mesh and will never be requested. The paper itself flags this in Section 4.3: 'Transparency challenges in page determination echo traditional virtual texturing issues... crucial for realistic representations in 3DGS with transparencies.' Page linking cannot fix the problem because links are created only when sampled points inside an ellipsoid land closest to a face on another page, i.e., geometric overlap of Gaussian volumes, not visibility through a transparent occluder. None of the evaluation scenes in Section 5 is selected for significant transparency, so the reported PSNR values do not exercise this failure mode. If the visible-page set misses background pages behind transparent structures, the method produces holes exactly where occlusion culling is most aggressive, which directly undermines the claim of identifying visible Gaussians.","agreement_with_reader":"partial"},"referee_report":{"model":"deepseek-v4-flash","summary":"The paper presents a virtual-memory system for rendering 3D Gaussian Splatting scenes that exceed GPU memory. An offline stage extracts a proxy mesh from the Gaussian ellipsoids, assigns Gaussians to pages, links overlapping pages, and builds LOD levels by k-means merging. At runtime, the proxy mesh is rendered to a low-resolution visibility buffer of page IDs; the resulting page list, augmented by links, drives a page table that streams required pages into a bounded GPU buffer, with LRU eviction and distance-based LOD selection. The system is implemented in Vulkan and ported to iOS via MoltenVK, and evaluated on four scenes (SciArt, Residence, Alameda, Berlin) on a GTX 1070 desktop and an iPad Pro M1. The paper reports that the method reduces GPU memory and frame times relative to rendering the full scene without virtual memory.","tokens_in":21040,"tokens_out":8548,"duration_ms":83716,"significance":"If the claims hold, the paper offers a practical mechanism for rendering 3DGS scenes larger than GPU memory, borrowing mature virtual-texturing technology. The authors provide a full implementation, a mobile port, and ablation studies that isolate page linking, LOD, buffer size, and page size; they also clearly identify several limitations (low-resolution visibility buffer, lack of LOD blending, transparency). The contribution is incremental but useful: it is one of the first to apply occlusion-based page streaming rather than frustum-only streaming to 3DGS. However, the central assertion that the method 'efficiently identifies visible Gaussians' is only demonstrated for the tested opaque scenes; the transparency limitation and the approximate page-linking heuristic are load-bearing and need stronger validation before the contribution can be fully accepted.","major_comments":[{"comment":"The page-determination stage is an opaque-surface test: page IDs are rendered on the proxy mesh with ordinary depth testing, so any face behind another face is treated as occluded. 3DGS, however, composites Gaussians with alpha blending, so semi-transparent structures do not fully hide the Gaussians behind them; those background pages will be marked invisible and never streamed, creating holes. The manuscript acknowledges this in Sec. 4.3 ('Transparency challenges in page determination echo traditional virtual texturing issues'), but the abstract and Sec. 4.1 still claim the method 'efficiently identifies visible Gaussians.' This is a load-bearing gap: either restrict the claim to opaque scenes, evaluate a scene with significant transparency, or implement the suggested pinning of transparent pages.","section":"Sec. 4.1, Sec. 4.3"},{"comment":"Page linking is the mechanism that repairs missed visibility, but its correctness is not established. Links are found by generating random points inside each ellipsoid and checking only the nearest proxy-mesh face; the paper gives no sampling density, no convergence criterion, and no analysis of failure modes. Table 2 shows how much depends on this heuristic: disabling page links drops PSNR from 42.89/47.19 to 35.02, and Figure 16 shows visible artifacts. Because the central claim is that the visibility buffer plus links returns the exact set of pages needed for artifact-free rendering, please provide an empirical sensitivity analysis (number of samples per ellipsoid, number of nearest faces) and, on a small scene, compare against exhaustive ellipsoid-intersection testing.","section":"Sec. 3.3, Table 2"},{"comment":"The rows 'Without page links, with LOD' and 'Without page links, without LOD' report identical PSNR (35.02) and SSIM (0.97) values. Either this is a copy-paste error or LOD has no effect when page links are disabled; in either case the table must be corrected and the result explained, since Table 2 is the main evidence for the contribution of page linking.","section":"Table 2"},{"comment":"The quantitative evaluation compares only ablations of the proposed method and does not include any existing large-scene 3DGS system as a baseline (e.g., CityGaussian [20], Hierarchical 3DGS [15], or a full-scene non-streaming renderer on the same hardware). All timings are medians with no error bars or repeated-run variance, despite the acknowledged nondeterminism of the adaptive LOD thresholds (Sec. 5.2). To support the claims of reduced memory and accelerated rendering, please report mean/median with variance over multiple runs and, where feasible, compare against a published system or a clear non-streaming baseline.","section":"Sec. 5"},{"comment":"The paper acknowledges that rendering the visibility buffer at low resolution 'can cause distant pages to be missed' (Sec. 4.3). This is not peripheral: the streaming decision is based entirely on that buffer, so a missed distant page translates directly into holes in the final image. Page links only cover geometric overlap, not visibility through distant gaps. Please add a quantitative study of visibility-buffer resolution versus the 'Missing Pages' metric introduced in Table 4, and either bound the resolution error or relax the claim of exact visibility identification.","section":"Sec. 4.3, Table 4"}],"minor_comments":[{"comment":"The heading 'Synchronsitaion' is a typo for 'Synchronization'.","section":"Sec. 5.1.3"},{"comment":"The table caption uses 'ArtSci' while Figure 13 and the text call the scene 'SciArt'; please unify the naming.","section":"Table 2"},{"comment":"The 'Missing Pages' metric is not defined; with a 250-page buffer, a value of 549 suggests it counts repeated requests or page faults rather than unique missing pages, so please define it in the text.","section":"Table 4"},{"comment":"The text around Table 1 is inconsistent about storage overhead: it says the overhead is negligible, but the final file size for SciArt (1505.5 MiB) is nearly double its initial size (804.9 MiB) due to padding and LOD levels; please clarify that 'overhead' refers only to the mesh/links file and state the LOD storage cost explicitly.","section":"Table 1"},{"comment":"In Equation (1), the symbols v_z, s, and n are not defined at first use; please define them in the text before or immediately after the equation.","section":"Sec. 3.1"},{"comment":"The stacked time-segment bars are not accompanied by an explicit legend or color key; please add a legend so the reader can map each segment to the stages described in the text.","section":"Figures 20 and 21"},{"comment":"The claim that frame times decrease as the number of pages decreases is based on unsmoothed FPS; please report a correlation coefficient or a smoothed plot to support the relationship.","section":"Sec. 5.3.2"}],"recommendation":"major_revision","confidential_remarks":"The duplicate PSNR in Table 2 should be checked by the editor before acceptance; if it is an error, the reliability of the other tables needs scrutiny as well. The paper would also be substantially stronger with a comparison against CityGaussian or Hierarchical 3DGS; I would prefer to see that comparison or a clear justification for its absence."},"author_rebuttal":null,"desk_editor":{"model":"deepseek-v4-flash","letter":"The thing to know: this paper gives a real new building block for streaming large 3DGS scenes. The core idea—render page IDs on an opaque proxy mesh to a visibility buffer, then stream only pages that show up, with page links to catch overlaps—is genuinely different from the frustum-only streaming in prior work, and the ablation shows it matters: dropping page links drops PSNR from 42.89/47.19 to 35.02 on the tested frame. That is a convincing internal result.\n\nThe paper is also honest about what it costs. It describes preprocessing, page table management, staging buffers, LOD integration, and a mobile port to iPad, and it spells out trade-offs in the text. The authors clearly know the weak spots. I believe the internal measurements: streaming visible pages does cut memory and frame time on the scenes they chose.\n\nSoft spots are real but mostly addressable. No comparison against CityGaussian or Kerbl's hierarchical LOD, so we don't know how it stacks against the alternatives. No error bars or repeated runs; Table 2 has the same 35.02 PSNR in two rows, which looks like a typo and should be checked. No code or data, so reproducibility is limited.\n\nThe bigger conceptual gap is the one the authors flag in Section 4.3 but don't handle: page determination uses an opaque proxy mesh with depth test, while 3DGS renders with alpha blending. Semi-transparent foliage, glass, or fences do not fully obscure what's behind them, so the proxy mesh can mark those background pages as occluded, they never get streamed, and you get holes. The paper mentions pinning transparent pages as future work, which is honest, but the abstract claims the method 'efficiently identifies visible Gaussians' without that caveat. None of the four test scenes is selected for significant transparency, so the reported numbers don't exercise this failure mode. That should be either fixed or explicitly scoped out of the claims.\n\nWho is this for? People building practical large-scene 3DGS renderers on consumer or mobile hardware. It deserves a serious referee; there's enough substance and honest engineering here. But the revision should add a baseline comparison, error bars, and either a transparent-scene test or a sharper statement that the current method targets opaque scenes.","headline":"Solid new application of virtual texturing to 3DGS, with an honest but incomplete evaluation that omits transparent scenes.","tokens_in":21512,"tokens_out":2900,"would_cite":true,"duration_ms":32293,"reading_group":"maybe","serious_thinker":"yes","would_accept_peer_review":true},"rs_alignment":null,"lean_confirmation":null,"pith_extraction":{"msc":[],"pacs":[],"model":"deepseek-v4-flash","headline":"This paper proposes rendering page IDs on a proxy mesh to a visibility buffer so that only visible Gaussian pages are streamed to the GPU, bounding memory use and accelerating rendering.","keywords":["3D Gaussian Splatting","virtual memory","virtual texturing","visibility buffer","level of detail","GPU streaming","occlusion culling","novel view synthesis"],"falsifier":"Take a scene with a known Gaussian whose mean lies on an occluded page but whose visible tail extends into a neighboring page, render it with page links disabled and a deliberately small visibility buffer, and check whether the final image shows a hole; the paper's own ablation, in which disabling links drops PSNR from 42.89 dB to 35.02 dB, is already a strong version of this test.","tokens_in":20490,"feed_emoji":"🧊","tokens_out":10767,"duration_ms":103711,"temperature":0.7,"pith_summary":"This paper tries to establish that the memory bottleneck of large 3D Gaussian Splatting scenes can be broken by treating Gaussians as pages in a virtual-memory system. Borrowing the tile-streaming ideas of virtual texturing, offline preprocessing extracts a coarse proxy mesh, assigns every Gaussian to a page, marks mesh faces with page IDs, links overlapping pages, and builds coarser LOD levels per page. At render time, the proxy mesh is drawn to a small visibility buffer that records which page IDs are visible, and those pages, plus their linked neighbors, are the only Gaussians streamed into GPU memory. The paper claims this keeps GPU memory bounded and speeds up rendering, especially for large, heavily occluded scenes, and demonstrates the pipeline on desktop and mobile hardware.","feed_headline":"Streaming only visible Gaussians lets huge 3D scenes fit in GPU memory","feed_subtitle":"A proxy mesh plus page table loads only the Gaussians in view, so big scenes run on modest GPUs.","key_machinery":"The central object is the page-ID visibility buffer: a low-resolution render of the proxy mesh in which each fragment outputs the ID of the Gaussian page covering that mesh face. This buffer converts occlusion into an explicit selection step, because the pixels it contains name exactly the pages that can contribute to the final image. Around it sits a page table that maps virtual pages to physical GPU pages, uses least-recently-used eviction, and stores per-page LOD information; page links, found by random sampling inside ellipsoids and checking the nearest proxy face, ensure that overlapping Gaussians on neighboring pages are requested together. The proxy mesh itself is built from plane-ellipsoid intersections cleaned with morphological operations and reconstructed with Marching Cubes, and the LOD levels are created by k-means clustering of Gaussian attributes followed by averaging.","core_discovery":"The central claim is that a 3D Gaussian Splatting scene can be rendered within a strict GPU memory budget by selecting Gaussians through a visibility-buffer page table instead of loading the whole scene. Preprocessing converts the scene into a simplified proxy mesh, groups Gaussians into pages by position, links pages whose ellipsoids overlap, and generates several LOD levels per page by clustering and averaging Gaussian attributes. Each frame, the proxy mesh is rendered with page IDs into a low-resolution visibility buffer; a compute shader reduces that buffer to the list of required pages, the page table uploads missing pages and evicts least-recently-used ones, and the LOD level for each page is chosen from its closest pixel depth. The paper reports that this selection reduces memory use and rendering time on the test scenes, with the largest gains when occlusion is abundant, and that page links are required to avoid visible artifacts.","pith_inferences":["Because the visibility buffer sees only what the proxy mesh exposes, scenes with heavy transparency would need pinned pages on transparent surfaces; the paper lists this as future work, and a coarse depth channel in the buffer would make the fix straightforward.","Replacing the random-sampling page-link heuristic with a bounding-volume hierarchy over Gaussian extents would likely make links both cheaper and more complete, directly attacking the main source of missing pages.","The same page-table structure could serve any scene representation that can provide an occlusion proxy, so the idea extends beyond Gaussian splats to hybrid mesh-radiance-field renderers.","Pushing page assignment and proxy-mesh construction into the training stage, instead of running them as an offline post-process, would remove the hour-scale preprocessing the largest test scene requires and could optimize pages for few links from the start."],"forward_implications":["A scene larger than GPU memory can be rendered with a fixed-size GPU buffer, because only pages visible from the current camera position are resident at any time.","Occluded environments benefit most: the visibility buffer removes Gaussians hidden behind other structure, which frustum culling alone cannot do.","When the GPU buffer is under pressure, the adaptive LOD mechanism pushes level transitions closer to the camera, trading distant detail for a hole-free frame.","The method accepts standard 3D Gaussian Splatting scenes without retraining, so existing reconstructions can be preprocessed and rendered at larger scale.","The page table and visibility buffer add only a small fraction of frame time compared with the depth sorting and splatting they save."],"supporting_citations":[{"why":"introduces sparse virtual texturing, the core pattern of rendering tile IDs and uploading visible tiles that the paper adapts to Gaussian pages.","marker":"[1]"},{"why":"defines the 3D Gaussian primitive, the scene file format, and the original rendering baseline that this work takes as input.","marker":"[14]"},{"why":"supplies the plane-ellipsoid intersection method used to slice the scene for proxy mesh extraction.","marker":"[12]"},{"why":"provides the Marching Cubes algorithm that turns the sliced samples into the proxy mesh.","marker":"[21]"},{"why":"introduces the multi-scale Gaussian merging approach that the paper's LOD levels are based on.","marker":"[39]"},{"why":"provides the virtual texturing analysis, including the low-resolution visibility buffer trade-off that shapes the page determination stage.","marker":"[23]"},{"why":"supplies the large reconstructed scenes used to evaluate the method under memory pressure.","marker":"[18]"},{"why":"describes a hierarchical large-scale Gaussian representation with asynchronous LOD streaming, the closest alternative the paper discusses.","marker":"[15]"}],"fun_headline_variants":["GPU memory limit? Page-table streams only visible Gaussians","Virtual memory for 3DGS: render massive scenes on small GPUs","Streaming by visibility: big 3D scenes, tiny GPU footprint","LOD and visibility paging render huge splats on any GPU","Render giant scenes by streaming just the visible Gaussians"],"cache_read_input_tokens":3200,"weakest_assumption_plain":"The method assumes that a coarse proxy mesh captures the scene's occlusion structure accurately enough, and that the random-sampling page-link test catches every overlap between Gaussian pages, so that every Gaussian that contributes to the image is on a page the visibility buffer requests.","fun_headline_variants_meta":{"raw":{"variants":["GPU memory limit? Page-table streams only visible Gaussians","Virtual memory for 3DGS: render massive scenes on small GPUs","Streaming by visibility: big 3D scenes, tiny GPU footprint","LOD and visibility paging render huge splats on any GPU","Render giant scenes by streaming just the visible Gaussians"]},"model":"deepseek-v4-flash","effort":"low","cost_usd":0.000333,"raw_usage":{"total_tokens":1818,"prompt_tokens":883,"completion_tokens":935,"prompt_tokens_details":{"cached_tokens":384},"prompt_cache_hit_tokens":384,"prompt_cache_miss_tokens":499,"completion_tokens_details":{"reasoning_tokens":846}},"tokens_in":499,"tokens_out":935,"duration_ms":8271,"temperature":1.0,"reasoning_tokens":846,"cache_read_input_tokens":384,"cache_creation_input_tokens":0},"cache_creation_input_tokens":0},"created_at":"2026-08-06T23:06:41.339909+00:00","model_set":{"reader":"deepseek-v4-flash"},"falsifier":"Take a scene with a known Gaussian whose mean lies on an occluded page but whose visible tail extends into a neighboring page, render it with page links disabled and a deliberately small visibility buffer, and check whether the final image shows a hole; the paper's own ablation, in which disabling links drops PSNR from 42.89 dB to 35.02 dB, is already a strong version of this test.","supporting_citations":[{"cited_title":null,"cited_arxiv_id":null,"evidence_quote":"introduces sparse virtual texturing, the core pattern of rendering tile IDs and uploading visible tiles that the paper adapts to Gaussian pages."},{"cited_title":"Hartmann","cited_arxiv_id":null,"evidence_quote":"supplies the plane-ellipsoid intersection method used to slice the scene for proxy mesh extraction."},{"cited_title":"Capturing, Reconstructing, and Simulating: the UrbanScene3D Dataset","cited_arxiv_id":"2107.04286","evidence_quote":"provides the Marching Cubes algorithm that turns the sliced samples into the proxy mesh."},{"cited_title":"Kerbl, A","cited_arxiv_id":null,"evidence_quote":"describes a hierarchical large-scale Gaussian representation with asynchronous LOD streaming, the closest alternative the paper discusses."}],"review_version":1}