Explore Projects

<p>This project aims to add podcast support to Alligator. Alligator is a RSS feed reader and that makes it an ideal software for adding podcast support since both use a similar protocol. The integration will also allow users to search for new podcasts and a playlist support to queue them. The project also aims to provide integration with the Linux ecosystem using MPRIS and also to other platforms such as Android and Windows. With over 65% of listeners tuning into podcasts from portable devices the project will bring flexible improvements to the app UI focused on mobile devices while exploiting QtQuick’s support in designing convergent applications that conform the UI without increasing cognitive load on the user and provide an excellent overall experience.</p>

mitmproxy is a superb tool for security and privacy forensics. It currently supports HTTP/1 and HTTP/2, but lacks support for QUIC and HTTP/3. This leaves about 25% of the web's traffic in the dark. The project's goal is to change that. To achieve this goal, UDP support and layers for QUIC and HTTP/3 need to be implemented in mitmproxy. For UDP, stream-like readers and writers will be introduced. Facilitating a library will aid in implementing QUIC, preferably aioquic. The new HTTP/3 layer will be based upon mitmproxy's existing HTTP/2 layer. Once the project is complete, QUIC and HTTP/3 traffic can be inspected using mitmproxy as well, just like HTTP/1+2 today. As a bonus, DNS capabilities will also be available, as a proof-of-concept for UDP support.

The idea is to add support for interactive movies inside VLC using the matroska.org mkv format. An interactive movie is like a gamebook but for movies. For that we need to improve MKV specification to support features like titles and menus, make existing mkv muxing tool, like MKVToolNix support the extended specification and finally integrate them to VLC.

<p>LiveHD only supports glibc-based Linux at the moment. We can extend support to other platforms like Alpine Linux and macOS, so more people can use it. Alpine Linux support also allows us to compose a more lightweight container for easier and faster deployment. Additionally, the infrastructure of the LiveHD project could use some improvement, and with that, the quality of the project and the development experience can improve significantly.</p>

Nowadays, the rise of AI has shed light into the power of GPUs. The notion of General Purpose GPU Programming is becoming more and more popular and it seems that the scientific community is increasingly favoring it over CPU Programming. Consequently, implementation of mathematics and operations needed for such projects are getting adjusted to GPU’s architecture. Automatic differentiation is a notable concept in this context, finding applications across diverse domains from ML to Finance to Physics. Clad is a clang plugin for automatic differentiation that performs source-to-source transformation and produces a function capable of computing the derivatives of a given function at compile time. This project aims to widen Clad’s use range and audience by enabling the reverse-mode automatic differentiation of CUDA kernels. The total goal of the project is to support the differentiation of CUDA kernels that may also include typical CUDA built-in objects (e.g. threadIdx, blockDim etc.), which are employed to prevent race conditions, using Clad. These produced kernels will compute the derivative of an argument specified by the user as the output based on an input parameter of their choosing. In addition, the user must be able to call these kernels with a custom grid configuration.

This project aims to add Windows support to the previously Linux-only XMPP client Dino. Since Windows is installed on approximately 75% of all desktop/notebooks, this would greatly expand the possible audience of this XMPP client. Dino aims to be a simple-to-use XMPP client, as such, it makes sense to make onboarding easier by running on common platforms. Additionally, this project aims to add support for saving passwords in keyrings and adding support for SASL SCRAM, making passwords more secure in case the keyrings are.

<p>Transformers are getting more and more attention in tasks outside of Natural Language Processing (NLP) and should be considered a general sequence to sequence model. Also in Computer Vision Transforms have shown to outperform or are on par with Convolutional Neural Networks (CNNs). Due to their increased practical importance and potential impact in the future, the goal of this project is to implement and reproduce the recent paper "An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale" by Dosovitskiy et al. for the TensorFlow Model Garden.</p>

Currently, the wild linker has limited support for linker scripts, which are commonly used in the Linux Kernel and embedded development. This makes it nearly impossible to use the wild linker for any Linux or embedded development. This proposal lays down a suggested path to try and implement most, if not all the major features requested for Linux kernel module support.

Currently, Mixxx uses PortAudio as a high level abstraction over audio APIs across all supported platforms, which only exposes the common subset of all those APIs, missing Linux specific features and conventions. This implementation will add Pipewire audio API support to Mixxx for Linux, listen for PipeWire events to support soundcard hotplug and update routing UI according to changes made in an external patchbay. It will also allow Mixxx to route audio to and from any source/sink. This proposal also attempts to achieve ALSA comparable latency with the PipeWire backend.

This proposal aims to enhance CVE-BIN-TOOL by integrating support for different VEX triage functionality. The problem at hand is the limited scope of CVE-BIN-TOOL, which currently lacks extended VEX integration, hindering its ability to provide a holistic risk assessment. The solution involves refactoring the current workflow, implementing support for various VEX formats (such as CSAF, OpenVex, and CycloneDX), establishing linkages between SBOMs and VEX formats, and updating documentation and tests for usability. Through this project, we aim to provide cybersecurity professionals with a comprehensive tool for identifying and mitigating vulnerabilities effectively. The deliverables include a refined workflow, support for multiple VEX formats, documented linkage mechanisms, and updated documentation and tests.

<p>Swift supports multiple levels of optimizations per single module. This project aims to achieve LTO support for Swift at LLVM level and at Swift’s intermediate representation level to do more aggressive optimization across modules.</p> <p>This proposal suggests language-agnostic LTO support and linker plugin implementation for Swift specific LTO.</p> <p>The linker plugin will be able to accept serialized Swift Intermediate Language (SIB) files for multiple modules and performs cross-module optimization passes (e.g. Dead Code Elimination, Inlining).</p> <p>As a result, it’s expected to achieve significant binary size reduction and runtime performance improvements.</p>

This project aims to extend the functionality of the Eclipse Dash License Tool by adding support for Software Bill of Materials (SBOM) files as input, specifically in CycloneDX and SPDX formats. Currently, the tool can accept and process dependencies from Maven files or NPM package files, but lacks the capability to accept SBOM files as input - a feature that is becoming more standardized in modern licensing software. This proposed solution involves the implementation of specific file parsers for CycloneDX and SPDX formats, extracting and normalizing component data, and then integrating this data into the tool's existing workflow. In addition, this project will support the generation of enriched SBOM outputs that include updated licensing information whilst preserving the initial contents of the file structure and metadata. The final deliverables for this project include SBOM input support via new command-line arguments, file parsing, integration with the rest of the tool's existing workflow, enriched SBOM output generation, extensive testing, and explicit documentation.

<p>With this proposal, I propose to implement a bridge between Prometheus and Performance Co-Pilot which would enable these systems to be able to import and export metrics across each other. The Performance Co-Pilot would be able to collect the metrics from application supporting Prometheus endpoint and pushing metrics from Performance Co-Pilot into Prometheus.</p>

Port BPF tools to Performance Co-Pilot PMDA and implement PCP/Htop DynamicTabs. The Htop utility recently acquired the ability to display multiple Tabs in its user interface. Currently, these display only process information. The aim of this project is to support generalized Tabs, where information beyond processes can be displayed in columns. The classic example of this would be being able to display cgroups on Linux.

<p>bpftrace is a high-level tracing language for efficient kernel tracing using eBPF (extended Berkeley Packet Filters). This project creates a new PMDA (Performance Metrics Domain Agent) for PCP which runs arbitrary bpftrace scripts and stores the output as PCP metrics, and a new Vector widget which visualizes these collected metrics in a live heat map or table. Furthermore, the Vector widget will include a bpftrace query builder for the rapid creation of bpftrace scripts.</p>

This project is to extend some timeseries functionalities based on the existing query languages. The tasks to be worked on are: 1. grammar extensions supporting scalar operands in expressions, either as literal constants or from functions returning a scalar result. 2. additional functions complementing existing functions to operate across both the time domain (with one scalar result per metric instance) and across instance domains (with a single vector result). 3. new statistical functions such as top_k(expr) and nth_percentile(expr, n) and rolling_avg(expr, n). 4. new functions for subsampling and interpolation of vector operands to match time series samples with other vector operands in an expression.

<p>Goal of this project is to improve and build upon existing Grafana intergration for Performance Co-Pilot.</p> <ul> <li>Developing a <strong>reactive dashboard</strong> and using PCP metrics</li> <li>Implementing support for PCP <strong>derived metrics</strong> in the Vector data source, as described in the PCP REST API documentation</li> <li>Improving the <strong>metric search</strong> process by creating a new page for live, full-text search on PCP metric names, instances, instance domains and their descriptions, if any</li> </ul> <p>Based on performance metrics from PCP and a predefined rule set, the <strong>reactive dashboard</strong> should display only relevant metrics to the user. For example, if the CPU utilization is high, it should show an overview of CPU statistics and processes contributing load. The user should then be able to drill down into more specific areas of interest - e.g. present graphs about lock contention. For each recognized performance issue a link should be presented to the user on how to resolve the issue. In this way the dashboards guide users toward possible root cause of performance problems.</p>

sktime in its current state does not support categorical variables in input data and this has been an often requested feature from its users. This project aims to add categorical support (for exogeneous input) to the forecasting and transformation modules by reworking the base framework layer and datatypes module. Another objective is to ensure categorical data works when used in sktime pipelines and relevant compositors.

This project adds Hyperlight as a new VMM backend in KraftKit, enabling Unikraft unikernels to run with `kraft run --plat hyperlight`. The work will introduce platform registration and a new Hyperlight driver in the machine layer, then implement the full machine lifecycle: create, start, stop, delete, inspect, list, logs, and watch. It will start with a minimal boot path for a basic kernel, then extend to networking and storage support where possible. By the end of the project, KraftKit will have first-class Hyperlight support, and users will be able to manage Hyperlight machines through the standard CLI workflow.

<p>This project aims to extend the current DSL based component code generator to also generate RoboComp components that can be run in the browser. The new components generated will be using javascript and as an html file should be able to be deployed in the browser and also to communicate with the non JS components already developed earlier (laser, keyboardcontroller, joystick etc.). It is an interesting diversion from current robotics technologies based on C++/ python to use JavaScript to code some highly concurrent components.</p>

Kyverno lacks the ability to operate on some important subresources like /scale and /status in areas such as validation and mutation. Upstream Issue (URL): - https://github.com/kyverno/kyverno/issues/3118 - https://github.com/kyverno/kyverno/issues/2843 - https://github.com/kyverno/kyverno/issues/4313

<p>The projects aims at incorporating Firebase Analytics and Crashlytics into Oppia's Android application to send usage data to a central location while ensuring that no sensitive information leaves the phone. It also aims at offline storage of event and crash stats in case of network connectivity issues. The implementation of such features will lead to a constructive and insightful decision making process and therefore promise a better end-user experience.</p>

<p>The project aims to program a demuxer in the libavformat and a parser and decoder in the libavcodec library. As DICOM files contain lots of metadata about the medical procedure done, the demuxer should be able to correctly identify and separate the data in the required number of streams. The DICOM decoder should decode the compressed pixel data and can extract a frame ( or multiple frames, depending on the stream ) from it.</p>