1,688 Active Repos | 344,628 Commits | 21,282 Contributors
THE SIGNAL
6,673 contributors show up in serving-related activity. Around 130 form its open-source core: the people active week after week in the subsystems that decide cost and tail latency (scheduler, KV-cache, attention backends, the model runner). That gap, between the visible population and the load-bearing core, is the shape of almost every category in this report.
Underneath, the work went where serving gets cheaper. FP8 and MXFP4 paths, blockwise quantization, FP8 MoE dispatch, tile-fusion kernels: low-precision work took the most commit volume, and it took it inside the serving, training, and edge codebases.
1,903 people across the open infrastructure write the fused low-precision kernels much of the stack builds on. Once one lands, it gets absorbed downstream into serving, training, and runtime code rather than staying isolated in a kernel library.
QoQ Snapshot
Every category grew, but the split is in composition. Model optimization, GPU kernels, and hardware co-design took on commits faster than people: an existing core, going deeper. Serving and training frameworks went the other way, pulling in newcomers onto stable foundations, though much of that intake stays shallow.
| Category | Code Commits | Code Contributors | Commits QoQ | Contribs QoQ |
|---|---|---|---|---|
| Hardware-Software Co-Design | 13,050 | 2,108 | +32% | +23% |
| GPU Kernels & Performance | 29,283 | 3,895 | +25% | +20% |
| ML Compilers & Graph Optimization | 14,224 | 1,557 | +17% | +16% |
| Inference Runtimes & Engines | 1,011 | 170 | +33% | +18% |
| LLM Serving & Inference | 8,561 | 1,997 | +15% | +20% |
| Distributed Training & Parallelism | 12,800 | 2,590 | +21% | +22% |
| Training Frameworks & Model Architecture | 11,205 | 1,832 | +21% | +27% |
| Model Optimization & Compression | 15,464 | 2,781 | +42% | +24% |
| RL Post-Training & Preference Optimisation | 4,523 | 704 | +18% | +16% |
| Edge & On-Device ML | 3,611 | 537 | +71% | +50% |
| ML Platform & Orchestration | 3,274 | 367 | +49% | +36% |
| ML Debugging & Tooling | 2,337 | 639 | +30% | +26% |
| Safety & Alignment Guardrails | 1,753 | 348 | +37% | +41% |
What’s Moving
🚀 LLM Serving & Inference
Serving this quarter concentrated on the request path: speculative decoding, chunked prefill, continuous batching, KV-cache management, and the disaggregation of prefill from decode so the two can scale on separate hardware. In the open serving repos measured here, model-level work barely figures. What lands is systems engineering against bursty, mixed production load, where cost and tail latency get decided. Unsurprisingly, the contribution still concentrates in vLLM and SGLang.
🧪 Training Frameworks & Model Architecture
Training splits in two. At the base sit the framework internals: Trainer abstraction and training loops, model definitions, tokenisation, checkpoint and state management (Orbax, NNX, TrainState), data loading, and fused-kernel integration into JAX and PyTorch, with the gravity in PyTorch’s compile-time internals. Above that sits a fine-tuning layer of parameter-efficient adapter training and no-code tools, easier to reach and more concentrated than it looks.
⚙️ GPU Kernels & Performance
FP8 stopped being experimental this quarter; it is the daily work now. Blockwise FP8 autotune kernels, grouped-blockwise persistent GEMM, and MoE dispatch-and-combine paths in FP8 are what landed. One forming cluster is worth watching: a handful of low-contributor megakernel repos filling with new hands this quarter around persistent-kernel and tile-fusion techniques. That is where the next cohort of attention-kernel specialists seems to be gathering.
🧠 ML Compilers & Graph Optimization
Compilers moved down the stack this quarter. Tensor and dataflow IR is going onto novel ISAs and network-on-chip topologies now, not only GPU and TPU. The pipeline underneath stays familiar: MLIR dialects and op-rewrite patterns, the XLA and StableHLO path, PyTorch’s Inductor and Dynamo internals, IREE and TVM lowering. It’s one of the deepest disciplines Deep Signal tracks and the slowest to onboard: the lowest new-contributor share of any growing category.
🔌 Hardware-Software Co-Design
Among the silicon programmes that develop in the open, AMD’s ROCm leads on volume and Tenstorrent is the largest non-incumbent, growing with the field rather than breaking out. Tenstorrent’s shape is the part worth reading: roughly half its commits are test and validation, and sustained contributors outnumber drive-by ones by a wide margin. That is an established, test-disciplined production org, well past early bring-up. As a category, it barely surfaces as public identities. Only about a fifth of its commits carry a public GitHub login; the rest come from corporate identities with little public footprint.
🧮 Model Optimization & Compression
Quantisation barely lives in dedicated optimization repos. The real work, MXFP4 and MXFP8, GPTQ and AWQ export paths, calibration and smoothing, the low-bit GEMM and dequant kernels that make a quantised model run, lands inside serving, training, kernel, and edge codebases. Counted where it actually happens, the real volume runs several times what the dedicated optimization repos show. One population here stands out: a genuinely independent specialist community working on GGUF, llama.cpp, and low-bit quantization formats like GPTQ and AWQ.
🎯 RL Post-Training & Preference Optimisation
Underneath the preference-optimisation loop, DPO, PPO, GRPO and RLOO variants, reward-model training, and the rollout and verifier environments that score generations as they train, sits a much smaller core: a few hundred people building the reward models and verifiers, the part that decides what “better” means. About half the work lives inside training-framework and serving codebases, the rest in research-lab instruction-tuning repos like AI2, Stanford, and Tencent.
Wider Field
Distributed Training & Parallelism. PyTorch’s distributed APIs are converging on DTensor as the common primitive: FSDP2’s per-parameter sharding, async tensor parallelism overlapping collectives with the matmul, MoE routing on all-to-all dispatch and grouped-GEMM. What this solves underneath is composing parallel layouts that used to be hand-built per combination. On the transport side, the visible concentration is torchcomms, a library being rewritten under load. It roughly doubled in its second active quarter, from 633 to 1,334 clean code commits (once generated documentation pages are stripped out). Commits largely centred on NCCL-OFI plugin development, HPC RDMA, and collective-algorithm DSL, carried by a small pool with an HPC-networking profile.
ML Platform & Orchestration. MLflow’s GenAI push is the live thread: span-based tracing of multi-step LLM calls and LLM-as-judge evaluation moving into the tracking server. Each platform is effectively single-vendor, built by the company that sells it.
Edge & On-Device ML. Four runtime targets, MLX, llama.cpp and ggml, ExecuTorch, and LiteRT, share little code and keep diverging, each deepening its own stack. Low-bit quantization runs through all of them, and this is the category drawing the most first-time contributors in what we track.
ML Debugging & Tooling. Profiling and evaluation pull opposite ways. Profiling is deep, vendor-staffed infrastructure (Kineto over CUPTI and roctracer, Nsight, Perfetto), while the most widely used eval harness has a handful of maintainers carrying most of it.
Inference Runtimes & Engines. Q1’s move is retrofit: TensorRT-LLM and onnxruntime-genai bolting KV-cache state and continuous batching onto engines (ONNX Runtime, Torch-TensorRT) built for stateless, single-shot inference. LLM serving broke both assumptions the original design rested on.
Safety & Alignment Guardrails. Safety is shifting from lexical filtering toward structural control, constraining how a generation is produced and scored, since pattern filters on finished text get bypassed. Almost none of it sits in dedicated safety repos: the rails live inside serving stacks like NeMo Guardrails and litellm’s hooks, the red-teaming inside eval tooling like promptfoo.
Where Talent Is Moving
Below, the portable skill is made visible. Kernel work sits at the centre, the one capability that reaches across quantization, distributed training, and silicon, which is why a kernel hire stretches further into the stack than a hire anywhere else. Compilers are the exception. They barely touch the rest of the graph, a closed discipline with little adjacent pool to convert from.
The thing to read here is timing. First-time hands are landing in edge (above half new this quarter), in the agent layer, and in the forming megakernel pool, all still early and active enough to identify before they consolidate. The load-bearing cores are closing the other way: compiler work onboards the slowest of any growing category, hardware co-design sits behind vendor walls, and the serving and kernel foundations are held by tenured hands who have stopped rewriting them.
Kernel and model-optimization overlap is the largest cross-area population here; compiler and serving share almost no one.
What the Headline Counts Hide
Every category here holds two populations inside one number: the people who touched the repo, and the smaller group who did the bulk of the work that decides the outcome. That gap is wider than public contributor counts let you see.
Serving collapses to a load-bearing core in the low hundreds. 6,673 contributors show up in serving-relevant activity this quarter. Only 1,997 contribute code touching serving subsystems; the remainder are visible through issues, reviews, documentation, and other project activity. Within that 1,997, 997 touch the subsystems that decide cost and tail latency: the scheduler, KV-cache (including prefix caching), attention backends and paged attention, prefill and the prefill/decode disaggregation that splits it from decode, continuous batching, speculative decoding, and the model runner. Sustained across multiple weeks, that group numbers around 130.
Two-thirds of GPU-kernel work happens outside kernel repos. Of the kernel-classified commits this quarter, only about a third sit in repos labelled as kernel libraries. The remainder lands inside serving, training, data, and compiler codebases. Source by kernel-library repo and you catch the dense concentrations while missing most of the authors doing kernel work elsewhere.
Same story with quantization, four-fifths off-label: most of it sits inside serving, training, kernel, and edge stacks rather than the dedicated optimization repos.
The market does not lack visible contributors. It lacks a way to separate the people who touched the repo from the people who actually did the work.
What This Means If You’re Hiring
Open-source hiring should start with the load-bearing core, not the visible population around it. The serving funnel above is the clearest example. A target list built from the open-source signal starts with the people who touched the core code.
Within that core, a durable specialist layer has formed. On speculative decoding and disaggregated prefill, the active pool grew roughly fourfold over five quarters, from under a hundred to around 400. Over the same period, the multi-quarter deep core (contributors sustained across three or more consecutive quarters) grew from 20 to 65. Two years ago this work had almost no proven returning specialists; today it has a stable nucleus that’s becoming easier to identify each quarter.
Kernel hiring runs on two facts that pull in opposite directions. The skill itself is broader than its reputation: under a narrow definition (FP8, tile-fusion, persistent kernels, fused attention), 1,903 distinct authors did this work this quarter. They are concentrated in AMD’s libraries (composable_kernel, aiter), but comparable populations sit inside vLLM and SGLang rather than dedicated kernel repositories.
Hardware experience tells a different story. Of 2,853 authors doing accelerator-kernel work, 2,055 worked on only one vendor’s silicon and just 214 showed work across three or more, even inside vendor-neutral repos. The crossings that exist are overwhelmingly NVIDIA-anchored: around 80% of the engineers who span vendors have NVIDIA among them, and the newer accelerators (Tenstorrent, TPU, Ascend) field far smaller pools to begin with, so proven cross-silicon talent for them is scarce in absolute terms.
The practical implication is that adjacent-stack sourcing works well for kernel talent, but proven multi-silicon experience remains exceptionally scarce. Compilers are the opposite: the graph shows almost no meaningful adjacency with the rest of the infrastructure stack, leaving little neighbouring talent to recruit or convert from.
Predictions
Q4 scorecard. Last quarter we said serving would fragment by hardware. It did: silicon-specific spin-offs now clear the 50-contributor threshold in the vLLM family (vllm-ascend, vllm-gaudi, tpu-inference). We said kernel skill would migrate into vector search. Early and narrow so far, GPU-index work is live in cuVS and DiskANN, a thin crossover rather than a broad shift. We predicted the training-framework contributor pool would contract below a set threshold. That call does not grade: the work-level recount moved the denominator it was written against. Reset for Q2.
- By Q2 2026: low-precision kernel work stays the largest single concentration of commit volume in the data, holding or extending its lead as quantized-inference demand keeps pulling engineering toward it.
- By mid-2026: the new-contributor-share gap holds or widens. The deepest infrastructure disciplines (ML compilers and ML debugging, each under a fifth new this quarter) keep compounding on a stable core, while edge and the agent layer, each above forty percent new, keep drawing fresh hands.
- By Q3 2026: the forming megakernel and persistent-kernel pool produces at least one breakout repo with a recognisable specialist core.
Adjacent Markets
🤖 Agent Framework grew sharply, on the largest contributor base in our coverage. Most of it is application engineering: agent orchestration, tool-calling, skill authoring, and the Model Context Protocol, which was the single busiest agent subsystem this quarter. The framework-engineering core underneath is a small fraction of that population, and the new-contributor share is among the highest we track. One to watch: shared contributors with LLM Serving and Training Frameworks are present; if that flow concentrates in serving-runtime work, it becomes a hiring signal.
🎨 Generative Media & Inference Apps is the smaller adjacent bucket, growing steadily. The work targets the product surface: node-graph execution in visual diffusion workflow builders and HTTP serving around image and video inference, more frontend and pipeline-wiring engineering than model work. Overlap with the infrastructure categories stays below a clear signal; the engineers building here and those building underneath are still different cohorts.
Methodology. QoQ category counts reflect real engineering work: we exclude merge commits, bot authors, release and version-bump automation, docs-only changes, and automated or generated bulk traffic, so a figure counts substantive code changes rather than noise. Category rows are not mutually exclusive and are not expected to sum to the headline commits and contributor totals.
Coverage and scope. D33P S1GNL tracks open-source contribution signal across the ML systems infrastructure layer at depth: over 4,500 primary repositories and their forks, with more than 200,000 resolved contributor identities classified across a taxonomy of 24 areas, 71 application domains, and 29 role families. This report surfaces a focused slice of that system: 1,688 active repos and 21,282 contributors this quarter, presented across 15 reporting categories. The two adjacent markets appear only in Adjacent Markets. The layer itself is where modern ML infrastructure is built: serving runtimes, compilers, kernel libraries, training frameworks.
This layer is largely open source (even where the proprietary model work above it stays private), so for roles built on it you can see what an engineer has actually shipped before the first conversation. Where that engineer also publishes, the same identity resolves across their research and models or datasets they’ve open-sourced, so the work behind the code connects to the work in it. That turns a category trend into a who, not just a how-many.
We only see public work: internal work at frontier labs and engineers under private identities are out of scope, and we don’t claim what we don’t measure.
Produced by Logikk, powered by D33P S1GNL. To discuss an ML Systems search: [email protected]. For full contributor-level signal access: D33P S1GNL.
Share Article
Get our latest articles and insight straight to your inbox
Hiring Machine Learning Talent?
We engage exceptional humans for companies powered by AI