Neural Bloom: A Deep Learning Approach to Real-Time Lighting

Dawid Gruszka; Rafal Karp; Tomasz Trzcinski

REVIEW 4 major objections 6 minor 25 references

Neural Bloom: A Deep Learning Approach to Real-Time Lighting

T0 review · 4 major / 6 minor · reviewed 2026-08-05 · deepseek-v4-flash

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

Pith's one-line read A compact convolutional network can generate a bloom brightness mask in a single pass, matching Unity URP bloom visually while running about 28 percent faster than the shader baseline.

desk verdict Honest engineering with a load-bearing flaw: the speedup claim rests on an unvalidated Python reimplementation of Unity's bloom, so the headline numbers are not reliable as published. read the letter →

arxiv 2509.05963 v1 pith:4RKEMXTX submitted 2025-09-07 cs.CV

Rafal Karp , Dawid Gruszka , Tomasz Trzcinski This is my paper · ORCID

classification cs.CV

keywords bloomeffectreal-timerenderingneuralnetworkbrightnessmaskU-Netpost-processingGPUperformanceimageregression

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

This paper claims that a small convolutional network can replace the standard multi-pass bloom post-process in real-time rendering, producing a brightness mask in a single inference that looks nearly identical to Unity's URP bloom effect while taking less time. The authors train two U-Net-style networks, NBL and FastNBL, on paired 128x128 views of 3D scenes, using Unity-generated bloom masks as ground truth. On their benchmark, FastNBL averages 0.1235 ms per mask versus 0.1725 ms for a shader implementation that mirrors Unity's bloom algorithm, roughly 28 percent faster, while NBL is about 12 percent faster with slightly higher quality. The broader claim is that neural single-pass inference avoids the conditional branching and multi-sample blur passes of traditional bloom, freeing GPU time for other effects.

What carries the argument

The load-bearing object is a shallow U-Net-style convolutional network trained to regress the bloom brightness mask from the scene view. Its encoder-decoder structure extracts spatial features at multiple scales and returns an image-sized mask in one pass, replacing the traditional prefilter, downsample-blur, and upsample pyramid. The speed difference comes from replacing many texture samples and conditional threshold branches with a fixed set of convolution operations; the two variants trade a few operations for quality via dilated and grouped convolutions.

What would settle it

Run the same Unity URP bloom configuration inside a real Unity build on the same GPU, measure the bloom pass time, and compare it with fused NBL and FastNBL inference at the same 128x128 resolution; if native Unity bloom is already as fast as or faster than the networks, the central speed claim fails. A second check is to feed a scene not seen in training and measure brightness-mask MSE, since the paper reports only per-scene training results.

Watch

Extended reading notes

Core claim

The central claim is that the bloom effect—normally a sequence of thresholding, downsampled Gaussian blurs, and upsampling passes—can be approximated by a shallow encoder-decoder network that directly outputs the brightness mask. The paper identifies two working configurations: NBL, using a convolution-batch-norm-ReLU encoder and decoder, and FastNBL, using dilated convolutions and grouped convolutions for fewer operations. Both are trained per scene with MSE loss against Unity URP bloom output and then optimized by fusing layers and compiling the model. On 5,000 test images per scene, NBL reaches an average MSE of 0.00029 and FastNBL 0.00076, both below the authors' threshold of 0.001 for v

Load-bearing premise

The central speedup rests on the claim that the Python/moderngl shader implementation accurately represents Unity's actual URP bloom performance; the paper asserts this equivalence without timing Unity itself, so if the shader is slower than the real engine the reported 12-28 percent gains are not against the claimed baseline.

Editorial extensions

If this is right

If the claim holds, a game engine could request a bloom mask from network inference on dedicated tensor cores, freeing texture units for other rendering work in the same frame.
A single-pass neural bloom would eliminate warp divergence from threshold branching, making frame times more predictable than the reference shader, as NBL's lower variance suggests.
The same per-scene training recipe should let a developer bake a scene-specific bloom approximation that is faster than the engine's own shader on that scene.
Because quality is measured against Unity URP bloom masks, the method inherits the look of that reference effect rather than introducing a new physically based model.
The reported 12-28 percent speedup is demonstrated at 128x128 resolution, so production integration would first need to confirm the margin at higher resolutions.

Reading between the lines

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

The speed comparison is made at 128x128; at production resolutions the convolution cost grows with pixel count while the shader's pyramid blur uses downsampled buffers, so the observed margin may shrink or reverse—the paper does not measure this.
The models are trained per scene, so a practical deployment would need either runtime adaptation or a general model; the paper lists this as a limitation, implying the natural next experiment is training one network on many scenes and measuring cross-scene MSE.
The paper does not measure temporal stability across frames; a neural mask that flickers would fail in motion even if per-frame MSE is low, and this is a plausible risk for a single-pass regressor.
The same architecture could be tested on other branch-heavy, multi-pass post-effects such as depth-of-field or motion blur; the authors state this direction but provide no results yet.

Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

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

Rafał, quick take on Neural Bloom. The central speedup claim doesn't hold as stated, because the “state-of-the-art Unity3D bloom” baseline is a Python/moderngl reimplementation whose runtime equivalence to Unity's actual renderer is asserted, not demonstrated. On GPUs, engine-level pass management, shader compilation, and memory layout can easily change timings by more than the claimed 28%. So the headline result is unproven.

That said, the paper does a few things honestly. It builds two compact CNNs that produce bloom masks in a single forward pass, properly measures inference with CUDA events and TorchScript, and—credit where due—the conclusion explicitly lists the limitations: single-scene training, fixed 128×128 input, and no guarantee of speed without further optimization. That transparency is more than many papers offer.

The soft spots are proportionate to the central claim. The quality metric is an arbitrary MSE threshold (0.001) without perceptual validation, and the p99 discussion is hand-wavy. The “variety of 3D scenes” in the abstract reduces to one extra scene with visual examples only. No code or data are available, so replication is impossible. The architectural label “U-Net-inspired” is generous for a three-layer encoder-decoder with no skip connections, but that's a labeling quibble.

Who is this for? Someone cataloguing neural approaches to screen-space effects might cite it, but the numbers should not be taken at face value. It deserves a serious referee—the flaws are fixable, and the problem is relevant—but as submitted the performance comparison needs real Unity benchmarks and higher-resolution tests. If it goes to review, I'd ask for the Unity timing data and a perceptual evaluation. As is, I would not rely on the speedups.

Referee Report

4 major / 6 minor

Summary. The paper proposes two convolutional U-Net-style models, NBL and FastNBL, to generate bloom brightness masks in real time. The models are trained on 128×128 images to regress the brightness masks produced by Unity3D URP's bloom post-process. The authors report average MSE values of 0.00029 (NBL) and 0.00076 (FastNBL), and inference times of 0.14053 ms and 0.12352 ms, respectively, compared with 0.17253 ms for a Python/moderngl shader implementation that is claimed to reproduce the Unity URP bloom algorithm. From this they conclude that FastNBL is 28.4% faster and NBL is 12.1% faster than the Unity3D bloom implementation, while maintaining visually indistinguishable quality.

Significance. If the speed and quality claims were substantiated, a single-pass neural approximation of bloom could be a useful lightweight alternative in real-time rendering, freeing GPU time for other effects. The paper identifies a reasonable problem and the proposed architectures are simple and plausible. However, the central comparison is against a reimplementation rather than the actual engine, the quality criterion is an arbitrary MSE threshold without perceptual validation, and all measurements are at 128×128 on a single trained scene. As it stands, the paper does not provide sufficient evidence for its headline claims. No code or trained models are mentioned, limiting reproducibility.

major comments (4)

[Section 4.3, Table 2] The column labeled 'Unity3D Bloom' is actually a Python/moderngl OpenGL reimplementation of a three-pass bloom algorithm, not the Unity URP implementation. The paper asserts (Section 4.3, 'This directly reflects Unity3D URP renderer bloom effect algorithm') that the shader reproduces Unity's algorithm, but no validation is given that its runtime is representative of Unity's engine. GPU performance depends on render pass management, framebuffer allocation, shader compilation, and driver behavior, which differ between a Python/moderngl context and a native C++ engine. Without timing data from actual Unity URP or a rigorous equivalence argument, the claimed 28.4% and 12.1% speedups over 'state-of-the-art Unity3D Bloom' are unsupported.
[Section 4.2] The quality claim relies on an arbitrary threshold: 'MSE values below 0.001 are nearly indistinguishable from the ground truth images.' No perceptual experiment, PSNR, SSIM, or other standard metric is reported. The average MSE values (0.00029 and 0.00076) correspond to RMSE of roughly 0.017 and 0.028 on a [0,1] scale, i.e., several intensity levels on 8-bit images; calling this 'indistinguishable' is not justified. Additionally, although Section 4.1 mentions 'a variety of 3D scenes,' quantitative quality results are only reported for the single scene used for training; Figure 7 is illustrative and reports no error metric. The paper should report held-out-scene performance and use a perceptual or standard image-quality metric.
[Sections 3 and 5] All performance and quality measurements are performed at 128×128 resolution, and the conclusion explicitly states that the models are trained on a specific scene and do not support variable or higher resolutions. This is in tension with the stated motivation of real-time rendering at 60–240 FPS, which typically operates at much higher resolutions. The claimed speed advantage is therefore only demonstrated under conditions far from the target application. The authors should provide measurements at a more realistic resolution (e.g., 1080p) or clearly restrict the contribution to low-resolution settings.
[Section 4.1] The paper does not state how the training and test sets are partitioned. Section 4.1 says a test dataset of 5,000 paired images per scene was prepared, but no information is given about the number of training images or whether the test images are distinct from those used for training. Without a clear train/test split, the reported MSE values could reflect memorization rather than generalization. The authors should describe the data-generation protocol explicitly, including the number of training frames and their overlap with the test set.

minor comments (6)

[Abstract] Grammar/wording: 'Our solution generate' should be 'Our solution generates'; 'up to 30% faster' is not clearly tied to a specific baseline in the abstract.
[References] Several references are incomplete or malformed: [1] appears as just '2', [2] lacks a title, [5] is incomplete ('John O’Rorke Greg James'), [6] has no title, and [11] and [24] are informal URLs with no author/date. These need to be corrected for journal submission.
[Table 1] Typo: 'parametrs' should be 'parameters'.
[Section 4.3] The text states 'All time measurements were performed using CUDA [15]' but the described shader baseline uses OpenGL moderngl and query objects. Please clarify which API/timing mechanism was used for which measurement.
[Figure 3] Only the NBL architecture is shown; FastNBL is described in text but not visualized. Adding a diagram for FastNBL or a combined figure would improve clarity.
[Section 1.1 / 4.1] The resolution notation is inconsistent ('128x128' vs '128×128'). Use a consistent format.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the bloom masks are a supervised regression target, and the speed baseline is a proxy implementation; these are validity concerns, not circular derivation.

full rationale

The paper's central pipeline is a standard supervised learning setup: U-Net-style models are trained to reproduce Unity URP bloom brightness masks, and quality is measured by MSE between the generated mask and the same kind of ground truth. This makes the evaluation metric coincide with the training loss, but that is the ordinary operationalization of the task, not a circular derivation: the models are evaluated on a 5,000-image dataset described as a test set, and the contribution is inference speed rather than a new physical law. There are no load-bearing self-citations; all substantive references (Unity URP docs, moderngl, U-Net, PyTorch) are external. The 'MSE below 0.001 is indistinguishable' criterion is an author-selected perceptual assumption, not an input that forces the reported result. The performance comparison uses a Python/moderngl reimplementation of the Unity URP algorithm rather than the actual Unity engine; the paper asserts equivalence but does not validate it. That is a correctness and external-validity threat to the headline speedup claim, not a circularity. The paper itself discloses key limitations—single-scene training, fixed 128x128 resolution, and the need for inference optimizations to realize speed gains—which further supports treating these as empirical limitations rather than circular reasoning. No quoted step reduces to its own input by construction, so the circularity score is 0.

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

The paper introduces no new physical or conceptual entities. The central claims rest on an empirically chosen MSE threshold, a set of hand-tuned network hyperparameters, and an unvalidated assumption that a Python shader proxy matches the real Unity engine's performance.

free parameters (3)

MSE quality threshold = 0.001
Chosen in Section 4.2 as the boundary below which outputs are 'nearly indistinguishable'; underpins the 'high quality' claim without perceptual validation.
Network hyperparameters = channels 64/32, kernel 3, dilation 2, groups 32, batch 32, lr 0.0002, epochs 1500
Hand-selected via 'extensive research' (Section 3); the reported speed and quality results are sensitive to these choices.
Image resolution = 128x128
Chosen to 'maximize iteration speed'; the performance claims are tied to this low resolution and are not shown to generalize.

assumptions (3)

domain assumption An MSE under 0.001 corresponds to visually indistinguishable bloom output.
Invoked in Section 4.2 to translate a numeric MSE into a claim of indistinguishable quality; no user study or perceptual metric is provided.
ad hoc to paper The moderngl/Python shader reimplementation accurately reproduces the Unity3D URP bloom algorithm's performance characteristics.
Section 4.3 states the algorithm directly reflects Unity URP, but no validation against the actual engine is provided; the speed comparison in Table 2 relies on this.
domain assumption The single-scene training regime is representative of the method's claimed real-time applicability.
All primary quality and speed numbers come from models trained and tested on one 3D scene (Sections 3 and 4.1); the authors acknowledge this limits adaptability.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Neural Bloom: A Deep Learning Approach to Real-Time Lighting." pith.science (2026). https://pith.science/paper/4RKEMXTX

@misc{pith2026250905963,
  author       = {Pith},
  title        = {Pith review of: Neural Bloom: A Deep Learning Approach to Real-Time Lighting},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/4RKEMXTX}},
  note         = {Machine review of arXiv:2509.05963}
}

read the original abstract

We propose a novel method to generate bloom lighting effect in real time using neural networks. Our solution generate brightness mask from given 3D scene view up to 30% faster than state-of-the-art methods. The existing traditional techniques rely on multiple blur appliances and texture sampling, also very often have existing conditional branching in its implementation. These operations occupy big portion of the execution time. We solve this problem by proposing two neural network-based bloom lighting methods, Neural Bloom Lighting (NBL) and Fast Neural Bloom Lighting (FastNBL), focusing on their quality and performance. Both methods were tested on a variety of 3D scenes, with evaluations conducted on brightness mask accuracy and inference speed. The main contribution of this work is that both methods produce high-quality bloom effects while outperforming the standard state-of-the-art bloom implementation, with FastNBL being faster by 28% and NBL faster by 12%. These findings highlight that we can achieve realistic bloom lighting phenomena faster, moving us towards more realism in real-time environments in the future. This improvement saves computational resources, which is a major bottleneck in real-time rendering. Furthermore, it is crucial for sustaining immersion and ensuring smooth experiences in high FPS environments, while maintaining high-quality realism.

Figures

Figures reproduced from arXiv: 2509.05963 by the authors.

**Figure 2.** Left: Selected view of the 3D scene without bloom. Middle: Isolated bloom glow effect (brightness mask). Right: Same view with the brightness mask applied. Each image is 128×128 pixels. ral Bloom Lighting (NBL), which provides superior quality at the cost of slower performance, and Fast Neural Bloom Lighting (FastNBL), which is faster but results in reduced quality. These solutions will be referred to as NBL and Fa… view at source ↗

**Figure 3.** Neural Bloom Lighting (NBL) architecture visualized [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗

Figures from the paper (4 more)

**Figure 4.** Figure 4: Example of four sample input data pairs. The right [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]

**Figure 5.** Figure 5: Shader Based Bloom Effect passes visualized [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]

**Figure 6.** Figure 6: The figure contains 12 examples arranged in 2 columns. [PITH_FULL_IMAGE:figures/full_fig_p007_6.png]

**Figure 7.** Figure 7: The figure contains 10 examples arranged in 2 columns. [PITH_FULL_IMAGE:figures/full_fig_p008_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

25 extracted references · 25 canonical work pages

[2]

Real-time post- processing effects in 3d rendering.Game Developer Mag- azine, 2008

Laurent Bavoil and Alain Dufresne. Real-time post- processing effects in 3d rendering.Game Developer Mag- azine, 2008. Discusses various post-processing effects in- cluding bloom. 1

work page 2008
[3]

The frame rate of a virtual reality headset, 2023

BrandXR. The frame rate of a virtual reality headset, 2023. Accessed: 2024-11-14. 2

work page 2023
[4]

readthedocs

Szabolcs Dombi, 2024.https : / / moderngl . readthedocs . io / en / 5 . 8 . 2 / index . htmlAc- cessed: 2025-01-26. 5

work page 2024
[5]

John O’Rorke Greg James. 2

work page
[6]

Accessed: 2025-01-26

Kronos Group, 2024. Accessed: 2025-01-26. 6

work page 2024
[7]

Opengl: A graphics api, 2024

Khronos Group. Opengl: A graphics api, 2024. Accessed: 2024-11-11. 1

work page 2024
[8]

Springer, 2001

Herbert Haas.Digital Image Processing. Springer, 2001. Gaussian blur technique described in the context of image filtering. 3

work page 2001
[9]

Neural network ambient occlusion

Daniel Holden, Jun Saito, and Taku Komura. Neural network ambient occlusion. 2016. 3

work page 2016

Show all 25 references

[10]

A survey on post- processing techniques in computer graphics.ACM Comput- ing Surveys, 52(6):1–36, 2019

Andreas Kuster and Christoph Gotsman. A survey on post- processing techniques in computer graphics.ACM Comput- ing Surveys, 52(6):1–36, 2019. Covers various techniques in post-processing, with focus on effects like bloom and light- ing adjustments. 1

2019
[11]

Bloom example image, 2024

LearnOpenGL. Bloom example image, 2024. Accessed: 2024-11-11. 2

2024
[12]

Deep learning.Nature, 521(7553):436–444, 2015

Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning.Nature, 521(7553):436–444, 2015. 1

2015
[13]

Artificial neural network based smart and energy efficient street lighting system: A case study for residential area in hosur.Sustainable Cities and Society, 48:101499,

Prabu Mohandas, Jerline Sheebha Anni Dhanaraj, and Xiao- Zhi Gao. Artificial neural network based smart and energy efficient street lighting system: A case study for residential area in hosur.Sustainable Cities and Society, 48:101499,
[14]

Deep shading: Con- volutional neural networks for screen-space shading.arXiv preprint arXiv:1603.06078, 2016

Oliver Nalbach, Elena Arabadzhiyska, Dushyant Mehta, Hans-Peter Seidel, and Tobias Ritschel. Deep shading: Con- volutional neural networks for screen-space shading.arXiv preprint arXiv:1603.06078, 2016. 3

2016 arXiv
[15]

Accessed: 2024-11-30

NVIDIA Corporation.CUDA Toolkit Documentation, 2023. Accessed: 2024-11-30. 5

2023
[16]

Elsevier, 3rd edition,

Matt Pharr and Greg Humphreys.Physically Based Render- ing: From Theory to Implementation. Elsevier, 3rd edition,
[17]

Torchscript: A scripting language for pytorch models, 2019

PyTorch Contributors. Torchscript: A scripting language for pytorch models, 2019. Accessed: 2024-11-30. 6

2019
[18]

Mseloss — pytorch 2.0 documenta- tion.https : / / pytorch

PyTorch Team. Mseloss — pytorch 2.0 documenta- tion.https : / / pytorch . org / docs / stable / generated/torch.nn.MSELoss.html, 2024. Ac- cessed: 2024-11-17. 3

2024
[19]

U-net: Convolutional networks for biomedical image segmentation

Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. InMedical Image Computing and Computer-Assisted Inter- vention – MICCAI 2015, volume 9351 ofLecture Notes in Computer Science, pages 234–241. Springer, 2015. 3

2015
[20]

Neural illumination: Lighting prediction for indoor environments

Shuran Song and Thomas Funkhouser. Neural illumination: Lighting prediction for indoor environments. InProceedings of the IEEE/CVF Conference on Computer Vision and Pat- tern Recognition (CVPR), pages 6918–6926, 2019. 1

2019
[21]

Version 2024.1.0, available athttps://unity.com/

Unity Technologies.Unity3D Game Engine, 2024. Version 2024.1.0, available athttps://unity.com/. 2

2024
[22]

https : / / docs

Unity Technologies.Unity3D URP 14.0 Bloom, 2024. https : / / docs . unity3d . com / Packages / com . unity . render - pipelines . universal @ 14 . 0 / manual / post - processing - bloom . htmlAc- cessed: 2025-01-26. 5, 6

2024
[23]

Unity asset store.https : / / assetstore.unity.com, n.d

Unity Technologies. Unity asset store.https : / / assetstore.unity.com, n.d. Accessed: 2024-11-26. 4

2024
[24]

Motion sickness in virtual reality, 2023

VirtualSpeech. Motion sickness in virtual reality, 2023. Ac- cessed: 2024-11-14. 2 9

2023
[25]

Neural supersampling for real-time rendering.ACM Trans

Lei Xiao, Salah Nouri, Matt Chapman, Alexander Fix, Dou- glas Lanman, and Anton Kaplanyan. Neural supersampling for real-time rendering.ACM Trans. Graph., 39(4), Aug
[2016]

Discusses light simulation in rendering, relevant to techniques such as bloom and light estimation. 1

Pith tools

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

[1] [2]

Real-time post- processing effects in 3d rendering.Game Developer Mag- azine, 2008

Laurent Bavoil and Alain Dufresne. Real-time post- processing effects in 3d rendering.Game Developer Mag- azine, 2008. Discusses various post-processing effects in- cluding bloom. 1

work page 2008

[2] [3]

The frame rate of a virtual reality headset, 2023

BrandXR. The frame rate of a virtual reality headset, 2023. Accessed: 2024-11-14. 2

work page 2023

[3] [4]

readthedocs

Szabolcs Dombi, 2024.https : / / moderngl . readthedocs . io / en / 5 . 8 . 2 / index . htmlAc- cessed: 2025-01-26. 5

work page 2024

[4] [5]

John O’Rorke Greg James. 2

work page

[5] [6]

Accessed: 2025-01-26

Kronos Group, 2024. Accessed: 2025-01-26. 6

work page 2024

[6] [7]

Opengl: A graphics api, 2024

Khronos Group. Opengl: A graphics api, 2024. Accessed: 2024-11-11. 1

work page 2024

[7] [8]

Springer, 2001

Herbert Haas.Digital Image Processing. Springer, 2001. Gaussian blur technique described in the context of image filtering. 3

work page 2001

[8] [9]

Neural network ambient occlusion

Daniel Holden, Jun Saito, and Taku Komura. Neural network ambient occlusion. 2016. 3

work page 2016