UbuCon India 2026

→ Asia/Kolkata
Bengaluru

Bengaluru

B.M.S. College of Engineering Bull Temple Rd, Basavanagudi, Bengaluru, Karnataka 560004
Bhavanishankar Ravindra (Private Entrepreneur/Ubuntu developer), Soumyadeep Ghosh (Snapcrafters/Ubuntu/Ubuntu Membership Board/Ubuntu Flutter Community)
Description

The second edition of UbuCon India by the Ubuntu India LoCo dedicated to the Ubuntu ecosystem and the broader Free and Open Source Software (FOSS) community in India. Our mission is to provide a platform for developers, users, contributors, and enthusiasts to learn, share, and collaborate. The conference aims to foster community growth and showcase the latest advancements and applications of Ubuntu and related technologies.

  • Saturday 14 November
    • 09:00 → 09:30
      Registrations 30m
    • 09:30 → 10:40
      Inaugural ceremony 1h 10m Audi 1

      Audi 1

    • 10:40 → 11:05
      Demystifying Ubuntu SRU: A Journey from Bug to Stable 25m Audi 1

      Audi 1

      A new Ubuntu release is just the beginning. The Stable Release Update (SRU) process is how the community and Canonical ensure that essential bug fixes are delivered to users without introducing new regressions.

      This presentation will walk you through the entire SRU journey. We'll explore the key stages, from filing an SRU bug report to the crucial verification process of this vital process, which helps to keep Ubuntu stable for millions of users.

      Disclaimer: I am not part of Ubuntu SRU team, this presentation will be solely based on my personal experience with SRU bugs.

      Speaker: Sudip Mukherjee
    • 11:10 → 11:40
      Practical Infrastructure Observability Using Open Source Zabbix 30m Audi 1

      Audi 1

      Monitoring has evolved from basic host checks to full-stack observability across on-premises, cloud, containers, and networks. Zabbix is a mature, enterprise-grade, fully open-source monitoring platform that enables organisations to achieve deep visibility without vendor lock-in.

      This talk introduces Zabbix from a Free and Open-Source Software (FOSS) perspective, covering its architecture, scalability model, data collection methods, and real-world operational use cases. Attendees will gain clarity on when and why Zabbix fits, how it compares with other monitoring stacks, and how the community drives its evolution.

      Speaker: Mr Saquib Akhtar (Solution Designer @ NOKIA)
    • 11:10 → 12:40
      Silicon from Scratch: Designing Your First CMOS Inverter with Open-Source EDA 1h 30m Workshop Room

      Workshop Room

      The modern software stack rests on a foundation of silicon that most developers treat as an impenetrable black box or a rock with runes. It is time to peel back the layers.

      Historically (Even today to an extent), Very Large Scale Integration (VLSI) and silicon design were and are locked behind massive paywalls and proprietary toolchains. The open-source hardware movement has shattered the first barrier. In this hands-on workshop, we will take a nuanced first-principles approach to build the fundamental building block of all digital computation: the logical inverter (NOT gate)

      Proposed Outline:

      The Physics of a Flip: A brief primer on CMOS logic, NMOS/PMOS transistors, and how voltage translates to binary state.

      Schematic Capture & Simulation: Drafting the initial circuit and simulating transient analysis using ngspice.

      Silicon Layout: Getting our hands dirty in magic to draw the actual physical geometries of the P-diffusion, N-diffusion, and polysilicon gates.

      Verification: Running Design Rule Checks (DRC) and Layout Versus Schematic (LVS) using netgen to prove our drawn silicon perfectly matches our logical intent.

      Speaker: N Nishchit (BMS College of Enigneering)
    • 11:45 → 12:05
      The Swiss Army Knife of Linux Performance Engineering: A Practical Introduction to bpftrace 20m Audi 1

      Audi 1

      Talk Description

      A few months ago, I started learning Linux performance engineering. Like many people, I began with top, htop, and strace. They were useful, but I kept running into questions that those tools couldn't answer. I wanted to know what the kernel was doing while my program was running, not just what my program was doing.

      That's when I found bpftrace.

      This talk is a walkthrough of that learning journey. I'll show the approach that helped me understand scheduling, system calls, file I/O, and CPU activity by tracing a running system instead of guessing.

      We'll start with a small C program and use a few familiar tools before moving to bpftrace. Rather than looking at syntax for an hour, we'll use tracing to answer simple questions: Why is a process waiting? Which function is taking time? Is the slowdown caused by the application or by the kernel?

      The goal isn't to turn everyone into an eBPF expert. I want people to leave with a practical workflow they can use the next time something is slow. If you've ever opened top, seen 100% CPU, and wondered "okay... now what?", this session is for you.

      The session is beginner friendly. If you're comfortable using Linux and have written a bit of code, you'll be able to follow along without any previous experience with eBPF or kernel development.

      Speaker: Mr Shane Cardoz Maria (FreeBSD Project)
    • 12:10 → 12:30
      Dockerizing CLI Tools: Lessons From Bruno 20m Audi 1

      Audi 1

      Aim: Most CLI tools require users to install runtimes, dependencies, and manage version upgrades manually. In this talk, I'll explore how Docker images can simplify CLI distribution, improve reproducibility, and reduce dependency-related issues.

      The goal is to provide a different perspective on when and why maintainers should consider shipping their CLI tools as containers.

      Description:
      Drawing from my experience working on Bruno CLI, I'll discuss the operational challenges of traditional CLI distribution and how containerized delivery can simplify the user experience. Instead of requiring users to install Node.js and repeatedly update packages through npm, a Docker image can provide a consistent, isolated, and reproducible execution environment.

      The session will cover practical considerations for building and distributing Docker-based CLI tools, including image versioning, dependency isolation, security benefits, CI/CD integration, and developer experience tradeoffs.

      I'll also demonstrate how teams can use Docker images to reduce installation friction, improve reproducibility across environments, and simplify automation workflows.

      This talk is aimed at maintainers of developer tools, DevOps engineers, and open source contributors who are looking for more reliable ways to distribute and operate command-line applications.

      Conclusion
      Attendees will learn when containerized distribution makes sense for CLI tools, how to package and version their tools using Docker, and how containers can help reduce dependency conflicts, simplify upgrades, and improve security and reproducibility across environments.

      Speaker: Mr Ganesh Patil (usebruno)
    • 12:35 → 13:05
      Is My Ubuntu Box WebGPU-Ready? A Practical Setup Guide 30m Audi 1

      Audi 1

      Something quietly changed on Ubuntu desktops this year. WebGPU, the browser API that gives web pages direct access to the GPU, went from a flag-gated experiment to on-by-default for a growing slice of Linux users. Chromium 144 turned it on for Intel Gen12+ GPUs, Chromium 147 added NVIDIA on Wayland, and Firefox has Linux default-on as an open 2026 goal.

      Whether your machine actually gets it depends on five things that never gets checked: your GPU, your Vulkan driver, Wayland vs. X11, whether your browser is a snap or a .deb, and which build you're running. Get one of these wrong, and the page either says "WebGPU not supported" or silently falls back to a CPU renderer, and you never find out why everything is slow.

      This is a beginner-level talk: no shader code, no ML background required.

      We'll walk through what WebGPU actually is and how the Vulkan-driver-to-browser stack works. Then, the current state of Firefox and Chromium on Ubuntu, specifically, the Ubuntu-specific traps (starting with snap sandboxing breaking Vulkan access), and a live five-command checklist you can run on your own laptop during the talk.

      Audience will leave knowing exactly why WebGPU works, or doesn't, on your machine, and where it's headed.

      Speakers: Aishwarya Mathuria, Nishant Kumar Thakur
    • 12:45 → 13:45
      Getting Started with Penpot: Design Principles, AI Workflows and more 1h Workshop Room

      Workshop Room

      Getting Started with Penpot: Design Principles, AI Workflows and more

      How do we make information easier to find, understand and use?

      This workshop uses a scientific poster as a simple, familiar example to explore visual hierarchy, contrast, typography and grouping, and to see how each design choice affects who can read and use your work.

      Participants learn the basics of Penpot, design principles and finish with a short demo of MCP as an open tool for auditing a design.

      Everything used in this session, from the design tool to the contrast checker, is open source, in keeping with the spirit of UbuCon.

      Outline

      1. Introduction (5 mins)

      Self-introduction, quick background, current title, etc.
      A quick scan test: participants see a dense scientific poster for ten seconds, then a poster that leads with its finding, and compare what they remember.
      Introduce the Better Posters approach and why questioning established conventions matters: we design the poster, but rarely the poster session.

      2. Getting Started with Penpot (20-25 mins)

      • Participants fill out a short form with their name and email and are invited into the workspace where they will work
      • Brief intro of Penpot, its open source ethos and open standards.
      • A quick, guided tour: boards, text, shapes, colour and navigation Showing/asking to complete a small task on the starter file to get comfortable withcertain features.
      • A one-page reference sheet covers the basics, so this section can move quickly and participants have something to return to during later exercises.

      3. Design Principles and Penpot Hands-On (25-30 mins)

      • Quick Show & Tell covering four principles, each with an inclusion lens (who might this exclude?):
      • A contrast-checking plugin for Penpot is used to demonstrate accessibility in practice. A self-serve practice file lets participants continue at their own pace and revisit it after the session.

      3.1 A small roundtable discussion activity -> 10 mins
      Participants audit a real poster on their own: what do they notice first, what is hard to find, what is too dense?
      Discuss 2-3 constraints (one takeaway, a ten-second scan, or an older audience viewing from a distance) and what might be changed?

      3.2 Hands-on activity participants can join: AI in the design workflow -> 10 mins
      A short walkthrough of how an AI agent connected to Penpot through MCP can support the design process:
      A short live demo of MCP connecting Penpot to an AI agent to audit the original poster.
      A live demo / recorded walkthrough of some prompts better suited for developers’ workflows.

      4. Closing Thoughts (2 min)

      Scan a QR code to leave feedback on the workshop.

      (Attached the full proposal in detail as a document in the submission)

      Speaker: Ms Anjali Raj
    • 13:10 → 13:40
      Ubuntu on Qualcomm Dragonwing platform for AI 30m Audi 1

      Audi 1

      This session will give details on Qualcomm Dragonwing platform’s AI capabilities and AI stack. It introduces the development and deployment of local AI applications on Ubuntu using Qualcomm platforms, with a focus on the IQ9 and Ventuno Q. It outlines Qualcomm’s AI stack, highlighting how CPU, GPU, and NPU hardware combines with unified software frameworks, runtimes, and developer tools to support a “train on cloud, run on Qualcomm” approach to edge AI

      Live demonstrations on IQ9 to cover end-to-end journey from model to local AI solution, including generative AI, vision-language models, and voice-based applications. It concludes with Ubuntu AI workflow best practices and an interactive Q&A, connecting platform capabilities with practical application development.

      Speakers: Mr Ravi Kumar Neti (Qualcomm India Pvt Ltd), Mr Sumith Kumar Budha (Qualcomm India Pvt Ltd)
    • 13:45 → 14:45
      Lunch Break 1h
    • 14:46 → 15:06
      Learnings from a $1M FOSS discovery and funding experiment 20m Audi 1

      Audi 1

      In October 2024, we announced floss.fund as a big experiment to fund critical Free/Libre Open Source projects globally, which in turn was the culmination of a series of ad-hoc funding attempts over the years. It is the first of its kind in India, and one of the few in the world. Over the last year, some of the biggest FOSS projects globally applied to the fund - from devtools, programming languages, libraries, critical FOSS infrastructure, to humanitarian and social-impact projects, all via word of mouth and volunteer outreach.

      While the experiment itself has done well, there have been many disappointments and learnings owing to legal and compliance-related challenges. In this talk, we will share our experience from running the program, what other projects and funders should know, and our plans for the future (making FLOSS/fund a community driven effort, pushing for the creation of an Indian sovereign FOSS fund)

      We will also introduce funding.json (an open JSON manifest for describing FOSS funding requirements that we launched as an experiment with FLOSS/fund) and the Rupee Fund - a new experiment by the FOSS United Community to enable the Indian FOSS community to put money in the ecosystem.

      Speaker: Mr Ansh Arora
    • 14:46 → 15:46
      Ubuntu as a Purple Teaming platform 1h Workshop Room

      Workshop Room

      Purple teaming is a collaborative security practice where offensive and defensive teams work together to continuously validate, improve, and measure an organization's ability to detect, respond to, and recover from attacks. Ubuntu provides a powerful and accessible platform for purple teaming by combining mature security capabilities such as containers, AppArmor, auditd, eBPF, systemd, and a rich ecosystem of open-source security tools. By enabling continuous validation of detection and response capabilities, purple teaming helps organizations move beyond periodic penetration testing towards building resilient and measurable security operations.

      This talk introduces the core concepts of purple teaming and demonstrates how an entire purple team exercise can be conducted using only Ubuntu and open-source tooling. Through live demonstrations, attendees will see common attacker techniques, the corresponding telemetry generated by the operating system, and how detection rules can be developed and refined in real time. The session will also map these activities to the MITRE ATT&CK framework, showing how organizations can systematically assess and improve their defensive posture. Whether you are new to security or an experienced practitioner, you will leave with practical knowledge and a reproducible Ubuntu-based environment for learning, experimentation, and continuous security validation.

      Speaker: Balachandran Sivakumar
    • 15:11 → 15:41
      Intent In, AppArmor Out 30m Audi 1

      Audi 1

      Generally in the organizations, you will see mandatory access control not been implemented quite extensively. Now, the reason is because in most of the organizations you will see there are limited number of security engineers that are available.

      Many organizations have limited security staffing, so a small team ends up covering Linux hardening, cloud security, vulnerability management, patching, SIEM, container security, and Kubernetes security all at once. In that reality, implementing LSM's like AppArmor in strict enforcement mode can be time intensive, and writing accurate rules requires deep knowledge of application behavior. When policies are incomplete or incorrect, production workloads can break, which is why mandatory access controls are often delayed or underused.
      KubeArmor solves this problem by letting you write your intent in simple YAML, and automatically generating the correct AppArmor profile for you.

      As a result, you can enforce strong security controls on your workloads without needing to handcraft complex profiles or risk breaking production applications. The same intent-based policy can also be compiled to other Linux security modules like BPF-LSM or SELinux, making it portable across different environments.

      Speaker: Cheithanya PR
      cheithanya-ubucon-2026
    • 15:46 → 16:01
      Coffee break 15m
    • 16:01 → 16:31
      AppArmor from First Principles: From Access Control to Application Confinement 30m Audi 1

      Audi 1

      Linux users are familiar with users, groups, ownership, and file permissions. But an application normally runs with the permissions of the user - or service account - that started it, and unless it is otherwise confined, it can often access whatever those credentials allow. So how do we restrict what one particular application is allowed to do, even when its Unix credentials would permit more?

      This talk builds AppArmor from that starting point. It begins with Discretionary Access Control (DAC) and the traditional Linux permission model, looking at how access decisions are primarily based on the credentials under which a process runs. From there, it introduces Mandatory Access Control (MAC) as an additional layer of policy that can restrict an application independently of ordinary ownership and permissions. It then takes a brief look at the Linux Security Module (LSM) framework that allows security modules to participate in kernel access-control decisions, before arriving at AppArmor, the security module Ubuntu uses by default for application confinement, and its path-based profiles.

      From there, the talk moves from concepts to practice. It reads a simple AppArmor profile, shows how rules govern the files an application may access and the programs it may execute, explores the difference between complain and enforce modes, and looks at how AppArmor reports denied operations. A short live demo ties these pieces together: a profile is applied to an application, a policy violation is deliberately triggered, the resulting denial is inspected, and the profile is refined in response.

      The goal is not to cover every AppArmor rule or feature, but to leave attendees with a clear mental model of where AppArmor fits into Linux security and enough practical understanding to begin reading, troubleshooting, and experimenting with profiles on their own.

      Learning outcomes:

      • Explain how DAC, MAC, and the LSM framework relate to AppArmor
      • Read and make sense of a simple AppArmor profile
      • Recognise an AppArmor denial and understand what it is telling you
      • Know how to begin investigating and refining a profile
      Speaker: Mr Safeer C M
    • 16:01 → 17:01
      Hardware-Aware Runtime Security for Ubuntu Systems 1h Workshop Room

      Workshop Room

      Ransomware can encrypt large volumes of data within seconds, often before conventional signature-based or software-level security tools can respond. This talk presents a hardware-aware approach for detecting ransomware and malware at an early stage on Ubuntu-based systems using processor-level behavioural information.

      The proposed framework uses Linux perf to collect hardware performance counter data such as cache misses, branch mispredictions, instruction activity, translation lookaside buffer events, context switches, and CPU utilisation. These low-level events capture changes in processor behaviour that arise when malicious software begins performing intensive encryption, memory access, and file-processing operations. The collected data is analysed using machine-learning models, including Random Forest, XGBoost, one-class SVM, and deep-learning-based classifiers, to distinguish malicious activity from normal workloads.

      Our experiments indicate that hardware-level behavioural patterns can provide an effective early-warning signal for ransomware detection, with selected models achieving detection accuracy of approximately 98%. The talk will also discuss practical challenges such as performance-counter multiplexing, sampling frequency, event selection, runtime overhead, and deployment inside virtualised Ubuntu environments.

      Attendees will learn how open-source Linux tools can be used to build a reproducible hardware-assisted security pipeline without requiring specialised security hardware. The broader goal is to demonstrate how Ubuntu, Linux performance monitoring, and machine learning can be combined to develop lightweight runtime protection mechanisms capable of detecting malware before substantial file encryption or system damage occurs.

      Speaker: Sheel Sindhu Manohar (Shiv Nadar Institution of Eminence)
    • 16:36 → 16:56
      Building Secure GitHub CI/CD Pipelines: From Commit to Production 20m Audi 1

      Audi 1

      Secure Github Pipeline, Sonarqube Checks, Protected Branches, Maintainers and security checks before code merge, Trivy Integration, Docker hardening, Docker Image scanning

      Speaker: Aniket Shitole
    • 17:01 → 17:31
      Lets mix Nix & Ubuntu using home-manager 30m Audi 1

      Audi 1

      I've been using Linux since 14 years, and as expected have distro-hopped a lot. Along with distro-hopping an unintended side-effect is you "package-manager hop" as well. I've used apt, pacman, dnf, homebrew for linux and what not. But once I discovered Nix, it felt like I solved a problem I didn’t even know I had.

      One of the easiest ways to dip your toes into nix was to use home-manager, which allows you to use nix style package management for the current user but does not need to be installed system-wide. Essentially, you can use home-manager along with your system's main package manager.

      This talk will focus on understanding the philosophy of Nix, the benefits of declarative package management, how to get started and its inner workings.

      Speaker: Yash Mehrotra
    • 17:31 → 17:36
      3D Printing Hacked 5m Audi 1

      Audi 1

      I love to 3D print, and make things. For the first few weeks, I loved it. But as time went on, I wanted to print multiple colors at the same time. When I looked online, I was given 2 options: 1 buy a $200 attachment, or use this opensource slicer (OrcaSlicer) without any asterisks. I have been using it, and I am loving it. It costed me zero money. All I had to do was create this mounting mechanism for my spools. Once that happened, I have been able to print in multiple colors for free. This is all possible because of a few things.

      1. The opensource nature of 3D printing. Everyone can see what others are printing.
      2. Prusa. Though prusa is not as popular today as it once was, they are the ones who pioneered 3D printing at a consumer level. They opensourced all their software, and that's what we use to this day.
      3. The slicer I am talking about was made opensource and built on top of existing slicers. Orca is built on top of prusa slicer.
      Speaker: Srirudran Yagnanarayanan (Student)
    • 17:36 → 17:41
      Closing remarks 5m Audi 1

      Audi 1

  • Sunday 15 November
    • 09:00 → 09:20
      Registration, Day 2 Check In 20m
    • 09:20 → 09:50
      Ubuntu Touch: freedom of choices in mobile OS space 30m Audi 1

      Audi 1

      Currently, the mobile operating system is occupied by Apple-Google duopoly, with their iOS and Android (respectively) occupying over 99% of the worldwide mobile OS market share [^1]. However, it doesn’t have to be that way.

      This talk will talk about Ubuntu Touch (https://ubuntu-touch.io), an alternative operating system for smartphones. It’s not yet another Android fork; rather, Ubuntu Touch is based on Ubuntu Linux and strives to give a truly different choice to freedom- and privacy-conscious users.

      This talk will give you the overview of what Ubuntu Touch is, the history of it, and how it’s built, as well as the landscape of Linux-based mobile operating systems in general.

      [^1]: as of July 2026. Information comes from Statcounter GlobalStats. https://gs.statcounter.com/os-market-share/mobile/worldwide

      Speaker: Ratchanan Srirattanamet (UBports)
    • 09:50 → 11:20
      Hands-On PyLabFlow: Building ML & Deep Learning Pipelines from Scratch 1h 30m Workshop Room

      Workshop Room

      Managing computational experiments during exploratory R&D is one of the trickiest parts of data science and machine learning. Notebooks get cluttered, parameter variations are hard to track, and reproducing past runs often requires digging through old files.

      In this 1-hour hands-on workshop, participants will build real machine learning and deep learning experiment pipelines from scratch using PyLabFlow—an open-source, local-first Python framework for experiment management and reproducibility.

      Through guided Jupyter Notebook exercises, attendees will:
      1. Set up a structured research workspace using PyLabFlow.
      2. Build modular Python components for data processing, scikit-learn ML models, and PyTorch deep learning architectures.
      3. Configure and run experiment pipelines (PipeLine) with automatic tracking and duplicate-run protection.
      4. Save and organize output artifacts, model checkpoints, and logs cleanly under experiment namespaces.
      5. Query and compare past experiment runs into Pandas DataFrames to analyze model performance across sessions.

      By the end of the workshop, every attendee will have built two functional hands-on projects (a scikit-learn regression pipeline and a PyTorch neural network workflow) and will leave with a reusable blueprint for organizing their own projects 100% offline.

      Speaker: Mr Bibekananda Hati (ExperQuick Research Infra Pvt. Ltd.)
    • 09:50 → 10:20
      eBPF Beyond Linux: Building a Runtime-Programmable Kernel for Robots 30m Audi 1

      Audi 1

      What does it take to change a robot’s low-level behaviour without reflashing its firmware, and what should the system do when an update is invalid?

      In this talk, I will explore that question through AxiomOS, an experimental bare-metal Rust kernel that loads verified eBPF programs at runtime. Drawing on development work on the Raspberry Pi 5, I will explain how a kernel can expose programmable behaviour without giving every loaded program unrestricted access to hardware.

      We will begin with the building blocks: bytecode, a verifier, maps, helper functions and event hooks. From there, we will follow a small program through loading, verification and execution, examining how memory access and helper calls are checked. The central question is what those checks actually establish, and what remains outside their scope.

      The second half will examine the problems that appear when runtime-loaded code interacts with physical hardware: limiting execution time, deciding when an update becomes active, restricting actuator commands, and keeping emergency-stop enforcement outside replaceable behaviour code. I will discuss the trade-offs behind interpreted execution and the failure cases worth testing, including invalid programs, interrupted updates and changes attempted while an emergency stop is latched.

      A worked example will illustrate an accepted program and a rejected one. Throughout the session, I will distinguish implemented mechanisms from experimental work, and software checks from properties that need testing on real hardware.

      Attendees will leave with a practical model for designing runtime extension points in embedded systems, understanding the limits of verification, and testing the update path—not just the program that runs afterwards.

      Speaker: Mr Utkarsh Maurya (volnlabs)
    • 10:20 → 10:50
      Accessible-Coconut: A Decade of Building an Accessible Ubuntu-Based Operating System for Visually Impaired Users 30m Audi 1

      Audi 1

      Accessible-Coconut is a free and open-source GNU/Linux operating system developed to provide an accessible computing environment for visually impaired users. Developed and maintained since 2011, the project has evolved alongside Ubuntu for more than a decade, combining the accessibility features of mainstream Linux with software and customizations specifically designed to meet the needs of blind and visually impaired users.

      Accessible-Coconut brings together a range of accessibility and educational applications, including LIOS, Sharada-Braille-Writer (SBW), IBus-Braille, Maths-Tutor, Accessible TuxType, Accessible TuxMath, and XBoard. These applications support Braille input and writing, text entry, mathematics, typing education, chess, and other everyday computing and learning activities for visually impaired users.

      The project follows the principle that visually impaired users should not need a separate computing ecosystem. Instead, accessibility should be integrated into mainstream free and open-source technologies, enabling blind and sighted users to use the same computers, operating systems, and applications. Accessible-Coconut therefore combines existing Linux accessibility technologies with purpose-built open-source applications and accessibility improvements developed through collaboration with visually impaired users and the wider FOSS community.

      Over more than a decade, Accessible-Coconut has continued to evolve with successive Ubuntu releases while maintaining its focus on accessibility, local-language computing, education, and digital independence for visually impaired users. This presentation will explore the history and evolution of Accessible-Coconut since 2011, its integration with Ubuntu, the applications included in the distribution, and the project's approach to developing sustainable, community-driven, free and open-source accessibility solutions.

      In 2025, Accessible-Coconut recorded 4,657 downloads across 106 countries. The largest numbers of downloads came from the United States (828), India (748), Germany (320), Brazil (269), the United Kingdom (175), Poland (168), and Turkey (141). Downloads were recorded across countries in Asia, Africa, Europe, North America, South America, and Oceania, demonstrating the international reach of a free and open-source accessible operating system for visually impaired users.

      Website: www.zendalona.com
      Presentation: https://www.canva.com/design/DAG11N3K0Ms/Xalu0yEOgeVTrLwiVO1Pqw/edit
      Accessible-Coconut home page: https://zendalona.com/accessible-coconut/
      Download Statistics: https://sourceforge.net/projects/accessible-coconut/files/stats/map?dates=2025-01-01%20to%202025-12-31

      Speakers: Nalin Sathyan (Zendalona), Mr Sathyaseelan K (Zendalona)
    • 10:50 → 11:20
      The Power of ROS: Connecting Robotics, AI, and the Ubuntu Ecosystem 30m Audi 1

      Audi 1

      Robotics and automation are at the heart of modern innovation, and the Robot Operating System (ROS) serves as the universal language connecting diverse robotic platforms. This talk explores how ROS and the Ubuntu ecosystem (Ubuntu Core, MicroK8s) provide a robust foundation for tackling challenges in robotics, AI, and IoT development. Through examples and real-world use cases, attendees will learn the key components of ROS, how it integrates with AI, and why Ubuntu is the ideal choice for scalable, secure robotic solutions.

      Speaker: Shridhara Bhat (F5 Networks - SDE 1)
    • 11:20 → 12:50
      Build a Zero-Cost AI Agent in Your Browser 1h 30m Workshop Room

      Workshop Room

      You can build, customize, and ship a working AI agent with no API key, no server, and not a rupee spent. In this 90-minute hands-on workshop, you'll do exactly that.

      We'll use WebLLM (an open-source browser runtime from MLC-AI), Google's open-weight Gemma 2 2B model (quantized to 4-bit, roughly 1.5 GB), and WebGPU, the browser's native GPU compute API, to run real LLM inference entirely inside a browser tab. The whole stack is open source, and the only tools you need are an Ubuntu laptop and a WebGPU-capable browser.

      The workshop moves through four phases.

      Phase 1 covers the AI loop: load a quantized language model from a CDN import, make your first chat completion, add streaming, and wire up multi-turn conversation memory, all in a single HTML file with zero build tooling.

      In Phase 2, you make it real. Turn the raw text loop into a styled chat application with message bubbles, auto-scroll, a loading progress bar, and input state management.

      Phase 3 is where you make it yours. Customize your agent's persona and system prompt (fitness coach, travel guide, language tutor, your pick), then build a research agent that calls real tools (Wikipedia, weather APIs) through an agentic loop. The model decides when it needs more information, calls a tool, reasons over the result, and loops until it has a grounded answer.

      Phase 4 ships it: deploy your agent to GitHub Pages in three steps. You leave with a live URL.

      Every attendee walks out with a working, deployed, zero-cost AI agent, plus the mental model to extend it with new tools, bigger models, and richer UIs.

      Prerequisites: a laptop with GPU enabled, checked via chrome://gpu), a text editor, and basic familiarity with HTML and JavaScript. No ML or AI experience required . Please check the pre-workshop in presentation material

      Speakers: Aishwarya Mathuria, Nishant Kumar Thakur
    • 11:20 → 11:40
      Ubuntu on Qualcomm Dragon wing platform for Multimedia applications and Interfaces 20m Audi 1

      Audi 1

      In this session, we introduce the multimedia capabilities of Qualcomm Dragon wing platform on following developer boards, both supporting Ubuntu 24.04:

      IQ9 SBC: Introduction to IQ9/IQ8 -performance capabilities for multimedia applications, industrial control, and advanced edge analytics.

      Arduino Ventuno-Q : Introduction to Arduino VentUNO-Q , Qualcomm’s developer board for Vision, AI

      Speakers: Mr Arunn D, Mr Balakrishnamachary Devarapalli
    • 11:40 → 12:10
      Debian packaging of Zig applications 30m Audi 1

      Audi 1

      The Zig programming language is almost a decade old. Over the past couple of years, the Zig toolchain has seen a steady rise in its popularity. Latest Zig compiler releases are now available on Ubuntu, as deb packages. Ghostty, one of the successful applications of Zig is also packaged for Ubuntu. In this talk, I propose to share my experience of creating Debian packages for Zig and its applications. I wish to share the challenges posed by cross-compilation, static linking and Zig's dependency management, and the how these were solved or circumvented. I hope to impress upon the audience, the need to bring in a clear packaging policy, whenever we foray into a new language ecosystem.

      Speaker: Pushkar Kulkarni (Canonical)
    • 12:10 → 12:30
      Beyond Tool Sprawl: Practical Discovery and Governance for MCP Agents 20m Audi 1

      Audi 1

      As agents gain access to more tools, indiscriminate tool exposure creates noise, latency, security risk, and fragile workflows. This talk introduces practical patterns for discovering and governing MCP tools on demand, using NCP as an open-source reference implementation.

      We will explore capability metadata, context-aware discovery, permission boundaries, lifecycle management, and observable agent workflows. The examples show how developers can keep agents focused on the right tools while preserving interoperability across MCP-compatible systems.

      The emphasis is on deployable ideas for Ubuntu and open-source environments, not a vendor-specific product pitch.

      Speaker: Arul Kumaran Ragunathan (Luracast)
    • 12:30 → 12:50
      Beyond the Breadboard: Scaling Raspberry Pi Projects to the Edge with Ubuntu Core 20m Audi 1

      Audi 1

      This talk walks through the journey of taking a Raspberry Pi from a simple GPIO experiment to a production-grade edge computing node running Ubuntu Core. We start with the fundamentals: flashing Ubuntu Core, understanding its transactional, snap-based architecture, and wiring up basic GPIO interactions for sensors and actuators. From there, we move into the practical challenges of edge deployments: secure boot, over-the-air updates, remote device management, and running containerized workloads reliably in the field. Attendees will leave with a clear picture of how Ubuntu Core's design choices, like immutability and confinement, make it a strong fit for edge use cases, along with practical tips for anyone starting their own GPIO-to-edge project.

      Speaker: Salman Faris (Screenly)
    • 12:50 → 13:50
      Lunch Break 1h
    • 13:50 → 14:10
      A Grant, Not a Credential: Limiting What AI Agents Can Do 20m Audi 1

      Audi 1

      AI agents are usually authorized as if they were ordinary applications. This leaves an important gap. Existing systems can identify an application and grant access to an account, but they do not adequately describe what one agent instance may do for one task. They also provide limited ways to control how authority is passed to other agents.

      This talk examines that missing authorization layer through GNAP, an IETF standard for delegated authorization. GNAP supports structured access requests, client instance keys, proof of possession, continuation and revocation. These mechanisms are already implemented in open source payment infrastructure through Rafiki and Open Payments. The talk considers how GNAP could support AI agents without replacing existing APIs or credentials. An agent receives limited authority to call a mediation service. That service retains the underlying credential and checks each requested operation before it reaches the downstream system. The talk separates what GNAP already provides from what still needs to be designed for agents. This includes task specific permissions, delegation between parent and child agents, and shared limits across multiple agents.

      Speaker: Mr Daev Mithran
    • 13:50 → 14:50
      Lean, Clean, and Secure: A Hands-on Intro to Chisel 1h Workshop Room

      Workshop Room

      What if you could pick apart a deb (a software package format used primarily by Debian and its derivatives such as Ubuntu) while retaining its functionality? Push the limits of how lean, and by extension, secure, it can be?
      Now, you don't need to be a security engineer or operating system expert to do this. With chisel, a command-line tool pioneered by Ubuntu and Canonical, we'll see just how developer-friendly it can be.

      Join me for a 30-min, hands-on workshop where I introduce chisel, use it to "slice" the debs that valkey is based on, and finally apply this work to build a very lean OCI image for the popular key-value db. You'll see how, with just over 15 minutes of work, we can build an image that's several MBs lighter than the existing image on DockerHub. But more important: mitigates nearly all 9 critical CVEs* found in the same!

      This workshop will cover:

      • chisel, the concept of "slices" and CVE reduction
      • how to approach the task of slicing a deb, and a note on design decisions
      • how to use chisel to actually cut a slice
      • how to test and validate your slice(s)
      • an agent skill to boost your slicing capabilities
      • how to use your slices to build lean OCI images for your apps, as an alternative to regular Docker images
      Speaker: Ms Soundarya Rangarajan
    • 14:10 → 14:40
      LLM on a $10 microcontroller: natural-language hardware control with no cloud 30m Audi 1

      Audi 1

      Most "on-device AI" is a thin client talking to someone else's GPU. This talk is the other end of the spectrum: a transformer trained from scratch, small enough to run on a $10 microcontroller, that turns English into GPIO commands with no network of any kind. No WiFi, no cloud, no API key — there is no network stack in the firmware at all.

      You type "blink pin 4 every 5 seconds 3 times" at a serial prompt and an LED blinks. The model is 312,128 parameters of fp32 weights memory-mapped out of flash, running on an ESP32-S3 next to the code that drives the pins. There is no operating system on the device: the model, the tokenizer and the GPIO driver are one firmware image. Training takes about five minutes per run on a laptop, and the whole toolchain is Linux-native.

      The interesting part is not that it fits. It is what went wrong.

      I gave the model a grammar in which an invalid request was impossible to express
      — every legal pin had its own token, so it physically could not say "pin 100."
      That reads like a safety guarantee. It is the reverse. A model that cannot say "pin 100" does not refuse; it says the nearest thing it can. On held-out data,
      "switch off pin 100" came back as pin 10: a real pin, a valid command, actuated silently, with nothing in the logs.

      That failure mode is not specific to microcontrollers. Constrained decoding, GBNF grammars, JSON-schema enforcement and function-calling APIs all work by restricting what a model may emit and then sampling the most likely permitted token. If your schema cannot express "the input was out of range," the model returns something in range and you never see the difference.

      The fix inverts the responsibility: numbers are transcribed digit by digit so the model can say something invalid, and the hardware layer refuses it by name.

      Speaker: Mr Manjunath Janardhan
    • 14:40 → 15:00
      Upstream First: Building and Contributing to Linux on Qualcomm® IoT Platforms with Ubuntu LTS 20m Audi 1

      Audi 1

      As Qualcomm continues its upstream-first Linux strategy, developers have more opportunities than ever to engage with the open-source ecosystem. This session explores how Ubuntu LTS, officially maintained by Canonical on Qualcomm IoT platforms, provides a stable and production-ready environment for edge AI, robotics, and IoT development.

      The talk will cover Linux upstreaming, contribution workflows, developer resources, and practical ways to get involved in Linux kernel, Ubuntu, and open-source communities. Attendees will also learn how Qualcomm-based platforms benefit from full ROS/ROS 2 compatibility, enabling seamless development for robotics and intelligent edge applications.

      Speaker: Ms Kartikey Rawat (Qualcomm)
    • 14:50 → 15:50
      Scaling Local AI: Benchmarking vLLM and Building Personal Agents 1h Workshop Room

      Workshop Room

      As AI moves from massive data centers to local and edge environments, developers need practical, open-source ways to deploy efficient, high-throughput models. This workshop provides a hands-on guide to building personal AI agents tailored for workplace automation, served via vLLM on Ubuntu and powered by modern unified memory architectures.

      Before writing any agentic code, we will break down the mechanics of unified memory by explaining how CPU and GPU memory pooling drastically reduces data transfer bottlenecks and accelerates inference on accessible hardware like the NVIDIA DGX Spark.

      From there, we will transition into a live, practical workshop focused on scale and efficiency. We will deploy vLLM, exploring how its implementation of PagedAttention and continuous batching solves memory fragmentation and allows for high-throughput serving at scale. To validate this, we will perform live benchmarking on the deployment to measure real-world token generation speed, latency, and memory utilization.

      Finally, we will consume this optimized local inference server to build and wire up personal AI agents capable of automating routine development and operational tasks. Attendees will experience the excitement of actively querying their own agents against the DGX Spark, seeing firsthand how serving requests at the local level transforms and accelerates daily workflows. You will leave with a clear understanding of how to benchmark and serve LLMs efficiently, along with the code necessary to spin up your own local AI agents.

      Speaker: Sayed Imran (66degrees)
    • 15:00 → 15:20
      AppArmor for Backend Developers: Confining a Java Service Without Breaking It 20m Audi 1

      Audi 1

      Running a Java service as a non-root user is a useful security measure, but the service may still have access to files it does not need. How can developers restrict that access while keeping the application functional?
      This practical session will demonstrate how to confine a Java service on Ubuntu using AppArmor. Using a small HTTP service in an isolated Ubuntu environment, we will identify its required resources, create an application-specific profile, and explore the difference between learning and enforcement modes.
      The demonstration will cover both expected and prohibited behaviour: normal API requests, configuration reads and report generation should succeed, while attempts to read unrelated dummy sensitive files or write outside approved directories should fail. We will also deliberately introduce a rule that breaks legitimate functionality, inspect the resulting denial, and adjust the profile without granting unnecessarily broad permissions.
      Finally, we will turn these scenarios into repeatable tests and discuss maintaining the profile as the application and Java runtime change.

      Speaker: SIDDESH A S A S
    • 15:20 → 15:40
      Securing the Software Supply Chain with in-toto: From Build to Verifiable Provenance 20m Audi 1

      Audi 1

      Securing the Software Supply Chain with in-toto: From Build to Verifiable Provenance

      Modern software is built through a chain of steps involving developers, CI systems, build infrastructure, package repositories, and release systems. But how can we verify that an artifact was actually produced through the expected process and has not been tampered with along the way?

      In this talk, we'll explore in-toto, an open-source framework for securing software supply chains through verifiable metadata and provenance.

      We'll start with a simple software supply chain and introduce the core concepts behind in-toto, including layouts, functionaries, materials, products, link metadata, signing, and verification. We'll then walk through a practical example of securing a small software build pipeline with in-toto.

      The talk will include a live demo showing both a successful verification and what happens when an artifact or a step in the supply chain is tampered with.

      Finally, we'll look at how in-toto fits into the broader software supply-chain security ecosystem, including SLSA, provenance, and related technologies.

      The goal is to give attendees a practical understanding of how in-toto works and why verifiable supply-chain metadata matters when building and distributing open-source software.

      Speaker: Mr Lakshya Gupta
    • 15:40 → 15:45
      The printer worked. That was the problem. 5m Audi 1

      Audi 1

      I set up the same homelab printer twice: once vibing with an AI, once actually understanding it.

      The first time I shared a USB printer over my LAN, I ran a string of commands I half understood, and it printed. I couldn't have told you how. A week later that box filled its disk with logs and crashed, a safety setting I'd left running while it logged a bug I hadn't fixed.

      Later I rebuilt the server and set the same printer up again, this time doing the reading: CUPS, lpadmin, PPD matching, device URIs, Avahi. It went cleanly.

      This talk puts the two passes side by side. Sharing one non-network printer turned out to be three bugs stacked on each other, each hiding the next: AppArmor quietly starving CUPS, a kernel driver and a userspace library fighting over the same USB interface, and a "clean" backend I'd written off as broken that was never broken at all, just blocked by the state I'd tangled the system into myself.

      You'll leave knowing how CUPS, AppArmor, usblp and Avahi fit together, and why a working setup you can't explain is a liability, not a win.

      Speaker: Aswin Pradeep C
    • 15:45 → 15:50
      Hardware Design Using Open Source Tools : POV Display 5m Audi 1

      Audi 1

      Hardware Design using Open Source Tools : POV Display

      Demo : https://www.youtube.com/shorts/mBMTX7Lzo30
      Source Code : https://github.com/obtronyt/pov

      This project explores how open source tools and technologies on Ubuntu can be used to take an embedded hardware idea from concept to a working device.

      The project is a custom Persistence-of-Vision (POV) display built around a PCB containing just 12 LEDs and an ESP8266 microcontroller. The PCB is mounted on a custom PLA 3D-printed mechanical assembly and rotated at high speed by a motor. By precisely controlling the LEDs based on the angular position of the rotating PCB, a single column of LEDs is transformed into a two-dimensional circular display capable of rendering text, scrolling marquees, animations and graphics.

      The project uses an open-source development workflow spanning hardware design, firmware and mechanical fabrication:

      • KiCad for schematic capture and custom PCB design
      • Cura Slicer for 3D Print Slicing
      • Arduino IDE for ESP8266 firmware development
      • ESP8266 Arduino Core and open source libraries
      • Custom bare-metal firmware for precise LED timing
      • Custom motor-driven mechanical design
      • Angular synchronization and timing
      • Conversion of text and graphics into POV display data
      • Animation techniques including marquee, sliding and procedural animations

      The talk will walk through the development process, from designing the PCB and mechanical assembly to writing the firmware that synchronizes LED patterns with the rotation of the device.

      More importantly, the project demonstrates an interesting embedded systems principle: additional computation, precise timing and mechanical motion can make simple hardware appear far more capable than its physical resources suggest.

      With only 12 physical LEDs, the finished device produces the illusion of a much larger circular display, demonstrating how open source software, electronics, embedded firmware and mechanical design can be combined to build a complete hardware project from scratch.

      Speaker: Kiran RS
    • 15:50 → 15:55
      Closing remarks 5m Audi 1

      Audi 1