The Universal Operating System
Showing 5 of 42 projects. Click any project card for scope, mentors, and proposal studio.
Mentors: Student: Jugal59
This project implements a debuginfod-compatible server within Debusine to provide automated debug symbol resolution for Debian developers. Currently, debugging binaries built by Debusine requires manual installation of -dbgsym packages. This project aims to eliminate this manual labor by allowing tools like gdb to fetch symbols automatically via HTTP. Based on an analysis of the elf_classify logic in elfutils, I have designed and prototyped a pipeline that identifies and extracts .debug ELF files from -dbgsym.deb packages and parses their Build-IDs. The implementation integrates this extraction into the isolated sbuild worker task. These symbols are then indexed as debian:debug-symbol artifacts and served via a custom Django view that supports the buildid/<id>/debuginfo and executable endpoints, including HTTP Range requests for partial content. Key Deliverables: 1) An isolated extraction pipeline using pyelftools within the sbuild task. 2) A Django-based artifact storage and indexing model (debian:debug-symbol). 3) debuginfod-compliant HTTP endpoints (/debuginfo and /executable) with support for mandatory headers and 206 Partial Content. 4) Documentation and integration tests for gdb symbol resolution.
Mentors: Student: Anurag Nayak
Debianize is a tools that aims to automatically create debian packages from scratch from upstream source trees. As for the current version, it works for some of the packages but it is not reliable. This projects aims at making it production ready such that it can work with most of the projects. Along with that improving its reliability, coverage, integration with the broader ecosystem and other enhancements.
Mentors: Student: Aryan Karamtoth
Linux Kernel Livepatching is the process of replacing functions in the kernel code affected by CVEs with the patch-applied functions during system runtime. It's basically a method to apply security kernel patches to a running system such as a server without rebooting it. Such a feature is crucial for servers running crucial computational tasks 24/7 which cannot afford a reboot. Livepatch module is already provided by the Linux kernel but it's upto the distributions as to how they will be handled. As of 2026, only a few handful amount of distributions like SUSE, Ubuntu and RedHat offer Linux livepatches, which means no community maintained distribution at the moment offers Linux livepatches. There has been a way to utilise Linux livepatching in Debian in the past using kpatch but after the release of Debian 13 Trixie, the support for the kernel in kpatch has been dropped which halted the progress of supporting livepatching in Debian. klp-build is a promising approach to this problem but it only supports SUSE kernels which are only accessible by internal SUSE employees. Debian also lacks a release plan or mechanism to distribute livepatches for kernels. The goal of this proposal is to introduce Linux livepatching in Debian by studying how livepatches can be integrated into Debian and if existing technologies like clang-extract can be integrated into the workflow, forking klp-build to develop dlp-build which will serve as a tool to create livepatches for Debian kernels, as well as proposing a binary format for livepatches and designing a release cycle for the same.
Mentors: Student: Gajendra Nath Soren
This project aims to detect vulnerable code clones in the Debian archive by automatically extracting signatures from security patches. Using a two-signal approach that separates vulnerable patterns from fix patterns, the system generates high-specificity queries to search the entire archive via Debian CodeSearch. A verification pipeline with language-aware filtering ensures that detected clones are truly unpatched instances of the vulnerability. The project delivers a complete, scalable pipeline that integrates with Debian Security Tracker workflows and produces actionable reports, significantly reducing manual effort and improving vulnerability propagation detection across the ecosystem.
Mentors: Student: mo-ashraf
Debusine currently only shows task logs after a task has fully completed. This means developers working with long-running jobs (such as package builds or test pipelines) have no way to monitor progress in real time or catch failures early. This project adds live log streaming to Debusine. The implementation follows a four-stage pipeline. On the worker side, the sub-process runner will be extended to capture stdout and stderr incrementally as a task runs, sending each line to the server over the existing WebSocket connection rather than waiting for the task to finish. On the server side, a handler will receive these lines and write them to a per-task Redis Stream, providing a persistent, ordered, low-latency buffer that supports multiple simultaneous readers. A server-side view will then expose these log lines to browser clients via Server-Sent Events or a WebSocket endpoint. As a stretch goal, the Debusine web UI will subscribe to that endpoint and display lines appearing on the task page in real time, with no page refresh required. Deliverables: - Worker-side incremental log capture and WebSocket emission, with full test coverage - Server-side Redis Stream ingestion, per-task key namespacing, and post-task flush to PostgreSQL - A server view that streams log lines to browser clients for running tasks - A browser-side UI update that shows live output on the task detail page using plain JavaScript, without any frontend framework