PythonAsia 2026

In the late 2000's to Early 2010's, I visited the Philippines a total of 6 times while serving in the United States Marine Corps. There I had found memories of enjoying my time with others and sharing in the amazing food and experiences. In the moment, the experiences were great but they didn't become legendary until word got around and the hype was built.

In 2026 much of our storytelling has changed from diving deep to buzz and hype in shortform. FOMO has never been higher but it's from the comfort of our couches and glossed by AI summary and algorithm-chasing. This is coming at the cost of community. ""Why participate when I can get the talks online and AI can teach me all the things""?

This talk tells stories of community and legend. It shares how communities can grow from ice cream parlors and random meetings at 5am morning walks.

As Large Language Models (LLMs) expand into global markets, they often hit a "Nuance Gap" or a failure to distinguish literal meaning from cultural context. This presentation examines the technical hurdles of building culturally competent AI through two lenses, namely, linguistic ambiguity (sarcasm) and localized safety (toxicity). Using the Philippines as a case study, we identify four critical hurdles: (1) the Linguistic Inversion Problem, where sarcasm flips intended sentiment; (2) the Context Vacuum, where text lacks the "cultural scaffolding" necessary for interpretation; (3) the Data Desert of low-resource languages; and (4) the Western-Centricity of standard safety filters. We propose a roadmap for researchers to move beyond literal translation toward AI that respects the "unspoken" and "unseen" nuances of regional identities.

This talk explores the inner workings of an RDBMS through KeiPyDB, a custom RDBMS I implemented in Python.We will follow the processing flow of a SELECT statement step by step, covering lexical analysis, parsing, abstract syntax tree construction, query planning, and execution, using code examples and debugger output.
The talk also covers the storage layer. By inspecting actual data files with a hex viewer, we will observe how pages and records are stored on disk, and how INSERT and DELETE operations modify them.

The goal of this session is to provide a clear, concrete understanding of the main components that make up an RDBMS. It is intended for attendees who are familiar with SQL but have not yet examined how a database processes queries internally.

This hands-on workshop introduces participants to building a simple recommendation application based on the hybrid search technique, which combines semantic vector search and full-text search.

Using Django, the MongoDB family (including Full-Text and Vector Search, VoyageAI embeddings), and LangChain, we will create a web-based recommendation application that handles hybrid search, document chunking, embedding generation, and result reranking.

By the end of this two-hour session, we will have gained a strong fundamental understanding that can be applied to the recommendation system we built. A beginner's level of Python is recommended, but no prior knowledge of AI or search systems is required.

This proposal introduces an innovative approach to Python code quality enforcement by combining fixit (a linting framework based on libcst) with generative AI to create custom linters tailored to team-specific coding standards.

Traditional linters like ruff provide general-purpose rules but struggle to address organization-specific requirements and coding conventions. This creates challenges where code review becomes subjective and dependent on individual reviewers' knowledge. Our solution leverages AI to generate fixit rules from natural language descriptions, dramatically reducing the barrier to creating and maintaining custom linting rules.

The core innovation lies in using libcst's Concrete Syntax Tree (CST) representation, which preserves formatting, comments, and whitespace—unlike traditional Abstract Syntax Trees (AST). This enables safe, automated code transformations that maintain the original code's style while enforcing new standards. By combining AI-assisted rule generation with fixit's powerful transformation capabilities, teams can quickly implement and enforce new coding standards across entire codebases, eliminating review subjectivity and accelerating modernization efforts.

The convergence of Location Intelligence and Artificial Intelligence—known as GeoAI—is reshaping how we interpret the physical world. From using satellite imagery to predict crop yields to analyzing GPS traces for logistics, applying machine learning to spatial data is becoming essential for modern data scientists. This two-hour workshop offers a practical roadmap for building end-to-end Geospatial Machine Learning pipelines in Python.

In this talk, I will give an overview of two of the uses of Python for structural engineers. First, Python can be used to "control" commercial structural engineering software using the Application Programming Interface (API), and even add features and workflow improvements that these software do not provide out of the box. Second, several Python libraries such as pyniteFEA, openseespy, concreteproperties and steelpy can be used to analyze structures using the finite element method (FEM). The latter use has the advantages of being free to use compared to commercial software, and being able to elevate the creation of design templates that we traditionally do using spreadsheets.

Learn how Python leverages AVX-512, hyper-threading, and GPU for extreme performance. We'll dive into hardware internals, code patterns, and scaling strategies for HighLoad systems. We'll look at how we get compute modules from sand and how they execute your Python code.

Zstandard is now first class in Python via the new compression.zstd module, bringing fast, high ratio compression to everyday workflows. This talk introduces Zstandard for Python developers, explains how it differs from gzip, bzip2, and LZMA, and shows clear benchmarks of compression ratio and speed. You will learn one‑shot, streaming, and incremental APIs, plus dictionary training for many small similar payloads. We will cover real scenarios such as log pipelines, HTTP payloads, data lakes, and packaging, including how integration with zipfile and tarfile improves usability. What is new is the unified compression namespace in Python 3.14 with an official Zstandard wrapper that simplifies API discovery and cross‑version compatibility. Compared to traditional choices, you can achieve smaller downloads and dramatically faster extraction while keeping CPU and memory costs reasonable. Attendees leave with practical patterns, compatibility tips, and reproducible tests to pick the right algorithm for their workloads.

The global tech ecosystem continues to grow, yet challenges like limited mentorship, a lack of role models, and fragmented community support hinder progress, especially for underrepresented groups. PyLadies offers a powerful model for bridging these gaps. This talk explores how PyLadies chapters worldwide foster technical growth, increase mentorship opportunities, and drive collaboration to create a more inclusive and sustainable global tech community.
We can contribute to the growth of the global tech ecosystem by leveraging the PyLadies model of an inclusive and sustainable community.

Pydantic v2 is fast, elegant, and thoughtfully redesigned — but migrating a real production system isn’t always as simple as upgrading a dependency. In our project, the v1 → v2 journey started with excitement and quickly turned into detective work: broken validators, unexpected serialization differences, and a few “why is this failing?” moments.
In this talk, I’ll walk you through how we navigated the migration, what we refactored, what we kept, and which patterns saved us hours of debugging. If you’ve been postponing your migration or don’t know where to begin, this session will give you a clear, practical path forward.

Recent high-profile cloud outages - such as the Amazon Web Services (AWS) service failure in October 2025 that disrupted thousands of applications worldwide , have exposed how fragile modern infrastructure becomes when locked into a single provider. For many businesses, hours of downtime translate directly into lost revenue, broken customer trust, and cascading failures.

In this talk, I’ll present a configuration-driven, cloud-agnostic architecture built with Python, designed to keep systems resilient even when one cloud fails. Instead of relying on vendor-specific services, we’ll explore how to design modular abstractions that let applications switch seamlessly between cloud providers through configuration alone.

We’ll also dive into cross-cloud data synchronization - for example, keeping datasets in Amazon DynamoDB mirrored in their equivalents on another cloud to minimize data loss during failover.

A live demo will showcase a Python-based service dynamically switching its back-end and data storage between clouds, proving that true resilience doesn’t require duplicating your codebase.

What they'll learn from your talk

• Practical techniques for embedding C++ libraries into Python using tools like PyBind11
• How to handle performance, threading, and memory management in hybrid Python–C++ systems
• How to profile and optimize data-intensive Python modules that rely on native code

What background experience they should have to get the most out of your talk.

• Developers familiar with C++-based Python libraries (NumPy, Pandas, PyTorch)
• Engineers curious about pushing Python’s performance limits
• Anyone who’s ever wondered what happens when you try to fit a rocket engine inside a Python module 🚀

Let's implement objects that are useless for anything.
For example, an object whose length returned by the len() function is different every time, or an object that returns a bullshit result when you check if a value exists with the in operator.
And through the implementation, you will get a better understanding of Python data types.

Running AI inference locally, processing AI models on an organization’s own hardware, such as on-premises servers or devices, rather than relying on cloud-based services, has become an increasingly popular choice across various industries. The primary appeal lies in the enhanced control and security it offers over sensitive data. In this workshop session, we will build how to build a completely local Agentic RAG without any external APIs using an Open-Source LLM (Gemma or Mistral) and Qdrant Vector Search Engine, both running locally on Google Colab. We will also trace and monitor the application using Comet OPIK, which is completely open source.

Pandas is one of the most widely used tools in Python, yet many developers unintentionally write slow or memory heavy DataFrame code. This talk covers practical performance techniques that can significantly speed up Pandas workflows: vectorization, avoiding apply, optimizing data types, reducing memory usage, minimizing DataFrame copies, improving joins and groupbys, and using chunked loading for large files. We also look at when to extend Pandas with Polars, Apache Arrow, or DuckDB for faster execution. If you work with data at any scale, this session gives you simple, actionable tricks to make your Pandas pipelines faster and more production ready.

Backstage has quickly become a de facto framework for building internal developer portals (IDPs) for teams implementing platform engineering. Powered by a centralized software catalog and opinionated "Golden Path" software templates, it lets platform teams standardize how services are created, documented, and deployed.

The catch is that these templates are effectively part of your platform. If a Backstage template silently breaks, for example, by missing annotations, using outdated CI configuration, or including invalid infrastructure snippets, every new Python service created from it starts life already broken.

In this talk, we treat Golden Paths like production code and show how to test them using Python. We will walk through building a small Python test harness that generates projects from Backstage templates, validates their catalog metadata and annotations, verifies that the generated Python service installs, lints, and passes tests, and optionally inspects dry-run plans to ensure required infrastructure actions are present. Attendees will leave with concrete patterns and code they can drop into CI so that every change to their Golden Paths is automatically tested with Python before any developer ever clicks "Create Service."

This talk provides a complete blueprint for architecting a development and release workflow specifically for open source Python libraries published to PyPI. We move beyond basic test-build-deploy workflows to address more topics necessary for developing and maintaining trusted libraries: solid test-build strategies, changelog management, handling untrusted contributions, managing feature branch preview builds, automated semantic versioning, documentation generation, ensuring package quality, and securing the release process and final distribution.

All of us have wondered sometime, what really happens when a list is created, or compare dictionaries, or use objects as set keys in Python? This talk explores the inner workings of Python’s core data types — lists, tuples, dicts, sets, and more — from the perspective of internal implementation, memory, mutability, method resolution and more. We'll uncover how these types are implemented under the hood, and what it means to override or extend their behavior.

Along the way, we'll look at practical examples of customizing these behaviors using special methods. Let's make an immutable list or a mutable tuple, we’ll explore what’s possible, what’s dangerous, and what’s just plain fun.

Whether you're a Python enthusiast curious about how things work or a developer looking to write cleaner, more powerful abstractions, this talk will give you fresh insights into Python’s data model and how to harness it effectively.

Air is a Python web framework built from scratch for AI-assisted development. We'll show how designing for LLM legibility makes you a better coder whether or not you use AI. This includes explicit types, clear contracts, documentation that reads like a book. The goal is a framework that works astoundingly well with commercial or open source LLMs, or even the introspection features of your LLM. While Air is being architected by the speakers of this talk, a lot of the Air codebase is collaboratively being developed at sprints in the Python Asia community, starting in Davao, Baguio, and Manila but soon growing to Singapore and beyond.

Arcade is a game programming engine built on top of Python. Compared to pygame, Arcade uses OOP concepts to speed up development of games. It also comes with built-in collision detection and other functionality useful to making a game!

For years, Python developers have been taught that creating and managing virtual environments is fundamental to Python development. Commands like python -m venv .venv and source .venv/bin/activate have been ingrained in every tutorial and workflow. But what if I told you that in 2026, developers no longer need to manually create virtual environments?

This talk explores the paradigm shift happening in Python's ecosystem, where tools like uv, pipx, and inline script metadata (PEP 723) are liberating developers from manual virtual environment management. I'll show how we evolved from the pain points of manual venv management through solutions like Poetry and pip-tools, culminating in today's automated approaches with uvx and pipx run for commands, and inline script metadata for scripts.

Through code comparisons demonstrating the old way versus the new way, you'll see how Python development has become dramatically simpler. Whether you're running a linter like Ruff, executing a one-off script, or starting a new project, you'll learn practical techniques to let tools handle virtual environments for you. It's time to break free and embrace a more productive Python development experience.

Target Audience: Intermediate Python developers familiar with virtual environments who want to modernize their workflow.

This 30-minute talk is for intermediate Python users curious about scientific computing and bioinformatics beginners. It demystifies the fundamental algorithms for sequence alignment (Needleman-Wunsch and Smith-Waterman) by connecting them to core CS (dynamic programming) and familiar concepts (like diff tools).

The target audience of this talk is categorized into two (2): primary and secondary audiences.

a. Primary Audience: Intermediate Python users curious about applying coding to science, and bioinformatics beginners

b. Secondary Audience: Data scientists exploring new domains, and educators seeking practical, high-impact examples of complex algorithms.

In this talk, I will cover the following topics:

1. Introduction: The "Alignment" Problem (5 min)
   ->This section introduces the core concepts of sequence alignment (global vs. local) using a familiar analogy: file comparison tools.

2. The Logic: From Grid to Python Snippet (10 min)
   -> A practical walkthrough of the dynamic programming logic behind sequence alignment, translating the algorithm's "grid" into an intuitive Python snippet.

3. Python in the Wild: Biopython & Beyond (5 min)
   -> This segment bridges the gap from theory to practice, demonstrating how to use the foundational Biopython library to perform real-world alignments.

4. Impact, Takeaways & Q&A Handoff (5 min)
   -> This final part explores the broad impact of alignment in fields like genomics and NLP, summarizes key takeaways, and opens the floor for Q&A.

Most of today’s popular Python web frameworks like FastAPI, Starlette, and Django Channels are built on a powerful idea called the ASGI protocol. It’s what makes them fast, concurrent, and capable of handling everything from simple HTTP requests to real-time WebSockets.

In this talk, we’ll take a deep dive under the surface to see how ASGI really works, from event loops and async I/O to ASGI scopes, message passing, and lifespan events. We’ll also look at how ASGI connects web servers like Uvicorn with frameworks like FastAPI, forming the bridge that keeps the entire async ecosystem running smoothly.

By the end of the session, you’ll not only understand how ASGI powers modern web frameworks, but also gain the insight that will empower you to debug better, extend confidently, and even build your own.

Python offers a simple, readable syntax that helps young learners shift smoothly from block coding to text-based programming, supporting deeper problem-solving habits and clearer logical thinking.

Every year, PyCon organizers face not only logistical and operational challenges but also emotional and mental ones. Behind the success of each conference are countless hours of coordination, problem-solving, and reflection.
In this talk, I’ll share my journey as a senior organizer of PyCon Hong Kong — the mental resilience needed to handle pressure, the practical steps we take to improve year after year, and how we continue to find meaning in community work. From sponsorship strategy and volunteer coordination to maintaining team motivation and personal balance, this session offers both practical insights and honest reflections.
My goal is to inspire fellow organizers to pause, reflect, and keep improving — not just to build a better PyCon, but to build a healthier, happier community behind it.

The Creator Developer Economy is rapidly reshaping how developers turn technical skills into sustainable, independent income. In this session, we’ll explore practical ways developers can build, deploy, and monetize data-driven automation and web-scraping solutions—using both open-source tools and hosted platforms.

The age of quantum computing is upon us. But how can we prepare for this new type of programming in Python without a quantum computer hooked to our rigs or with free access? One good way is to prepare our code by running it on GPUs as quantum simulators. NVIDIA CUDA-Q enables the development of pure or hybrid quantum programs that run on both GPUs and quantum computers. In this workshop, we will cover an introduction to quantum programming and how to use NVIDIA CUDA-Q to run basic quantum programs, and we will see examples of how to apply them to applied cases such as quantum machine learning and optimization.

In an age where vulnerabilities are discovered daily and exploited faster than patches can be released, Python stands as the ultimate ally for defenders. This session takes you behind the scenes of building Toolshell, a next-generation SharePoint CVE scanner powered by Python that automates detection, analysis, and reporting of real-world vulnerabilities like CVE-2025-53770.

Attendees will learn how to:
1. Engineer an AI-assisted vulnerability scanner using modern Python libraries.
Build a config-driven detection engine with regex pattern matching, adaptive scoring, and SSL certificate analysis.
2. Transform raw scan results into beautiful HTML reports and structured datasets for security dashboards.
Apply defensive Python automation techniques to identify exposure safely before attackers do.

This talk blends cybersecurity and software craftsmanship, showing how Python empowers defenders to automate vulnerability discovery, accelerate incident response, and make threat detection transparent and reproducible. Whether you're a security analyst, developer, or DevSecOps enthusiast, you’ll walk away inspired to turn your scripts into battle-ready python security tool that protect real infrastructure.

For many Python beginners, learning databases feels like cracking open an ancient spellbook: mysterious runes (SQL syntax), lengthy incantations (boilerplate code), and a constant fear of summoning errors you don’t understand. But what if working with databases felt more like casting clean modern Python magic? This is precisely what SQLModel provides! It lets you define your database tables, validate your data, and power your APIs with a single Python class. No need to chant raw SQL spells or copy schemas in multiple places, one class/model will do all the magic.

In this beginner-friendly talk, we’ll banish the old scrolls of boilerplate and conjure a live demo: a spellbook API powered by SQLModel and FastAPI.

Python's elegant simplicity often hides a powerful system of internal conventions, many revolving around the humble underscore (). This talk, "Life Under the : A Guide to Python's Internal Conventions," demystifies the rules and mechanisms behind the scenes of Python's most powerful features. We will explore the single underscore (_) for stylistic clarity, the purpose of name mangling using double underscores (), and the practical application of "Dunder Methods" (e.g., __init, add) for customizing object behavior and implementing language protocols. Finally, we will dive into Python’s attribute access logic and the sophisticated mechanics of Data and Non-Data Descriptors, the building blocks for features like @property, classmethod, and staticmethod. Attendees will leave with a clearer understanding of how to read and write more idiomatic, maintainable, and powerful Python code.

Pyxel is a retro game engine developed by kitao-san, which is attractive because of its ability to create NES-like retro games in Python, its simple and intuitive API, and its expressive power limited to 16 colors and 4 sounds. On top of this strong Pyxel limitation, we created a presence-slide viewer that requires expressive power. We also incorporated an interesting mechanism using WebSocket communication. In this talk, I will show how we implemented the technology from loading Markdown to displaying slides, with a demonstration.

As a parent, you wanted to share your appreciation and love for the Python programming language with your children but does not know how to start or how to introduce Python to your kids. This session will feature some parenting tips on how to start ushering your kids early into their Python journey and give themselves a head start in learning one of the most versatile programming languages on the planet.

Notebooks are beloved for data exploration and education, but dreaded for production code. Poor reproducibility, hidden state, and out-of-order execution have kept them quarantined from "real" software engineering. Not to mention the thousand-line git merge conflicts.

Maybe it's time to rethink the notebook, and marimo does just that.

Haiku is a traditional Japanese poetic form typically known for its two-part structure (juxtaposition), use of seasonal words (kigo), brevity, simplicity, and objectivity. Modern haiku is being practiced in other languages as well, including English. The structure of modern English haiku is slightly different from the traditional Japanese form, but it still adheres to those principles.

This talk provides a brief introduction to haiku, its poetic ideals, and how it resonates with some of the ideas presented in the Zen of Python. It aims to share with the audience lessons from haiku (such as minimalism in writing code and objectivity in collaboration), which are helpful not just in Python programming and software engineering design but also in how we approach problems in general.

What if you could visualize music, detect beats, or classify songs — all in Python? In this talk, I’ll dive into audio signal processing and visualization using powerful libraries like librosa, numpy, and matplotlib. I’ll show how sound can be transformed into data, visualized as spectrograms, and analyzed to extract rhythm, pitch, and genre.
Attendees will learn the fundamentals of digital signal processing (DSP) for audio, how to work with waveforms and frequency data in Python, and how to use machine learning to recognize patterns in sound. By the end, you’ll know how to turn any sound file into a visually engaging dataset — and how to make Python “see” sound.
No prior DSP experience is required — just familiarity with Python and curiosity about the intersection of code, math, and music.

The Philippines continues to work toward the Sustainable Development Goals (SDGs), but its progress becomes clearer—and more actionable—when viewed alongside other countries facing similar social, economic, and environmental challenges. Many SDG issues in the Philippines mirror broader regional struggles, yet the lack of accessible, comparable data makes it difficult for citizens and decision-makers to understand where the country is ahead, where it is falling behind, and what lessons can be learned from peers.

This 2-hour, hands-on workshop uses Python to compare the Philippines’ SDG performance with that of other nations in Southeast Asia and beyond. Participants will use open global datasets to clean, explore, and visualize cross-country indicators—revealing patterns, inequalities, and standout practices. By grounding the analysis in international comparison, the workshop helps participants understand not only how the Philippines is doing, but why some countries progress faster and what strategies may be adapted.

This workshop is not about politics — it’s about essential skills for meaningful development analysis:
✔ Data literacy for interpreting global SDG indicators
✔ Critical thinking through country-to-country benchmarking
✔ Responsible analytics that avoid misleading comparisons
✔ Transparency through reproducible and open Python workflows

By the end of the session, participants will have built a concise, reusable “SDG Comparison Notebook” that compares Philippine performance to regional and global peers. The goal is to demonstrate how Python can illuminate where the Philippines stands in the world—and how data can guide smarter, more accountable pathways toward achieving the SDGs.

Every modern Python project depends on dozens (sometimes hundreds) of third-party packages. Each of them can - and regularly does - receive security advisories, patches, or CVEs. Even if you “just build business logic”, you inherit all the risks of your supply chain.
This talk is a practical introduction for early-career developers: why dependency security matters, how to audit your environment with pip-audit, what went wrong in several real CVEs found in 2025, and how to build a lightweight but reliable patching workflow without breaking your production environment.
Perfect for anyone who wants to level up their engineering maturity, avoid supply-chain surprises, understand what it really takes to keep dependencies updated sustainably.

Across the past decade, education research has shifted from teaching code through strict syntax to building broad problem-solving skills. Python fits this shift well because it is clear, flexible, and beginner friendly. This session highlights global trends in computational thinking and explains why Python works as a foundation for K to 12 learners. It helps students focus on logic, structure, and creative problem solving, which strengthens digital literacy and prepares them for a tech-driven future.