Gophercamp2026

Sessions

Discover the talks, workshops, and lightning talks at Gophercamp 2026

13 sessions confirmed

This list is not final and subject to change.

Caching filesystem access

The session will introduce common problems one has to deal with when implementing caching of filesystem access in a highly scalable system, in particularly in Kubernetes' kubelet. You will be introduced to logic primitives that are useful in a system with parallel access, all wrapped in a pluggable design for accessing cached authorization records from a host system. You will also learn the tradeoffs of staying effective while keeping your solution resource-limited. I will describe basic benchmarking techniques that are helpful when assessing performance of a system so that you have an actual proof that your caching implementation is useful, and under which conditions.

Speaker

Concurrency and thread limit in Go

What are the practical limits of concurrent programs in Go, and what happens if you breach them? A fuckup story.

Speaker

Finding Bugs Before Your Users Do

Your service is in production. A user says it's slow. Another says data is stale. Your logs show nothing wrong. This talk walks through a real debugging session: metrics reveal the pattern, traces pinpoint the layer, structured logs expose the root cause. You'll see how to instrument a Go service with Prometheus, OpenTelemetry, and structured logging, without drowning in noise. Walk away knowing exactly what to record, what to ignore, and how to build alerts that actually help.

Speaker

Green Tea GC: The Insight Behind Go's New Garbage Collector

Green Tea's insight is elegant: scan spans, not objects. But how do you actually implement that? What data structures track which objects are marked vs. scanned? Why does the ownership protocol use three states? And how did span-based scanning unlock SIMD optimizations that were impossible before? This talk dissects Green Tea's implementation: the inline mark bits structure, the FIFO span queues, the ownership protocol that prevents duplicate work, and the AVX-512 SIMD kernels in Go 1.26 that use a cryptographic instruction (VGF2P8AFFINEQB) for bitmap expansion. I've read the actual runtime code and understand why each design decision was made.

Speaker

How Go Optimizes Your Code

Curious how the Go compiler transforms and optimizes your code behind the scenes? This talk is for you.

Speaker

Kronk: Hardware accelerated local inference

In this talk Bill will introduce Kronk, a new SDK that allows you to write AI based apps without the need of a model server. If you have Apple Metal (Mac), CUDA (NVIDIA), or Vulkan, Kronk can tap into that GPU power instead of grinding through the work on the CPU alone. To dog food the SDK, Bill wrote a Model Server that is optimized to run your local AI workloads with performance in mind. During the talk, Bill will show how you can use Agents like Cline and Kilo Code to run local agentic workloads to perform basic work.

Speaker

Leak and Seek: A Go Runtime Mystery

Join us for an in-depth exploration of the Go runtime, where we unravel a real-world memory leak mystery that pushed us deep into the internals of the language. Based on our blog post "Leak and Seek: A Go Runtime Mystery" (https://cyolo.io/blog/leak-and-seek-a-go-runtime-mystery) , this talk takes you behind the scenes of a complex debugging journey. We'll walk through the unexpected behavior we uncovered around Go's finalizers, the pitfalls around it, and the tooling we used to diagnose the issue. Our investigation didn't just end with a fix—it sparked upstream GitHub issues, engaged the Go community in lively discussions, and led to changes planned in future Go releases. You'll leave with insights into Go finalizers, practical debugging strategies, and access to an open-source tool that can help you catch similar issues in your own projects.

Speaker

Observability-Driven Development: Why 99.9% uptime doesn't mean your product works

Abstract Your users are leaving before you know they had problems. A slow signup flow, a failing payment endpoint, or a broken onboarding step. By the time you hear about it from support tickets, you've already lost trust and revenue. Most Go applications start with great intentions: fast iteration, clean code, and rapid shipping. But without the right observability foundations from day one, teams end up flying blind. Metrics live in one place, logs in another, and there's no way to connect a spike in error rates to actual user impact. In this talk, I'll share hard-won lessons from building production systems at scale and show you how to instrument Go applications with user journeys at the center. You'll learn how to build a minimal, effective observability stack using OpenTelemetry, connect technical signals to business outcomes, and establish SLOs that Product and Engineering can co-own. This is not a talk about adding more dashboards. This is about shipping fast with confidence. What You'll Learn 1. Why observability is a Day 1 decision - The cost of flying blind: churn, firefighting, and lost roadmap time - How to measure user outcomes, not just server health - The difference between good and great early-stage observability 2. Building the minimal observability stack in Go - Instrumenting with OpenTelemetry: metrics, traces, and structured logs - Choosing the right backends: Prometheus, Tempo, Loki (or managed alternatives) - Connecting technical signals: from metric spike → trace → log → user impact - Practical Go patterns: middleware, context propagation, and sampling strategies 3. Making SLOs about user journeys - Defining SLIs/SLOs for core flows (signup, checkout, onboarding) - Shared ownership between Product & Engineering - Using error budgets to balance speed and reliability - Release guardrails: detecting regressions in minutes, not hours Target Audience - Go developers at startups or scale-ups who want to build observability from the ground up - Engineering leads balancing velocity with reliability - Product Engineers who need to understand user impact, not just server metrics - Anyone who has debugged production issues by guessing Prerequisites: Basic Go experience. No prior observability knowledge required.

Speaker

Protobuf internals

Ever wondered how Protocol Buffers really work under the hood? In this talk, I’ll peek inside the wire format, explore VarInt encoding, and learn how to parse Protobuf messages in Golang, even without knowing their schema. Perfect for Gophers curious about low-level magic behind the scenes.

Speaker

Supply Chain Security

While Go modules include several technical safeguards against supply chain attacks, they aren’t bulletproof. Join this talk to uncover how your supply chain is protected, where the blind spots remain and what steps you can take to minimize risk.

Speaker

The Self-Building Gopher

We've been in the era of agents since the start of 2025. But how do we move from "cool demo" to a tool we don't hesitate to use in production, without spending eight hours debugging an agent's hallucination? This session explores the journey of building and scaling coding agents within the Go ecosystem. We will move beyond the hype of tools like Claude Code and Codex to focus on the engineering discipline required to make them useful. Key highlights include: - The "Test-First" Mandate: Why testing agents from day one is the only way to prevent infinite debugging loops and resource waste. - The Self-Building Gopher: A practical demonstration of using Claude Code and Go to create an agent capable of extending its own capabilities. - Architecture for Autonomy: How to structure a Go codebase so that an agent can safely navigate, implement "skills," and self-correct through a native feedback loop.

Speaker

Ultimate Private AI

This is a hands-on, full-day workshop where you'll go from zero to running open-source models directly inside your Go applications — no cloud APIs, no external servers, no data leaving your machine. You'll start by loading a model and running your first inference with the Kronk SDK. Then you'll learn how to configure models for your hardware — GPU layers, KV cache placement, batch sizes, and context windows — so you get the best performance out of whatever machine you're running on. With the model tuned, you'll take control of its output through sampling parameters: temperature, top-k, top-p, repetition penalties, and grammar constraints that guarantee structured JSON responses. Next you'll see how Kronk's caching systems — System Prompt Cache (SPC) and Incremental Message Cache (IMC) — eliminate redundant computation and make multi-turn conversations fast. You'll watch a conversation go from full prefill on every request to only processing the newest message. With the foundation solid, you'll build real applications: a Retrieval-Augmented Generation (RAG) pipeline that grounds model responses in your own documents using embeddings and vector search, and a natural-language-to-SQL system where the model generates database queries from plain English — with grammar constraints ensuring the output is always valid, executable SQL. Each part builds on the last. By the end of the day, you won't just understand how private AI works — you'll have built applications that load models, cache intelligently, retrieve context, and generate code, all running locally on your own hardware.

Speaker

Understanding Escape Analysis in Go - How Variables Move Between Stack and Heap

As a seasoned Go developer responsible for developing and maintaining a registrar backend to handle connections with about 40 registries and about 1k req/min I have to make sure the system is always well handled and performant. In order to make sure of it, escape analysis is a key part in it that I had to consider in it. - Why Escape Analysis Matters The Go compiler automatically decides where variables lives on the stack (fast, automatically freed) or heap (managed by GC, slower). While many developers never think about memory allocation, understanding escape analysis can be crucial for performance-sensitive code paths. Excess heap allocations increase garbage collection pressure and can slow down applications. - What Escape Analysis Is Escape analysis is a static compiler optimization that analyzes whether a variable can safely be kept on the stack. If a variable’s address escapes the function scope for example because it is returned or stored for later use the compiler must allocate it on the heap. - Code Walkthrough with Examples We’ll explore key patterns that force heap escapes or keep data on the stack: 1. Simple value return vs pointer return 2. Passing pointers and how this affects escape decisions 3. Why local pointers sometimes don’t escape Each example will include the -gcflags="-m" output to show the compiler’s reasoning. - How to Inspect Escape Behavior in Your Code Attendees will learn how to use `go build -gcflags="-m"` to see escape analysis annotations. We’ll interpret compiler messages and explain how they map to code behavior. - Practical Tips to Reduce Unnecessary Heap Allocations Beyond theory, the talk will cover actionable advice: 1. Prefer returning values instead of pointers when possible 2. Be mindful of interfaces and closures that may cause escapes 3. Understand allocations in hot paths and optimize where it matters

Speaker

Want to Present at Gophercamp?

We're still accepting proposals! Share your Go knowledge and experiences with the community.

Submit Your Proposal

Submission deadline: March 31, 2026