I build high-performance backend and ML infrastructure, and I validate it against references instead of trusting it.

At Reliance Jio, I work on production 4G/5G analytics, deterministic query compilation and GPU-backed inference on Kubernetes/OpenShift, including a 13-node, air-gapped, IPv6-only deployment. Outside work, I contribute to PyTorch, DuckDB, bpfilter and other C++ and ML projects, and build tools for GPU performance and distributed coordination.

Eleven merged changes across six upstream C++ and Rust projects (PyTorch, DuckDB, bpfilter, Apache Arrow nanoarrow, Apache Arrow Rust, OpenTelemetry C++); the six 2026 bug fixes each carry a regression test that fails without the fix, and every GPU claim below was measured on rented hardware and committed.

PyTorch core — three accepted changes
Enabled existing dynamic-shape support for foreach operations by default under torch.compile, with a test update (#158985). Exposed rearrange through the torch.func public API, with tests and documentation (#173183). Fixed the cuDNN CTC loss for strided log_probs and zero-initialized its gradient buffer, which cuDNN leaves unwritten past each sequence's length, with tests that compare loss and gradient against the native kernel (#203097).

DuckDB — two merged pull requests
SELECT DISTINCT over an unnested struct covered only the columns as written, not the expanded fields, so rows collapsed wrongly; the binder now regenerates the targets after binding (#27973). The deprecated materialized C API left a result half-initialized when it met an untyped SQLNULL column, so later accessors read a missing null mask and segfaulted on SELECT NULL, 42; translation now handles SQLNULL (#27707).

Meta’s bpfilter — three merged pull requests
Added IPv4 Type of Service and IPv6 Traffic Class matchers, including command-line parsing, BPF code generation and unit tests (#364, #369); the IPv6 implementation uses endianness-safe byte loads. Fixed meta.probability above 50 %, where a sign-extended 32-bit immediate in a 64-bit BPF compare made every such rule match 100 % of packets (#597).

Apache Arrow Rust — one merged pull request
Sped up sparse-dictionary row encoding in arrow-row by gathering Utf8, LargeUtf8, Binary and LargeBinary dictionary values with typed kernels instead of a per-row dynamic extend: about 21–24 % lower mean time on the prepared 8,192-row string-dictionary benchmark for dictionaries of 32K–4M values (#12113).

Apache Arrow nanoarrow and OpenTelemetry C++ — one merged pull request each
Made nanoarrow's testing JSON comparison recurse into nested and dictionary child fields' metadata (#993). Removed a misaligned sockaddr_in access in OpenTelemetry C++'s SocketAddr, with a regression test that fails on the original header even without sanitizers (#4725).

_{Landing commits: PyTorch foreach · rearrange · CTC loss · DuckDB DISTINCT · SQLNULL · bpfilter probability · arrow-rs dictionary gather · nanoarrow metadata · OpenTelemetry sockaddr.}

infer-determinism — finds where LLM-inference GPU kernels stop being deterministic or batch-invariant, by comparing raw output bits for a fixed probe request under batch-size, position, padding, split-KV and CUDA-graph perturbations. The first run on an H100 NVL covered seven targets (PyTorch, vLLM, FlashInfer, vLLM FlashAttention, fused MoE). No divergence was recorded for the runnable torch_sdpa backends, vLLM's direct batch-invariant kernels, fused MoE, or FA2/FA3 with num_splits=1; it recorded two candidates: float32 torch.mm after vLLM's init_batch_invariance() (low severity, since model Linear layers use the Triton path), and FlashInfer CUDA-core decode with disable_split_kv=True, already reported upstream as flashinfer#7981. That run's attention probes used head dimension 64. A second H100 run added GQA, head dimensions 128 and 256, sliding windows and FP8 KV cache: vLLM FlashAttention with num_splits=1 and FlashInfer tensor-core decode with disable_split_kv=True showed no divergence, and one low-severity candidate turned up, FlashInfer prefill at head dimension 128 giving different bits under CUDA-graph replay than in eager mode. Both runs used one GPU. Source · Run 1 results · Run 2 results

spsc-latency — four bounded single-producer/single-consumer ring buffers in C++20, written from scratch (sequentially consistent indices on one cache line, acquire/release on one line, separate lines, and separate lines with a cached peer index), with a throughput and round-trip-latency harness and stress and ThreadSanitizer tests of 100 million transfers per design. On a pinned Threadripper PRO 3995WX (shared rented host), the cached design moved 133.8 M items/s with a one-way p99.9 of 140.5 ns for 8-byte messages at capacity 1024, median of 3 trials, clock overhead not subtracted. An unpinned Apple M2 Pro run is also committed. Source · x86 results · M2 results

orderbook-latency — a single-instrument limit order book in C++20 with a std::map baseline and a preallocated engine that does not allocate on the hot path; a differential test replays 500,000 messages through both and checks they agree, under normal and ASan/UBSan builds. On a pinned Threadripper PRO 3995WX (shared rented host), the fast engine's p99.9 was 281 ns against 471 ns, and its batched throughput 20.8 against 10.7 M messages/s, median of 3 repeats on the default synthetic stream, timer overhead not subtracted. Single-threaded, not an exchange gateway. Source · x86 results · M2 results

Also built: 3D Point Cloud Viewer — C++/OpenGL, octree-based culling and level-of-detail rendering.

Have a systems problem worth digging into?
I’m interested in backend, distributed-systems, ML-infrastructure and performance-engineering work.

Frisco, Texas · Open to relocation
Email · LinkedIn · Hugging Face