Gophercamp2026

Sessions

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

21 sessions confirmed

Beyond Go: Leveraging Native C/C++ Libraries Safely with cgo

What really happens when Go’s garbage-collected runtime meets unmanaged C++ code? This talk explores how to integrate C/C++ libraries into Go applications using cgo — without sacrificing safety, maintainability, or observability. Drawing from a production DNS filtering engine backed by LMDB and integrated across runtimes, we’ll examine memory ownership rules, pointer passing constraints, runtime boundaries, and real-world pitfalls.

Speaker

Bridging Legacy C++ and Go with AI Agents

Many Go teams are not replacing C++ overnight. They are building new Go services next to legacy C++ systems that still own critical paths, shared data models, and years of operational knowledge. The hard part is usually not syntax. The hard part is coordinating changes across code, configs, telemetry, tests, and runbooks without losing control. This talk shows a practical way to use AI agents and MCP as workflow glue between those two worlds. Using one concrete migration story, it walks through how an agent can map call-sites across a C++ and Go boundary, draft a migration plan, support safe experiments with flags or shadow traffic, propose reviewable changes on the Go side, and help keep observability and documentation in sync. The goal is not to put agents on the hot path or let them rewrite risky low-level code. The goal is to expose each language’s tools consistently, set clear safety boundaries, and use agents where workflow automation actually helps. Attendees will leave with a repeatable migration playbook, a clearer trust model for agent-assisted engineering, and practical ideas they can try in their own mixed-language systems.

Speaker

Building Multi-Agent Systems in Go with ADK

Building Multi-Agent Systems in Go with ADK (practical deep-dive). Walk through ADK Go's architecture - orchestrator/synthesizer patterns, session management, tool routing and conversation state handling.

Speaker

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

Create You First Linter

I have created many linters and some of them are available in golangci-lint. I would like to show how easy it is to create a linter in Go, but also, how powerful it is. The goal is to enforce your style guidelines in your CI pipelines, reducing cognitive load and letting your team focus on what matters: the code and the business logic.

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

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

Learning Go by deploying with Talos Linux

I deploy a microservices Go application on an immutable OS (Talos) locally on my laptop utilizing a stack consisting of Go backend gRPC, WebSockets, NATS message broker and Postgres database.

Speaker

let a mage do it

how to build composable dev env automation using magefiles when working in organizations with multiple go teams, it's common to have duplicated "automation" in the develoment environment setup (scripts to run tests, upload results, lint code, etc.) makefile is the most commonly used entrypoint for these commands in go, but it doesn't scale and can't easily be composed magefile is a rake inspired cli that solves this by allowing to build this in pure go, can be distributed as a library that many projects can simply use

Speaker

Lighting talks

Alex: Why Go Hides Spin Locks? Juraj: Go tiny with Tiny Go

Speakers

Multi-file downloads with zipserve

You probably know how to use archive/zip to stream multiple files in a zip archive directly to a client. But you don't get a progress bar and can't resume the download this way. So many services write the archive to a cloud object storage first and then let the user download it from there instead. With zipserve, you can assemble a zip archive dynamically and directly serve it to the client with support for progress bar and resumable downloads. This talk explains how zipserve works and how you can use it in your service to improve the user experience of multiple-file downloads.

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

TinyGo - Embedded Workshop

Introduction to embedded development with TinyGo. Content of workshop: - Blinky - The first simple application for MCU - Sensor - Reading values from sensors - Wi-Fi - Connecting DevKit to the network and Go service - Possibilities of running small AI edge models The workshop is beginner friendly. No prior knowledge about embedded development is required. Recommended: - Installed Go and TinyGo on your computer - USB-C cable - Check the latest release of TinyGo: https://tinygo.org/blog/2026/tinygo-0-41-the-big-release/ DevKits will be provided during the workshop.

Speaker

Transpiling Go to Rust and Others

Abstract Goany (https://github.com/pdelewski/goany) is a transpiler that takes a subset of Go and compiles it to C++, C#, Rust, JavaScript, and Java, allowing developers to write portable libraries once using familiar Go syntax and tooling. In this talk, attendees will learn why Go's simplicity makes it uniquely suited as a transpilation source, how to design a minimal yet practical language subset for cross-language compatibility, and what trade-offs arise when mapping Go constructs to fundamentally different languages. Talk Description Have you ever implemented the same logic twice because one component was written in Go and another in a different language? This is a common problem in polyglot systems, and existing solutions — C bindings via FFI, IDL-based code generation, or transpilers like HAXE — each come with significant trade-offs: adoption barriers, serialization overhead, or the need to learn an entirely new language. This talk introduces a different approach: using Go itself as the source language for cross-language transpilation. https://github.com/pdelewski/goany is not a theoretical exercise — it is a working project that already transpiles Go code to five target languages. During this session, I will show practical examples of transpiled code, including a C64 emulator and a GUI demo running in the browser, and walk through the design decisions behind building such a tool. But building a transpiler is only half the challenge — the other half is deciding what to transpile. I will cover: - The problem: why reusing logic across language boundaries remains painful, and why existing approaches (FFI, Protobuf/gRPC, HAXE, FusionLang) fall short in certain scenarios - Why Go is a great fit: its small, well-defined spec, comprehensive standard library, and strong tooling make it an ideal transpilation source — unlike custom languages, every goany program is a valid Go program - Designing the subset — what to include and why: the guiding principle behind goany's subset is to include only constructs that produce nearly one-to-one correspondence between input and output in every target language. I will walk through the reasoning behind what made the cut (primitives, slices, structs, multiple returns, methods, loops, conditionals) and what was deliberately left out (goroutines, generics) with examples of how each decision affects the generated code. The subset is intentionally a work in progress — it started minimal and is gradually expanding as new constructs prove they can be mapped cleanly across all targets - How goany works: a walkthrough of the transpiler architecture — parsing Go's AST, mapping the chosen subset to target language constructs, and producing readable output in C++, C#, Rust, JavaScript, and Java - Live demos: a C64 emulator and a GUI application running in the browser via JavaScript transpilation, demonstrating that this focused subset is already sufficient to build non-trivial, real-world applications - Challenges: dealing with memory model differences, producing idiomatic output, and the ongoing tension between expanding the subset and maintaining clean transpilation The key insight of this talk is that designing a transpiler subset is not about supporting as many features as possible — it is about finding the largest common denominator across target languages, and evolving that denominator over time as you learn what works. Attendees will walk away with a concrete framework for thinking about cross-language compatibility, practical knowledge of building tools on top of Go's AST packages, and a new perspective on how Go's deliberate simplicity enables use cases that more complex languages cannot.

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.

Separate Ticket Required

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

Using AWS Lambda to Create Serverless Go Apps

Learn how Go and AWS Lambda can be used to build scalable serverless backends without managing traditional servers. This talk shows how to structure Go-based Lambda functions and integrate them with AWS services to replace or simplify classic server-side architectures.

Speaker

Your Go Logs Are Misleading You: The Case for Wide Events

Our current logging habits—spamming slog.Info deep in our domain logic and double-logging errors—are noisy, expensive, and actively hostile to on-call engineers. In this talk, we’ll explore a fundamental architectural shift for Go applications: The Wide Event (Canonical Log Line). We will look at how to leverage Go’s `context.Context` to accumulate high-cardinality data throughout a request's lifecycle, emitting exactly one rich, searchable log at the boundary. You’ll learn how to clean up your business logic, seamlessly integrate with OpenTelemetry, and pragmatically roll this out to a legacy monolith without begging your PM for a 3-month refactoring sprint. Let's stop writing diaries, and start building analytics.

Speaker