mokshagna prattipati
depthL7surface

L7 · surface · bengaluru

below theabstraction line.

Boot paths and page tables in a car. Order books and cache lines in a matching engine. Same problem both times — find where the machine is wasting time, and take it back.

↓ descend
MTCH-1 connecting…
spread —mid —resting 0
waiting for first print…
p50
—
p99
—
max
—
adds
0
0add_order latency—
Real measurements from the JavaScript engine in your browser, timed with performance.now(). Not the C++ engine — that one targets 200 ns p50 on a pinned core. The semantics are identical; the substrate isn't.

loading measurements…

seq 0
L6userland

Who's running the process

The part of me that a hiring manager meets first.

I'm Mokshagna — most people call me Moksha. I'm a systems engineer in Bengaluru, and I spend my time in the part of computing where the abstractions run out and you have to deal with the machine as it actually is.

Right now that means automotive platform work at Jaguar Land Rover — three operating systems sharing one ARM SoC, where a 600 millisecond regression in first-screen render is a real problem someone has to go find. Alongside it: kernel memory management, a compiler down to x86-64, a zero-copy IPC bridge, and a limit order book engine chasing sub-microsecond adds. The one above is that same design in JavaScript, so you can watch it work.

Embedded systems and trading infrastructure look like different worlds, and people are usually surprised I care about both. They're the same job. Both are hard-real-time. Both punish you for allocating on the hot path. Both come down to knowing exactly what the hardware is doing on every cache line — and being stubborn enough to keep looking after everyone else has decided it's fast enough.

I should be honest about the process: I start one thing and finish somewhere else. A boot investigation turns into reading lk-boot disassembly at midnight. The detours are usually where the good part was, so I've stopped fighting it and started writing them down.

L5application

What I ship, and who pays for it

Automotive platform and OS internals. Three operating systems, one SoC, a boot budget measured in milliseconds.

Multi-OS platform, ARM Exynos Auto

Jul 2025 — present

Jaguar Land Rover TBSI · Graduate SW Engineer · QNX, Linux, AOSP, C++, SELinux, cgroups, Yocto

  • Cut the boot KPI to 4.8s across concurrent QNX/Linux/Android stacks via devb-ram UFS piggybacking and asynchronous SLM dependency chaining.
  • Moved storage init into a native C++ service (persist_mount), using fork/execv to run blkid and resize2fs safely through custom SELinux domains during block-level migration.
  • Extended AOSP libprocessgroup so native cgroup (cpu, blkio) constraints propagate into the Java framework layer, isolating resources across the app lifecycle to prevent starvation.
  • Relocated core components into secondary IFS images and moved the primary IFS into high memory — 600ms off first-screen render, primary IFS down to 32 MB.
  • Reverse-engineered lk-boot to map UFS storage routing and break the single-core sequential loading constraint in early init.
  • Enforced SELinux domain transitions for LXC containers — lxcpower context inheritance, restorecon relabeling, patched Treble compliance tests.
  • GTest coverage for the Health Monitoring System at 92.9% line / 90.5% function; GDB core-dump analysis for segfault triage.

Dynamic partitioning for OTA

May — Jul 2024

Jaguar Land Rover TBSI · Software Intern · AOSP, Device Mapper, C++, Bash

  • Designed a dynamic read/write partitioning scheme on ARM Exynos Auto, bypassing fixed ECU constraints with a custom AOSP super-partition for OTA updates.
  • Built a native C++ tool and Bash CLI to manipulate AAOS Device Mapper mount paths, reconfiguring partitions on the fly at zero runtime cost.
  • Validated across 50+ automated expand/shrink cycles with zero data loss; co-authored the internal white paper that made it the baseline for future ECUs.
L4runtime

Things I built because I wanted to know

Source on github.com/Moksha2004. Each one started as a question I couldn't answer from reading.

Limit order book matching engine

v1 · measured2026 — ongoing

lowlat-orderbook · C++20, CMake · single-symbol, price-time priority, zero heap allocation on the hot path

  • v1 comes in under budget: add_order p50 —, cancel_order p50 —, against a 200 ns target. Timed with rdtsc over 200k iterations; full percentiles and the environment are published on the engine panel above, straight from the benchmark's own output.
  • Zero per-order heap allocation on the hot path, and not as a claim — an LD_PRELOAD malloc counter runs the proof: 100k add/cancel cycles, 0 allocations attributable to orders.
  • Flat array price ladder for mid ± 1000 ticks with a std::map fallback beyond it: O(1) indexing where the volume actually is, correctness without ever resizing on the hot path.
  • Intrusive doubly-linked FIFO per price level — orders live in a pre-allocated arena, so addresses stay stable for the OrderID → Order* map that makes cancels O(1).
  • Self-trade prevention (CancelNewest) and modify semantics that only surrender time priority on price change or size increase, matching CME/NASDAQ behaviour.

Zero-copy shared-memory bridge

Jan — Mar 2026

C++, Python, pybind11 · POSIX mmap, lock-free SPSC ring, AF_XDP, NumPy buffer protocol

  • Zero-copy C++ ↔ Python transport over POSIX mmap, skipping kernel context switches entirely — 1.18B msgs/sec throughput.
  • Lock-free SPSC ring buffer using acquire/release ordering, 64-byte cache-line padding (alignas(64)) against false sharing, and _mm_pause() backoff.
  • AF_XDP kernel-bypass ingest of raw UDP straight from the NIC into memory-mapped UMEM, eliminating per-packet syscalls and the kernel stack.
  • Raw C++ memory exposed through pybind11 and the Python buffer protocol for vectorized NumPy reads at 850M msgs/sec — 500× over OS pipes.

Kernel memory management and tracing

Aug — Nov 2023

GemOS · x86-64 · IIT Kanpur, Prof. Debadatta Mishra

  • Implemented mmap, munmap, mprotect and cfork with lazy allocation and copy-on-write, including VMA partitioning, coalescing and access-flag validation.
  • Wrote the page-fault handler against a 4-level page table (48-bit VA), mapping physical frames and refcounting PFNs for CoW sharing.
  • Built a circular trace buffer backing Linux-style strace and ftrace, intercepting invalid-opcode faults to capture syscall arguments and reconstruct nested backtraces.

Python subset → x86-64 compiler

Jan — Apr 2024

Flex, Bison, x86-64 · IIT Kanpur, Prof. Swarnendu Biswas

  • End-to-end compiler emitting x86-64 assembly: Flex lexer, Bison parser, optimized three-address-code IR.
  • Hierarchical symbol table plus a code generator handling register allocation and runtime stack frames for deep recursion.
  • Semantic analyzer enforcing static type safety across multi-level inheritance, overloading, typecasting and control flow, with traced errors.
L3kernel

Decisions, and the detours

Notes are decision logs — two designs were defensible, here's why I picked one. Detours are the other half: I start one thing and finish somewhere else, and the somewhere else is usually where the interesting part was.

L2firmware

Where software meets my hands

Drawings, paint, and things with wires. None of it is on my résumé and all of it is why I'm any good at the rest.

Drawing is looking at something long enough to see the structure underneath, then removing everything that isn't it. That's also what a profiler is for.

L1silicon

Bedrock

The numbers that aren't self-reported, what I reach for, and how to reach me.

WorldQuant BRAIN
11,483
Gold tier. 8 live systematic alpha signals on US equity universes, validated out-of-sample on Sharpe, returns and turnover.
LeetCode
1,760
Contest rating, peak 1,829 — top 9.72% globally. C++, weighted toward DP, union-find and divide-and-conquer.
JEE Advanced 2021
AIR 1837
Top 0.1%. Led to CSE at IIT Kanpur, minor in control systems.
Education
IIT Kanpur
B.Tech Computer Science & Engineering, 2021–2025. CPI 7.7/10.

Open to

Systems & low-level engineering
Kernel, embedded, platform, performance. The closer to the metal, the more interested I am.
Trading infrastructure
Quant dev or systems quant at an HFT or prop shop. Matching engines, feed handlers, kernel bypass.
Just talking shop
If you've shipped something fast and want to argue about how, I'll always make time. No agenda needed.
languages

C++, C, Python, x86-64 and ARM assembly, Bash

systems & os internals

Linux kernel, POSIX, QNX and RTOS, AOSP, virtual memory, IPC, lock-free concurrency, SELinux, cgroups

build & tooling

CMake, Yocto/BitBake, Docker, GTest, GDB, pybind11, Flex/Bison, Git