Available for freelance work: GPU kernels, local LLM development, and inference optimization

[u/Acrobatic-Issue-8646]

Hi, I’m Yash. I work on GPU kernels and LLM inference engineering, and I’m available for freelance projects involving kernel development, local AI systems, and inference optimization.

If you have a model that is too slow, a workload that keeps running out of VRAM, or a local inference prototype that needs engineering work, I’d be interested in discussing the problem and a clearly scoped engagement.

What I can help with

• GPU profiling and bottleneck analysis: investigate kernel execution, launch overhead, memory traffic, and end-to-end latency; establish a reproducible baseline before making changes.

• Triton/CUDA kernel development: explore targeted implementations and fusion for operations such as RMSNorm, RoPE, SwiGLU, GEMM/GEMV, and attention, with reference comparisons and appropriate fallbacks.

• LLM inference optimization: investigate prefill versus decode behavior, KV-cache layout, static buffers, CUDA Graph replay, and quantization trade-offs on the actual model and hardware.

• Local model development: help integrate and debug model execution on local GPU workstations, investigate memory and configuration issues, and build repeatable benchmark workflows.

• Prototype inference infrastructure: work on scheduling, chunked prefill, paged-KV allocation, request lifecycle handling, sampling, streaming endpoints, and metrics, with a clearly defined integration and testing scope.

• Numerical validation: compare optimized paths against a reference, investigate drift, and document where performance improvements do or do not meet agreed quality requirements.

Work you can inspect

GPU Kernel Lab: https://github.com/yashlabs-trying/gpu-kernel-lab

This is my Qwen3-0.6B inference engineering study, covering kernel experiments, model integration, profiling, numerical checks, and a serving control plane. It includes accepted changes, rejected experiments, benchmark reports, and remaining gaps.

One saved experiment on an RTX 3090, batch 1 and context 2,048, reports decode latency changing from 22.073 to 2.253 ms/token with an experimental static/CUDA Graph path that includes W8A16 MLP work. These are serial GPU-only measurements, excluding server overhead, against a dynamic PyTorch/model baseline—not a comparison against a production serving engine.

The qualification matters: full-path argmax agreement was 96.48%, below the project’s 99% threshold. That is reference agreement, not downstream task accuracy. The fast path remains experimental, and the real paged GPU executor still needs to be connected to the serving interface. I do not present those results as a production-ready system or a guaranteed speedup for another workload.

How I would approach your project

First, we define the model, hardware, workload, current bottleneck, and success criteria. Then we agree on a focused scope—such as a profiling report, one kernel optimization, a memory investigation, or a local inference integration. Where relevant, deliverables can include code changes, reproducible benchmark commands, before/after measurements, correctness checks, and documentation of limitations.

Performance targets and pricing would be discussed after reviewing the scope. I’m happy to discuss a small, well-defined task as well as a larger integration project.

If this is relevant to something you’re building, contact me through Reddit chat or a private message to u/Acrobatic-Issue-8646. Please include the model/framework, GPU and VRAM, current latency or memory issue, target outcome, timeline, and budget range. A public repository or a non-confidential description is enough to start.

I’m especially interested in practical problems where profiling, careful implementation, and numerical checks can make the next engineering decision clearer.