PyCon Lithuania 2026 Schedule

Python's technical roadmap is public, yet most engineers only find out about language changes when something breaks in CI. Python is one of the few languages at this scale governed entirely by its community, which means every decision gets made in the open, and that transparency is a real competitive advantage. This talk is about learning to use it and understanding why the community behind it is what makes that possible in the first place.

Good documentation doesn’t happen by accident. But it also doesn’t have to be painful. This talk shows how Python developers can integrate documentation naturally into their daily work. We’ll look at docstrings, turn them into readable docs with reStructuredText and Sphinx, and learn how few organizational measures, docs-as-code practices, and automation can help—or get in the way …

The module `itertools` provides 20 tools. There's 19 iterables and then there's `tee`... But what does `tee` do and why is it the only thing in the module `itertools` that's not an iterable? In this talk you will understand what `tee` does and when to use it, but most importantly, you will understand the paradox behind `tee`... See, the thing is that `tee` seems to go against the laws of iterators...

We at One Codex work in the microbiology field. This means that we deal with massive taxonomy trees all the time. It is impossible to cover everything, so in this talk, I am going to focus on the best data structure to: - store tree data - serialize it - display it on the frontend

In the last few years, we’ve seen amazing progress around Python packaging for library code. Packaging applications usually requires more work, but thanks to recent developments it’s getting easier than ever. Will this be the year of packaging your Python app for the Linux Desktop?

This talk is for anyone curious about what it’s like to run FastAPI in production. An asynchronous web framework with automatically generated documentation and dependency injection, FastAPI has made huge gains in popularity and overtook Flask in the 2025 Stack Overflow Annual Developer Survey. FastAPI’s features are impressive and picking it up is easy, but beyond that what is it really like to run in production? What joys and pitfalls await those deploying the most popular Python web framework?

Explore how Apache Airflow modernized its massive monorepo by transitioning from complex custom scripts to official Python packaging standards and tools like uv. This session breaks down the management of 120+ distributions, the implementation of modular pre-commit hooks, and a novel approach to "static" shared libraries within a single repository. Join us to see a real-world blueprint for large-scale modularity as we advocate for the formalization of a Python workspace standard.

Free-threaded Python aims to significantly improve performance, allowing multiple native threads to execute Python bytecode concurrently. In this talk, we will explore the current state of Python's free-threading initiative and assess its practical readiness for widespread adoption.

Transitioning from data science to software engineering doesn’t mean starting over, it means translating the scientific method into systems work. In this talk I would share the DS habits that most improved my engineering. I would also cover the gaps that surprised me and the concrete techniques that helped me close them. The talk would include useful tools related to hpc, multi-agent systems that help improve the code and runtime.

Writing tests is an important part of every project. In this talk, I will show how to improve your tests using Pytest, Faker, and Hypothesis. We will start with Pytest, a simpler and more readable way to write tests. Then we’ll look at Faker, which helps create test data more easily. Finally, we’ll explore Hypothesis, a tool that generates random test cases to help find hidden bugs. You will leave this talk with clear examples and useful tips to write better tests in your projects using modern tools.

At some point, every Python developer hits a library that no longer fits. The docs end, the abstraction leaks, and you’re stuck between “best practices” and shipping. This talk starts with a mistake: modifying a library’s source code and proudly posting about it. It worked - and it taught me a better way. This isn’t a tool talk. It’s about mindset. Libraries aren’t sacred. They’re code. Code you can read, understand, and extend. And learning to look inside is a skill, not a sin.

What started as a single API call in 2020 is now 36 architectural patterns, open protocols adopted by 150+ organizations, and production systems shipping 1,300 pull requests a week without a human writing a line of code. This talk builds a shared vocabulary for that evolution — chronologically, in Python pseudocode, with the researcher or company that coined each pattern and exactly what it's called in the frameworks you use today.

Let’s make your functions smarter with decorators, simplify operations using lambdas, save memory with generators, and handle resources like a pro with context managers. We’ll mix clear explanations with hands-on practice - so you can write code that’s cleaner, faster, and feels Pythonic.

You use Python for your code why not use it to deploy code to the cloud too? Pulumi, an open source Infrastructure as Code library allows you to configure your cloud infrastructure using Python. In this session we'll deploy a data processing pipeline using Pulumi in GCP and talk through core concepts and fundamentals. Using this example we'll talk through practical best practice ensuring reliable and maintainable infrastructure that scales with your projects.

This talk offers a brief overview of cryptographic algorithms, going through their evolution from antiquity to our days. We will explore the origins of encryption, from early ciphers to the beginnings of computer-based cryptography, and then focus on key modern algorithms such as RSA, AES, and IES.

SQL is an excellent DSL for relational data, but ORMs hide it behind their own leaky abstractions. This talk shows how to build a cleaner persistence layer and use Postgres to its fullest, without the overhead you never asked for.

With more and more tools abstracting from a developer's workflows, understanding how git visualization tools help - not simply using it - is more important than ever. In this talk, we take a look at the history of git workflows, the basics of git, and the renaissance of understanding version control in a world gone mad for “vibe coding”.

The tools and workflows we use as developers are often as important as the code we write. The beauty of the Python ecosystem is that there are many options to the types of linters, formatters, type checkers, testing frameworks, and security scanners we can choose. However, too many options can paralyze decision making and often we use sub-optimal tools just because we've used them before. Learn some lessons from the tooling we use for maintaining, testing, and deploying our Python code at Mozilla.

Developers are excited about AI, but not about the proven practices that would make them faster today. I'll explore the efficiency gaps hiding in plain sight – from debugging habits to testing strategies to software design – and argue that these fundamentals become even more essential when AI enters the picture.

Every team has code that makes them cringe. Legacy pipelines nobody dares touch, "temporary" tables that became the source of truth, and SQL queries that outlived three team leads. We call it technical debt, and the instinct is always the same: fix it. But should we? After migrating from Redshift to Snowflake, learning PIG just to rewrite a pipeline deprecated months later, and surviving Airflow OOM kills, I have opinions. And maybe a framework slightly better than "it depends."

The carbon market is set to reach 1T dollars by 2030, yet 84% of offsets fail to deliver real climate benefits. Verification still relies on sparse site visits and self-reported data. This poster shows a Python workflow that audits carbon projects using satellite imagery and ML, detecting over-crediting and leakage in REDD+ sites. With open data and open-source tools, anyone can compare claimed versus observed forest outcomes and verify what projects actually deliver.

Building great engineering teams has never been straightforward — but the rules keep changing. Three back-to-back panel discussions with CTOs and engineering leaders covering the full spectrum: scaling teams and competing for talent in a small market, navigating a leadership role that looks nothing like it did five years ago (AI included), and making the hard calls on culture, tech debt, and architecture when there's no clear playbook to follow.

In 2025, classic data tests via Python are not enough. During 25-30 minutes talk I will show how Python powers modern Data Quality: from real-time freshness checks to anomaly detection and orchestrator integration. No AI hype: starting with quick Data Quality overview and problem statement I will show practical code, architecture, and hands-on engineering for resilient pipelines from Data Engineer/Data Quality Engineer perspective.

2D static plots are great, but they are static. Data isn't - it changes. So we turn a plot into an animation. But we don't live in planes - we live in space. And we want to send a message, not just show an animation. This leads us to the 3D animated story! In this talk I will close the gap between abstract data and its physical reality. Through step-by-step examples using (Geo)Pandas, (I)Pydeck, PyVista, Blender etc., I will turn basic charts into 4D stories with custom models added to geospace.

Statisticians and machine learning specialists have a lot to learn from each other (even if they don't think so). This talk lightheartedly awards points to both classical statistics and machine learning, with an attempt not to offend anyone (but to annoy everyone). Topics include: Are confidence intervals worth it? What is bias, anyway? Can I just code it in Python?

Airflow basics are well documented. Production Airflow is not. This talk covers the patterns, costs, and migration pitfalls that only show up after you've deployed: dynamic DAGs that scale, sensors that don't waste resources, CloudWatch bills that surprise you, and MWAA version upgrades that break in ways the changelog didn't mention. Practical lessons for teams running Airflow beyond the tutorial stage.

How do you turn thousands of PDFs into actionable insights? This talk shows how we built a Python-based AI assistant using LLMs and RAG to automate literature reviews: covering architecture, trade-offs, and real lessons from production use in policy research.

Python struggles with heavy data loads. Rust offers speed, and PyO3 makes bridging the two seamless. This talk shows how to build a shared Rust core to avoid code duplication. I will also cover using Apache Arrow for zero-copy data sharing and removing serialization costs entirely. Discover how this stack enables high-performance data processing in Python and Pyspark

Python enables data professionals to move beyond analysis and transform information into clear, compelling stories. With various libraries, Python supports insightful exploration, expressive visualizations, and interactive elements that enhance communication. This talk highlights practical techniques for turning patterns, trends, and insights into engaging narratives, making data more understandable, impactful, and actionable.

The web isn’t an API, but Python developers often treat it like one. This talk explores how to design Python interfaces for unstable data sources, focusing on schema evolution, defensive parsing, and protecting downstream users.

Unlock the power of Quantum Machine Learning (QML) with Python and Qiskit. You will explore the distinctions between classical and quantum machine learning and gain an understanding of data encoding, quantum kernels, and the training process of a Variational Quantum Classifier. You’ll also discover how Qiskit Functions integrate quantum into application workflows to solve complex challenges. Finally, you’ll explore IBM case studies showing the transition to practical "quantum utility."

Many teams work with datasets that evolve over time. What starts as simple setup, quickly turns into chaos once updates become regular. In this talk, I share a practical workflow for managing dataset updates by splitting the process into clear stages, each represented by a Python script. This approach was used in production for two years on image datasets from 2,000 to 200,000 samples and helps small teams reduce cognitive load and keep dataset and model updates predictable.

This talk introduces how Python and FastText can be used to detect low-resource African languages using the MasakhaNER dataset. We cover key preprocessing steps, evaluation methods, and challenges such as dialectal variation and sparse data. The session also compares FastText with African-focused NLP tools like AfroXLMR and Masakhane Models, offering clear guidance on when each tool works best.

One of the core fundamental pieces of technology every software-related tech stack is heavily dependent on is Git. The ability to version code and control the flow of development is the only common focus for every software project. We take for granted that everyone in the working industry can indeed properly version code. In this talk, we’ll explore the meaning of data versioning and how we could borrow methodologies from the software engineering field to better manage our data.

Have you ever faced an enormous, wide table? Sometimes you need to cope with it because it's faster in this form, and that's what your stakeholders need. Anyway, it’s hiding entities, metrics, and time semantics. Learn how the dissection framework reveals schema structure and turns risky rewrites into surgical precision.

When your embedding-based classification model fails, should you collect more data or try a different approach? This talk shares a practical XAI workflow using UMAP visualization and prototype analysis to uncover systematic failures. We will explore how to use these tools to identify semantic overlaps and make evidence-based decisions when debugging high-dimensional similarity systems.

In 1952, two statisticians proposed a simple model for comparing sports teams. In 1960, it became the foundation of chess ratings. Today, that same math powers everything from ChatGPT's alignment to Chatbot Arena leaderboards. But you don't need to be OpenAI to use it. I'll show how Bradley-Terry and preference-based ranking can solve everyday problems: comparing A/B test variants, ranking search results, evaluating ML models, prioritizing features, and more.

Modern digital lending demands instant decisions, and behind those decisions is a Data Science workflow powered by scorecard. This talk explains how scorecards calculates credit risk in a transparent and scalable way, from feature engineering to production deployment. Using real examples from our company, models that enable fast, reliable loan approvals.

We are told that modern data engineering requires expensive cloud warehouses and enterprise SaaS. This talk challenges that narrative. I will show how I built scoris.eu - aggregating business data from hundreds of sources across Lithuania, Latvia, Estonia, Finland, and the UK - as a solo developer. Using a purely open-source Python stack (dlt, dbt, Prefect) on cheap infrastructure, I will demonstrate that with the right architecture, you can integrate data at scale without burning cash on the cloud.

Just what does Claude Code need access to and why? In this talk, we'll dive into privacy and security concerns when using LLMs, code assistants and AI agentic workflows. Aside from making you more paranoid, you'll leave with some practical tips on how to cover your prompts in tin foil and avoid the worst types of mistakes.

Tutorial: Unsloth for Small Language Models Fine-Tuning Small Language Models (SLMs) can deliver strong performance with far lower computational demands than large LLMs, making them ideal for on-device, edge, or cost-sensitive applications. However, fine-tuning them effectively and quickly on limited hardware remains challenging. This hands-on tutorial on Unsloth, an open-source library that makes fine-tuning SLMs dramatically faster and more memory-efficient.

What if you could watch an AI’s thought take shape? For years, LLMs have been impenetrable "black boxes," but we are finally beginning to find ways to see how the ghost in the machine actually works. This talk explores **mechanistic interpretability**, a subfield of AI that aims to understand the internal workings of neural networks. Mapping these internal "circuits" is not only just a philosophical curiosity - or duty: it is a high-stakes engineering necessity for safety, debugging, and trust.

Even small changes in LLMs can impact output quality, safety, and user experience. In this talk, we’ll show how to log experiments with Langfuse, automate tests with Pytest, and enrich them using Hypothesis-generated random data scenarios. Participants will learn how to use code, tests, and data-driven A/B tests to improve LLM development.

Context Engineering is the new prompt engineering. As agentic workflows grow, just appending messages to a list causes context poisoning and latency spikes. In this talk, we'll look at a better architecture using the `deepagents` library. We'll explore the four pillars of context engineering: Write, Select, Compress, and Isolate. You'll learn how to treat context as a finite resource and build autonomous agents that can solve complex tasks without crashing your context window.

GenAI-based projects are easy to prototype, but hard to test. In this hands-on workshop, we will build a simple AI chatbot from scratch and, in parallel, create an AI agent that tests it during development. The testing agent will generate user scenarios, detect failures such as prompt issues, incorrect tool usage, etc., and then suggest concrete next steps for improvement. The core theme of the workshop is building AI systems with the help of AI itself, while keeping an engineering-driven approach to design

Catch silent ML failures before they reach production! This session demonstrates lightweight, practical techniques to validate and monitor ML models across their lifecycle. Using tools like DeepChecks and Evidently AI, attendees will learn how to detect data drift, evaluate model quality, and ensure trust in their models with minimal effort.

Legacy migrations, tangled integrations, undocumented business logic – every team has that category of work nobody wants to touch. This talk shares practical lessons from using AI to tackle exactly those challenges. Through the example of a real IT system migration – normally a 2–4 year project – we will show how AI can compress the timeline to weeks, reduce the pain, and even make it fun.

**I haven't written a single line of code in over a year.** As CTO of an AI startup, I've fully embraced vibe coding: orchestrating AI to generate production-ready code. 🔍 **Highlights** 1. **The paradigm shift:** from autocompletion to full project generation 2. **My 3-step workflow:** voice prompts, deep research, code generation 3. **The judgment trap:** why expertise matters more than ever You'll leave with practical techniques to ship 10x faster!

Reverse engineering binaries once required deep expertise. Today, AI models like Opus 4.6, GPT-5.3-Codex, and Gemini 3.1 Pro change the rules. Watch how pairing AI with the NSA's Ghidra decompiler or simple hex tools like xxd makes binary hacking accessible. We will dive into practical projects: hacking infinite lives into Atari’s River Ride, porting the legacy game Chromatron, decoding LED backpack protocols, and hunting for backdoors. Let me show how to add reverse engineering to your everyday skills.

In this talk, I propose to discuss the problem of building explainable AI with the two approaches - causal vs correlational. I will talk about what mech interp in LLMs. As a way to understand how models answer questions by looking inside them and checking which neurons activate when. I will discuss Anthropic's open sourced a python module - circuit-tracer, the Neuronpedia portal , will also talk about my own work with "activation cube" data structure (this is not a standard - I came up with it)

Retrieval-Augmented Generation (RAG) often produces incorrect results when relying solely on vector-based similarity. While vector search is strong, it fails on exact keywords, acronyms, and domain-specific terms. This talk shows how to build high-accuracy RAG pipelines with Hybrid Search and Re-ranking using LangChain, combining vector and full-text retrieval and applying cross-encoder scoring to deliver more relevant context and reduce hallucinations.

Quantum Machine Learning (QML) combines quantum computing and classical machine learning, but its practical value is often misunderstood. In this hands-on workshop, we will explore QML using Qiskit, build and run real quantum machine learning models, and compare them with classical approaches. The session focuses on practical intuition, runnable Python code, and a clear discussion of current advantages, limitations, and realistic use cases of QML.

Most teams iterate on prompts by eyeballing outputs and hoping for the best. This talk presents a different approach: connect your prompt to a measurable downstream outcome, build a test set, and let metrics drive improvements. I'll walk through a complete feedback loop - from prompt to retrieval metrics to automated error analysis to LLM-powered iteration - and show how this turns prompt engineering from guesswork into something you can actually measure and improve systematically.

LLMs can answer questions, but can they conduct research? Real research requires planning, data gathering, synthesis, and refinement. This talk explores Python patterns for orchestrating multi-step workflow to create autonomous research agents. We'll deconstruct the agentic architecture, from DAG-based planning to reflection loops, and show how to implement these concepts using practical Python patterns.

AI-generated "slop" is overwhelming vulnerability triage and burning out maintainers. This session focuses on building a unified framework to identify and "black-hole" synthetic noise at scale. We will discuss practical, cross-platform strategies to automate the rejection of low-signal reports and protect engineers from the unsustainable volume of AI-augmented disclosures.

I'll discuss building capabilities on top of on-device language models, with Rewrite as a case study – a publicly available paraphrasing skill that is widely used across Microsoft's products. I'll cover comprehensive data collection strategies, carefully designed adapters training and evaluation. I'll discuss the engineering challenges we faced: achieving target latency while maintaining quality, hardening the system against edge cases, and how to deliver the technology to partners and the lessons learnt.

As AI agents evolve from simple chatbots to complex multi-agent systems utilizing Model Context Protocol (MCP), manual validation becomes impossible. During this talk, I will demonstrate the process of architecting a quality assurance loop for these solutions. No theoretical fluff: I will focus on the practical analysis of automated pipeline results, interpreting Langfuse reports for cost and performance, and ensuring reliability from an AI Architect/System Engineer perspective.

AI systems are not neutral; they encode values that are opaque and separate from people. As developers, we are making decisions that shape who has power, who is surveilled, who is replaced, and who gets a voice, often without intending to. This talk frames AI ethics as a software engineering problem, not just a philosophical one. We’ll examine how everyday technical choices can unintentionally reinforce authoritarian tendencies around disinformation, manipulation, and harmful automated decision making.

Retrieval pipelines can improve from user feedback-but connecting signals like likes, dwell time, and clicks back to model retraining is tricky. This talk walks through an architecture for doing it: hybrid candidate generation (BM25 + embeddings), neural reranking, feedback collection, building evaluation sets, and the retraining loop. Concrete examples from production, with trade-offs between different approaches.

In this session, we explore Specification-Driven Development (SDD) and its implementation in the Kiro IDE. You will see how machine-readable specifications drive the entire lifecycle—from EARS-based requirements to automatically generated code, tests, and documentation. The session also highlights the industry shift from developers as coders to developers as orchestrators of AI agents, defining intent and architecture while AI executes and validates the implementation.

The cost of software development has fallen to $10.42 an hour—less than minimum wage. A burger flipper at Macca's earns more. What does it mean to be a software developer when everyone in the world can develop software? Tools like Cursor have commoditised the knowledge and skill of software development, enabling non-developers to build and ship.