NS
Nayant Srivastava
01Experiments // Research

The Engineering Laboratory

Empirical investigations, numerical simulations, hypothesis tests, and prototype systems across computational domains.

Active Domains
6 Research Areas
Documented Sweeps
6 Published
Interactive Tools
ByteLogic Platform
Methodology
Empirical Rigor
02Empirical Sweeps // Evidence

Documented Experiments

Testing specific engineering hypotheses through measurement, ablation baselines, and synthetic stress injection. Click any experiment to inspect code kernels and mathematical derivations.

Filter Lab:
AI / ML·SEP 2026
Validated

Reduced-Order Neural Surrogate for Thermal Data-Center Airflows

Core Hypothesis:

"A Fourier Neural Operator (FNO) trained on localized Navier-Stokes CFD sweeps can predict rack temperatures with <1.0°C error while reducing latency by over 100x."

Experimental Setup:

16-rack containment zone simulated in OpenFOAM at 1.2M cell resolution. Evaluated across 240 transient workload spikes against an autoregressive FNO architecture.

Observed Empirical Result:

Mean absolute error was 0.64°C across all sensor probes. Step evaluation latency dropped from 18.4 seconds (CFD) to 4.1 milliseconds (surrogate) on a single edge GPU.

Scientific Conclusion & Verification:

Validated. Fast enough to operate within a real-time closed-loop RL control cycle without stability degradation.

Core Mathematical Implementation Kernel:
Reduced-Order Neural Surrogate for Thermal Data-Center Airflows
01import torch
02import torch.nn as nn
03from torch.fft import rfft2, irfft2
04
05class SpectralConv2d(nn.Module):
06    """Fourier Neural Operator layer for 2D convective temperature fields."""
07    def __init__(self, in_channels: int, out_channels: int, modes1: int, modes2: int):
08        super().__init__()
09        self.modes1, self.modes2 = modes1, modes2
10        self.scale = 1.0 / (in_channels * out_channels)
11        self.weights1 = nn.Parameter(self.scale * torch.rand(in_channels, out_channels, modes1, modes2, 2))
12        self.weights2 = nn.Parameter(self.scale * torch.rand(in_channels, out_channels, modes1, modes2, 2))
13
14    def forward(self, x: torch.Tensor) -> torch.Tensor:
15        batch, c, h, w = x.shape
16        x_ft = rfft2(x) # 2D Real-to-Complex Fourier Transform
17        out_ft = torch.zeros(batch, x.shape[1], h, w // 2 + 1, dtype=torch.cfloat, device=x.device)
18        # Complex multiplication in frequency domain
19        out_ft[:, :, :self.modes1, :self.modes2] = torch.einsum(
20            "bixy,ioxy->boxy", x_ft[:, :, :self.modes1, :self.modes2],
21            torch.view_as_complex(self.weights1)
22        )
23        return irfft2(out_ft, s=(h, w)) # Inverse FFT back to spatial mesh
Latency Reduction:140x
Max Local Error:0.64°C
AI / ML·AUG 2026
Validated

Symmetric vs. Asymmetric INT8 Quantization Drift in Autoencoder Latents

Core Hypothesis:

"Asymmetric min-max quantization preserves non-zero centered anomaly detection tails significantly better than symmetric zero-centered scaling."

Experimental Setup:

Tested across 100,000 synthetic sensor telemetry vectors with injection of extreme value power-law distributions. Compared reconstruction MSE and F1 score degradation.

Observed Empirical Result:

Symmetric quantization caused a 14% drop in tail event recall due to zero-point clipping. Asymmetric calibration retained 98.9% of full FP32 recall.

Recall Retained:98.9%
Compression Ratio:3.8x
Graphics·AUG 2026
Prototype

Draw Call Latency Under Vulkan Bindless Descriptors vs. Traditional Sets

Core Hypothesis:

"Transitioning from per-material descriptor set rebinding to a single global bindless texture array reduces CPU command buffer recording time by >60%."

Experimental Setup:

Omnix Engine benchmark scene rendering 8,000 distinct textured cubes with unique roughness/metallic maps. Profiled with RenderDoc and Tracy Profiler on RTX 4070.

Observed Empirical Result:

Command buffer generation time fell from 4.2ms to 0.9ms per frame. GPU execution time remained flat with minor cache improvement.

CPU Record Time:-78%
Draw Call Count:1 (Indirect)
Systems·JUL 2026
Validated

Multi-Producer Single-Consumer (MPSC) Ring Buffer Contention at 10M msg/s

Core Hypothesis:

"Cache line padding on atomic head and tail pointers prevents false sharing and scales linearly up to 8 producer threads."

Experimental Setup:

Synthetic benchmark dispatching 64-byte telemetry packets from 1 to 16 producer threads into a fixed-size 65,536 element circular buffer on an 8-core AMD Ryzen CPU.

Observed Empirical Result:

Unpadded version bottlenecked at 4 threads with severe cache coherence invalidation storm. Padded cache-aligned version maintained 12.4M msg/s throughput up to 8 threads.

Peak Throughput:12.4M msg/s
L1 Invalidation:-82%
Algorithms·JUL 2026
Validated

GPU vs. CPU Voronoi Tessellation for Real-Time Interactive Manifolds

Core Hypothesis:

"Evaluating Voronoi boundaries via fragment shader distance fields achieves consistent 60fps at 4K resolution compared to Fortune's sweep line algorithm on CPU."

Experimental Setup:

Canvas benchmark with up to 100 draggable centroids in ByteLogic concept demonstrations. Compared CPU Delaunay dual triangulation with WebGL fragment distance rendering.

Observed Empirical Result:

WebGL approach sustained solid 60fps even with 500 dynamic seeds; CPU polygon clipping began dropping frames at 80 seeds on low-power mobile devices.

Frame Rate:60 FPS @ 4K
Max Seeds:500+
Game Technology·JUN 2026
Exploring

Acoustic Obstruction Ray Tracing in Dynamic Voxel Enclosures

Core Hypothesis:

"Low-density bounding volume hierarchy (BVH) ray casting can estimate high-frequency audio dampening through architectural walls in under 0.2ms per sound emitter."

Experimental Setup:

Prototype voxel room scene in C++ testing early acoustic propagation algorithms for Last Transistor game world.

Observed Empirical Result:

Early sweeps show promise: 16 rays per listener provide believable occlusion filtering with <0.12ms compute overhead on background worker thread.

Ray Cast Latency:<0.12ms
Rays per Emitter:16
03Foundations // Curricula

Research Domains

Long-term computational categories defining current investigations and development goals.

// DOMAIN 01Active Vector

Artificial Intelligence & Machine Learning

Statistical learning, inference runtimes & reinforcement control

Empirical investigations into neural surrogate modeling, INT8 quantization frontiers, reinforcement learning stability, and unsupervised topology discovery.

Surrogate Physics ModelingINT8/FP8 QuantizationDeep RL ControlAttention PruningClustering Manifolds
Active: ADCTM, MINDLITE6 Sweeps
// DOMAIN 02Active Vector

Systems & Runtime Engineering

Low-latency C++, memory architectures & OS concurrency

Measuring hardware limits: cache hierarchies, memory bus saturation, lock-free queues, and asynchronous IO completion engines.

Lock-Free Data StructuresCache Line AlignmentZero-Copy IOThread PinningSIMD Intrinsics
Active: Omnix Core, MINDLITE Runtime4 Sweeps
// DOMAIN 03Active Vector

Algorithms & Computational Complexity

Graph theory, combinatorial heuristics & dynamic programming

Algorithm engineering beyond asymptotic big-O: cache-oblivious tree traversals, spatial hashing, and streaming cardinality estimation.

Spatial Acceleration TreesDynamic Graph PartitioningHyperLogLog SweepsVoronoi Generation
Active: ByteLogic Core5 Sweeps
// DOMAIN 04Active Vector

Computational Mathematics

Spectral linear algebra, optimization surfaces & differential manifolds

Translating continuous mathematical formalisms into numerically stable floating-point algorithms and visual geometric intuitions.

SVD & Spectral DecompositionConvex OptimizationMatrix CalculusStochastic Differential Equations
Active: ByteLogic Textbooks3 Sweeps
// DOMAIN 05Active Vector

Graphics & Engine Architecture

Vulkan/C++ rendering pipelines, compute shaders & simulation

Modern GPU rendering pipelines: bindless resources, indirect draw calls, compute-driven particle fields, and clustered deferred shading.

Vulkan Compute PipelinesBindless DescriptorsFrustum & Occlusion CullingParticle Simulation
Active: Omnix Engine4 Sweeps
// DOMAIN 06Long-term Vector

Game Technology & World Systems

Physics engines, spatial partitioning & real-time interactivity

Long-term research into interactive world building, deterministic simulation state, spatial audio propagation, and autonomous entity behaviors.

Rigid Body IntegratorsSpatial Audio Ray TracingHierarchical State MachinesEntity-Component Architecture
Active: Last Transistor2 Sweeps
Interactive Computational Visualizer

Interactive Experiments on ByteLogic

Don't just read static telemetry logs. Step through dynamic K-Means expectation-maximization manifolds, inspect 3D ASCII projection tori, and evaluate algorithm convergence live in the browser.

Launch K-Means ManifoldExplore ByteLogic Hub