EventTracer: Physics-Aware Event Rendering

Updated 9 July 2026

EventTracer is a path tracing-based rendering pipeline that directly simulates high-frequency event streams from complex 3D scenes using physics-aware methods.
It efficiently converts low-sample-per-pixel, noisy RGB sequences into realistic bipolar event spikes through a two-stage process involving the PixPulse network and BiLIF unit.
The pipeline bridges the gap between simulated and real event camera outputs, enhancing fidelity for downstream tasks such as reconstruction and depth estimation.

EventTracer is a path tracing-based rendering pipeline that simulates high-fidelity event sequences from complex 3D scenes in an efficient and physics-aware manner. It was introduced to address a persistent bottleneck in event-based vision: existing simulators either rely on noiseless RGB videos that are costly to render or operate at temporal resolutions equivalent to only $100\text{--}300$ FPS, far below the $<100\,\mu\text{s}$ regime associated with real event cameras. EventTracer combines low sample-per-pixel path tracing with a lightweight event spiking network that denoises rendered RGB videos into realistic event sequences, and it reports a runtime of about 4 minutes per second of 720p video while preserving physically grounded spatiotemporal modeling (Li et al., 25 Aug 2025).

1. Problem formulation and sensing model

EventTracer is grounded in the standard event-camera model in which each pixel emits an event whenever the change in logarithmic brightness exceeds a contrast threshold $\rho$ . The emitted datum has the form $(t,x,y,p)$ , where $t$ is the timestamp, $(x,y)$ is the pixel location, and $p \in \{+1,-1\}$ is the polarity indicating brightness increase or decrease. This sensing regime provides extremely high temporal resolution, very high dynamic range, and sparse asynchronous outputs focused on changes rather than full-frame appearance (Li et al., 25 Aug 2025).

The immediate motivation for EventTracer is dataset generation for event-based vision. Real event data are expensive to acquire, difficult to synchronize with frame-based imagery, and difficult to annotate densely with depth, normals, or segmentation. Simulating event streams from 3D scenes offers controlled camera motion, lighting, and geometry, but prior approaches face a three-way trade-off between physical realism, temporal resolution, and efficiency. Video-based simulators such as V2E and V2CE inherit the frame-rate bottleneck of their RGB inputs, while 3D-scene pipelines based on high-SPP path tracing can require seconds per frame at 720p and become impractical at $1000$ FPS (Li et al., 25 Aug 2025).

This framing places EventTracer at the interface between physically based rendering and neuromorphic sensing. Rather than treating events as a post hoc thresholding operation on low-rate videos, it renders high-frequency photometric changes directly from 3D scenes and then learns a sensor-like spiking transformation that is robust to low-SPP Monte Carlo noise. The result is a simulation pipeline intended to narrow the sim-to-real gap for downstream event-based learning systems (Li et al., 25 Aug 2025).

2. Rendering architecture

EventTracer has two principal stages: a low-SPP path tracing backbone implemented in Falcor, and a lightweight event-generation network called PixPulse. The path tracer renders RGB frames from static or dynamic 3D scenes at $F_{\mathrm{evt}} = 1000$ FPS. To reduce cost, it uses $N=64$ samples per pixel rather than the much larger sample counts otherwise needed for nearly noiseless path-traced video. PixPulse then converts the resulting noisy temporal RGB signal into a bipolar event sequence (Li et al., 25 Aug 2025).

Component	Function	Key details
Low-SPP path tracer	Render high-frequency RGB from 3D scenes	Falcor, $<100\,\mu\text{s}$ 0 FPS, $<100\,\mu\text{s}$ 1 SPP
PixPulse	Convert noisy RGB trajectories into event spikes	Pixel-wise 1D convolutional network
BiLIF unit	Generate signed event output	Outputs $<100\,\mu\text{s}$ 2 with leaky integrate-and-fire dynamics

The rendering stage is based on the standard rendering equation

$<100\,\mu\text{s}$ 3

with Monte Carlo path tracing approximating the integral by stochastic sampling. In EventTracer, the outgoing radiance estimate is computed with low SPP, which dramatically reduces cost but introduces visible Monte Carlo variance. The pipeline does not denoise these RGB frames into conventional videos; instead, it learns to map their temporal behavior into realistic event streams (Li et al., 25 Aug 2025).

This architecture is significant because it relocates the efficiency–realism trade-off. High-fidelity global illumination remains in the loop, but the expensive requirement of high-SPP noise suppression is replaced by a learned temporal sensor model. A plausible implication is that EventTracer is best understood not as a generic video simulator, but as a physics-aware event renderer whose image formation and event generation stages are jointly optimized for neuromorphic downstream tasks (Li et al., 25 Aug 2025).

3. Event-generation model: PixPulse and BiLIF

For each pixel $<100\,\mu\text{s}$ 4, EventTracer first converts the rendered RGB sequence into luminance

$<100\,\mu\text{s}$ 5

then applies a log transform with threshold $<100\,\mu\text{s}$ 6:

$<100\,\mu\text{s}$ 7

The temporal input to PixPulse is the sequence of log-brightness differences

$<100\,\mu\text{s}$ 8

This matches the event-camera convention that reacts to changes in logarithmic intensity rather than absolute brightness (Li et al., 25 Aug 2025).

PixPulse is a pixel-wise, temporally local network composed of 1D convolutions and residual temporal blocks. If $<100\,\mu\text{s}$ 9 denotes the temporal input for one pixel, the network applies an initial temporal convolution,

$\rho$ 0

followed by $\rho$ 1 residual 1D convolution blocks and a final projection

$\rho$ 2

after which a bipolar leaky integrate-and-fire unit converts $\rho$ 3 into an event sequence $\rho$ 4 (Li et al., 25 Aug 2025).

The BiLIF unit extends standard LIF dynamics to signed spikes. With membrane potential $\rho$ 5, threshold $\rho$ 6, and input current $\rho$ 7, charge and leak follow the usual LIF pattern, while the spike output is

$\rho$ 8

This produces positive spikes for brightness increases and negative spikes for decreases. Because BiLIF preserves an internal state and threshold-reset dynamics, EventTracer models polarity, saturation trains under large changes, and internal state bias in a way intended to resemble real event-sensor behavior (Li et al., 25 Aug 2025).

The choice of a pixel-wise temporal network is deliberate. It avoids spatial convolutions, keeps the receptive field short ( $\rho$ 9), and makes full-frame TensorRT deployment inside Falcor practical. At the same time, the combination of log-brightness differences, learned temporal filtering, and signed spiking provides a learned denoising-and-sensing stage rather than a simple deterministic threshold rule (Li et al., 25 Aug 2025).

4. Training objective, dataset generation, and empirical evaluation

PixPulse is trained using high-SPP, $(t,x,y,p)$ 0-FPS path-traced RGB videos as supervision inputs and V2E-generated event streams as targets. The training corpus consists of three scenes—Bistro Interior, Bistro Exterior Day, and Bistro Exterior Night—with a total of 7,936 frames. The loss is based on a bidirectional 1D earth mover distance. For target sequence $(t,x,y,p)$ 1 and prediction $(t,x,y,p)$ 2, the forward 1D EMD is

$(t,x,y,p)$ 3

and the bidirectional variant averages this quantity with the same computation on reversed sequences. EventTracer applies the loss separately to positive and negative events and adds a spike-count regularizer,

$(t,x,y,p)$ 4

yielding a total objective $(t,x,y,p)$ 5 (Li et al., 25 Aug 2025).

Using this pipeline, the authors construct ETScenes, a synthetic event-RGB dataset comprising six scenes, 90 seconds of video, about 6,000 RGB frames at 60 FPS, about 90,000 event “frames” at 1000 FPS, and ground-truth depth maps for each RGB frame. At inference time, EventTracer runs at 1.12 minutes per second of 360p event video and about 4 minutes per second of 720p video, substantially reducing the cost of path tracing-based event simulation at high temporal frequency (Li et al., 25 Aug 2025).

Evaluation uses a Real2Sim protocol in two downstream tasks. In event-to-video reconstruction, a representative result with E2VID+ gives SSIM/LPIPS/LPA of $(t,x,y,p)$ 6 on ETScenes, compared with $(t,x,y,p)$ 7 on ETScenes-V2E and $(t,x,y,p)$ 8 on ETScenes-V2CE. In event-to-depth estimation, EventTracer achieves AbRel $(t,x,y,p)$ 9, SqRel $t$ 0, RMSE $t$ 1, RMSE log $t$ 2, and SI log $t$ 3, compared with $t$ 4 for V2E and $t$ 5 for V2CE. Qualitatively, the authors report that EventTracer preserves more fine details such as lamps, window grids, chairs, street tiles, and scene texture at edges (Li et al., 25 Aug 2025).

These experiments support a specific interpretation of fidelity. EventTracer is not evaluated only by visual similarity of integrated event images; it is evaluated by how well real-data-trained downstream models behave on the synthetic streams. This makes the pipeline a data-generation instrument whose quality is defined operationally through reconstruction and depth performance rather than through purely photometric criteria (Li et al., 25 Aug 2025).

5. Position within event-based vision

EventTracer belongs to the event-based vision ecosystem, but it occupies a different functional layer from trackers, detectors, and generic backbones. Direct asynchronous trackers such as Event-ECC operate on event streams at the level of per-event motion compensation and continuous optimization, performing one Gauss–Newton ECC update per event to track features over time (Zafeiri et al., 2024). RGB–event trackers such as Mamba-FETrack instead fuse synchronized RGB frames and event streams with modality-specific backbones and report $t$ 6 on the SR/PR metric on FELT while reducing FLOPs from $t$ 7 to $t$ 8 relative to a ViT-S based tracker (Huang et al., 2024). Frequency-domain fusion methods such as FreqTrack make the spectral structure of RGB-event data explicit and report leading precision of $t$ 9 on COESOT (You et al., 16 Apr 2026).

The same distinction holds for infrastructure-level components. Event Transformer+ is a sparse, patch-based backbone for event-stream classification and dense depth estimation that exploits event-data sparsity to reduce computation on both GPU and CPU (Sabater et al., 2022). TUMTraf EMOT provides a roadside event-camera dataset, MOT-style annotations, and a tracking-by-detection baseline for traffic scenes, including 10 ms, 20 ms, and 30 ms event-image windows and benchmark results for vehicles and pedestrians (Li et al., 16 Dec 2025).

This places EventTracer upstream of much of the event-based vision stack. It is neither a tracker nor a recognizer; it is a simulator and dataset-construction pipeline. A plausible implication is that EventTracer can serve as a synthetic data substrate for methods that require high-frequency event streams with paired RGB, depth, or other labels, including reconstruction, depth estimation, tracking, and multimodal fusion systems (Li et al., 25 Aug 2025).

6. Broader meanings of event tracing and open issues

Although EventTracer is a specific 2025 rendering system in event-based vision, the broader literature uses closely related ideas in several other senses. In targeted event detection, labeled multivariate streams are converted into a univariate event score $(x,y)$ 0, and level shifts in that score stream are then detected online; the detector is “targeted” because it is trained specifically on segments labeled as events of interest (Stuetzle et al., 2010). In software instrumentation, JETracer provides real-time tracing of GUI events for Java applications based on AWT, Swing, and SWT, using a common EventMessage model and socket-based communication between agent and host (Molnar, 2017). In production-system incident localization, ACT compares sets of distributed traces from steady-state and incident periods and effectively localizes more than $(x,y)$ 1 of incidents (Ramasubramanian et al., 2022).

This suggests that “EventTracer” functions as a recurring event-centric design pattern across domains: transform raw event-bearing activity into a structured trace, score stream, or routed event representation that preserves the information needed for downstream reasoning. The 2025 EventTracer specializes that pattern to physics-aware event-stream rendering, but its emphasis on high-frequency streams, explicit temporal modeling, and downstream-task validation aligns with this broader family of event-oriented systems (Li et al., 25 Aug 2025).

Within the rendering pipeline itself, several limitations remain explicit. The authors note an event-count mismatch because PixPulse is only weakly constrained to match the exact number of spikes; ETScenes is relatively small and focused mainly on indoor scenes; and the simulator models scene radiance via path tracing but does not explicitly simulate lenses, point spread functions, or multispectral sensor physics. Future directions include better constraints on event counts, larger and more diverse synthetic datasets, and integration with differentiable optics or learned point spread functions (Li et al., 25 Aug 2025).