Waspy is an ahead-of-time compiler that translates a typed subset of Python directly into compact WebAssembly, without shipping a Python interpreter or runtime. This talk explores the design choices behind that approach, including typed intermediate representation, direct Wasm code generation, closed-world compilation, memory layout, and the trade-offs involved in supporting Python’s dynamic semantics. This talk compares Waspy’s approach with interpreter-based Python-on-WebAssembly systems, discuss how supported programs are validated against CPython, and look at the current limitations around memory management, dynamic language features, and interoperability. The talk ultimately asks a broader compiler-design question: how much Python can we compile without shipping Python itself?

This talk explores how a CUDA backend was added to kornia-rs, a Rust computer vision library built for robotics and embedded deployment, without relying on Python, libtorch, or the OpenCV C++ runtime. CUDA kernels are written as CUDA C strings, compiled at runtime with NVRTC, cached for the process lifetime, and launched through cudarc. The talk covers the design journey from cuda-oxide to CubeCL and finally NVRTC, benchmark results showing up to 2.0× speedup over OpenCV's CUDA module and 6.5× over PyTorch, and why kernel performance alone isn't enough once transfer costs are considered. It also looks at results on Jetson Orin, the hardware this design ultimately targets.

Padmashree gave a talk on “Enabling Documentation-Aware Language Features in SourceKit-LSP”, which was based on her GSoC project, “DocC Language Features in SourceKit-LSP”. She discussed the evolution of the project, starting with the initial approach of module-wide symbol graph generation during background indexing, the challenges faced with this approach and how they overcame these challenges with on-demand, single-node symbol graphs. She also demonstrated the DocC language features implemented on top of this approach.

Ashutosh and Akash talk about teaching students the etiquette of open source contributions beyond simply submitting pull requests. They discuss effective communication with maintainers, handling rejection, responsible use of AI, and practices such as peer reviews and internal contributions that help students contribute meaningfully without creating unnecessary work for maintainers.

Saniya Fatima talks about extending capa, an open-source malware analysis tool, to support scripting languages such as Python, Bash, JavaScript, and C#. Based on her Google Summer of Code project with FLARE, she explains how Tree-sitter enables capability extraction from scripts, along with capa’s architecture and analysis workflow. The talk also covers the key design decisions behind the integration and concludes with a live demonstration of capa’s binary and script analysis capabilities.

Dhruv Puri tells the story of two crashloops in RudderStack, an open-source event pipeline, running on Kubernetes. Neither acts were caused by a bug in RudderStack. In the first, a tight CPU limit throttled a single-threaded control plane until its liveness probe timed out. ArgoCD then reported the fix as "Synced" while the old limit stayed live, because client-side apply doesn't remove fields it never recorded. In the second, a routine memory spike on a small shared node squeezed the page cache and pushed the node's disk past its IOPS limit, so five unrelated pods crashlooped without a single OOM kill or eviction. The talk covers how CFS CPU quotas actually work, why a health check can't tell a dead app from a slow one, and the Kubernetes gotchas behind both failures.

Ashutosh Pandey and Akash Singh share their experience of building and growing developer and open source communities through LLVM Social Bangalore, IICT, SEGFAULT, and Point Blank. They talk about how to bring people into a community, deepen their involvement, and turn participants into active contributors through open source, hackathons, meetups, conferences, and mentoring. The talk also highlights how to build communities that grow sustainably and continue to thrive beyond individual organizers.

Padmashree S S talks about how language-server technology can bring IDE-style feedback to documentation workflows. Based on her Google Summer of Code project with SourceKit-LSP, she explores how diagnostics, navigation, syntax highlighting, and real-time feedback can improve documentation authoring, using DocC as a case study and sharing insights from her open-source development experience.

GiGi Koneti talks about EntropyKV, a lightweight approach to reducing LLM KV cache memory usage on consumer GPUs. The talk explains how value-weighted key norms and layer-adaptive allocation can compress long-context memory without the overhead of attention-based methods, using an OS-inspired caching strategy. It also explores the concept of semantic quantization and demonstrates how EntropyKV enables long-context models to run efficiently on GPUs with limited memory.

Owm Dubey talks about what happens inside Android when an app is launched, taking a closer look at the system components that make app startup fast and efficient. The talk covers Android’s Zygote forking model, the journey from tapping an app icon to rendering the first frame, and the differences between Jetpack Compose and the legacy View system. It also explores how developers can navigate Android’s open-source codebase to better understand and debug the platform.

Shreyas Hegde talks about how Julia enables GPU programming across NVIDIA, AMD, Intel, and Apple hardware using a single kernel. The talk introduces the JuliaGPU stack, including GPUCompiler.jl, KernelAbstractions.jl, GPUArrays.jl, and AcceleratedKernels.jl, and explores how Julia’s compiler infrastructure handles cross-vendor GPU execution. It also covers the performance challenges of portable GPU code and insights from contributing to the JuliaGPU open-source ecosystem.

Bhuvan talks about how LLVM’s compilation pipeline differs when targeting CPUs and GPUs. The talk compares x86-64 and NVPTX compilation, exploring shared optimization stages, GPU-specific divergence analysis, register allocation, and instruction selection across NVIDIA and AMD architectures. It also looks at LLVM’s growing role in GPU development and the future of open GPU tooling.

Saalim Quadri talks about the internals of Android’s Launcher3, exploring how it powers the home screen, app launching, widgets, search, recents, and personalized experiences such as the Google Feed. The talk covers Launcher3’s architecture, its integration with SystemUI, overlay plugins, and the implementation of custom “-1” panels, along with practical insights from maintaining and customizing Launcher3 across Android releases.

Ashutosh Pandey and Akash Singh share how Google Summer of Code became the foundation for building thriving open source communities in India. Ashutosh explores how GSoC helped grow India's compiler ecosystem through LLVM Social Bangalore, compiler conferences, hackathons, educational initiatives, and the ACM SIGPLAN India chapter. Akash then highlights PointBlank, a student-run open source community that has guided dozens of students into GSoC and sustained open source contributions far beyond the program.

Dhruv Puri delivered a talk on Kubernetes policy enforcement, explaining how Kyverno adopted CEL-based policies and introduced namespace-scoped policy types to address RBAC complexity, improve multi-tenant isolation, and reduce admission latency. He also shared insights into Kyverno's architecture and practical strategies for optimizing policy performance.

Yash Agarwal delivered a talk on distributed AI training using Megatron-Core and Kubeflow Trainer on Kubernetes. He explained how tensor parallelism enables large models to run across multiple GPUs, how distributed training components communicate through tools like torchrun, and why correct GPU configuration is critical for successful training runs. The session also explored common failure points in real-world deployments, including NCCL issues, shared-memory limitations, GPU-count mismatches, and pod placement challenges, while providing practical guidance for debugging and reproducing distributed training workloads.

Ashutosh Pandey delivered a talk where they explored the field of compiler technology. He discussed everything like how beginners could get started to the exciting research problems currently being tackled in the field. He outlined how compilers power modern tech in unexpected places and shared information about community events across India.

Ashutosh Pandey delivered a talk as to how compiler technology is everywhere powering everything from Android and Postgres to AI frameworks like PyTorch. He outlined how most modern systems rely on LLVM to bridge the gap between software and hardware and how right now is the best time for the field. He also talked about the problems for the people to work on like automatic parallelisation, phase ordering, Program Synthesis, Automatic Compiler Verification, Polyhedral Optimization. At the end he gave a brief introduction to the LLVM monorepo and provided a roadmap for beginners to join this field.

Akash Singh and Dhruv Puri dove deep into the building blocks every modern engineer needs: Linux fundamentals, Git workflows, version control best practices, branching strategies, CI/CD pipelines, containerization with Docker, cloud-native infrastructure, and DevOps culture as a whole. They also talked about about building first-principles problem-solving skills, reading documentation, understanding your git diffs, and why knowing what's happening under the hood matters.

Akash Singh and Pratik Singh delivered a talk on "Reducing AWS Glue Bills by 25x Using Airflow," where they shared a favorite infrastructure success story as to how they slashed their AWS Glue costs from $10,000/month → $400/month across 80 ETL pipelines leading to a 96% cost reduction. This was done by migrating to Apache Airflow on EKS but the beauty of airflow lets you run it with n number of connectors / any platform!. It was a great session highlighting how smart architecture and the right tools can drive incredible efficiency and cost savings.

At the CSS Workshop co-located with the FSTTCS Conference in Goa, Ashutosh Pandey presented an experimental investigation into the reliability of LLM-generated C code. The talk demonstrated that security-aware prompting alone does not consistently prevent crashes or unsafe behaviors, and analyzed how factors such as prompt structure, example guidance, temperature, and programming language choice influence model failure patterns. The presentation highlighted deeper concerns around robustness, evaluation methodology, and the limits of prompt-based safeguards in safety-critical code generation contexts.

During the CSS Workshop at the FSTTCS Conference, Kamini Banait, Madhur Kumar, and Prajwal K P delivered a research-focused talk exploring the behavior and analytical consequences of intermediate representations generated by tools like Ghidra and P-code. The session dissected structural and semantic variations across IRs, discussed their relevance to binary analysis and lifting accuracy, and reflected on the complexities of translating machine-level constructs into analyzable abstractions. Their work sparked technical discussions on correctness, abstraction fidelity, and security analysis strategies.

Pratik Singh spoke about the evolving landscape of CI/CD where continuous code quality becomes a core focus, especially with AI becoming an integral part of developer toolchains. He explored how modern CI/CD pipelines can integrate automated AI-driven quality checks — from intelligent code suggestions and static analysis to vulnerability detection and test automation — to improve software reliability and reduce manual QA overhead. Singh highlighted the challenges and opportunities of combining AI with traditional DevOps practices to create feedback-rich, quality-centric deployment workflows.

Pratik Singh delivered a practical session on transforming common Terraform pitfalls into robust, policy-compliant Infrastructure as Code using GitOps and KCL (Kubernetes Configuration Language). He walked through how teams can leverage KCL to validate Terraform plans against organizational policies early in the development lifecycle, enforce least-privilege resource definitions, and prevent misconfigurations that lead to security or compliance issues. The talk emphasized integrating this validation into GitOps workflows to automate error detection, improve governance, and increase confidence in IaC deployments.

Ashutosh Pandey delivered an engaging session on growing a specialized tech community around compilers, programming languages, and systems from small beginnings to nearly 2000 engaged members. He shared strategies for community building, including regular meetups, active collaboration, inclusive engagement practices, and leveraging online platforms to sustain momentum. Through real-world anecdotes and lessons learned, the talk highlighted how consistency, clear purpose, and supportive environments can help scale niche technical communities effectively, inspiring contributors to connect, learn, and grow together.

Pratik Singh delivered a talk on reducing the operational burden of platform engineers by leveraging Argo CD together with reusable Kustomize templates. He outlined how template-driven configuration can cut down on repetitive YAML creation and how combining this with Argo CD’s GitOps model allows teams to standardize application deployments while enabling self-service onboarding. The session explained the role of App Project RBAC in empowering developers to customize and deploy applications independently, improving consistency, productivity, and predictability across Kubernetes deployment workflows.