Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
The goal of this proposal is to address the challenge of investigating the contents of containerized applications, which run in isolation from the host operating system. The proposed solution is to extend go-crit with forensic analysis features to improve its usability in analyzing container checkpoints. Then the new features of go-crit will be used to enhance checkpointctl's user-friendliness when performing forensic analysis of container checkpoints. The deliverables of this project will include the following: - An updated version of go-crit with forensic analysis features, which will allow other tools written in Go to perform forensic analysis of container checkpoints more easily. - An updated version of checkpointctl CLI with new command designed for forensic analysis of container checkpoints.
Kubernetes has recently moved its forensic container checkpointing feature into beta. This feature allows checkpointing containers within Kubernetes pods, and, with some additional steps, restoring them on a different node. This approach preserves active TCP connections of the container. However, workloads (e.g., web servers) with established TCP connections to the migrated container cannot make use of this feature, as the container IP changes after migrating to another node. This project implements a P4-based load balancer on the data plane that dynamically reroutes packets to the correct IP address after container migration. The goal is to make the migration invisible to the client, causing only a period of service unavailability, after which communication can be resumed without re-establishing the TCP connection. Deliverables of this project include a P4-based load balancer, control plane code for P4 runtime interaction, a minimal CNI plugin for Kubernetes integration, and performance benchmarks to demonstrate the system's effectiveness.
<p>Gentoo is an operating system with extreme focus on configurability and performance. To provide fully customizable experience, without interfering with the stability of the system, Gentoo has a concept of masked packages. These masked packages (or versions) are either untested, or are known to be unstable and are installed only if the user explicitly unmasks them. While this concept is a boon to the stability of the operating system, the current implementation requires the packages to be tested manually by a team of developers. This significantly increases the time in which new packages are made safely available to the users. The goal of this project is to provide a mechanism to test and stabilize the packages automatically with little or no human intervention.</p>
<p>XIP and TCP/IP can interoperate with each other by encapsulating the XIP packets as the payload of the IP datagram , which can be tunneled through the IP networks and can be extracted and processed further by hosts at the end of the tunnel .The U6ID principal encapsulates XIP packets in IPv6 UDP datagrams .</p>
In this GSoC project, I worked on developing a multimedia processing system, focusing on commercial detection and replacement using deep learning. I have developed a real-time, efficient solution that enhances media consumption experiences by seamlessly integrating custom audio streams during commercial breaks.
<p>This project aims to provide an API for different programming languages to load firmware, start/stop and communicate with the BeagleBone PRUs (Programmable Realtime Units) from user space using the RemoteProc, RPMsg drivers. Example firmware and user space software are provided to demonstrate the use of the project.</p>
The Checkpoint-Restore Operator manages checkpoint retention well but has no way to create checkpoints automatically. This project adds a new CheckpointSchedule CRD and controller that triggers checkpoint creation through four mechanisms: cron-based time schedules, CPU/memory resource thresholds, Kubernetes cluster events (node drain, pod eviction, preemption), and pod annotations for application-level signaling. All triggers call the existing Kubelet Checkpoint API via the Kubernetes API server proxy. Deliverables include the CheckpointSchedule CRD, a CheckpointCreator that calls the Kubelet API, four independent trigger subsystems, a TriggerManager to coordinate them, a full controller-runtime reconciler, RBAC updates, unit and BATS integration tests, and sample configuration. Together with the existing retention policies, this turns the operator into a complete checkpoint lifecycle manager — admins declare both when checkpoints are created and how long they are kept, with no custom scripting required.
The project aims to eliminate GBridge and merge its functionality into greybus (linux driver) and cc1352 driver. The subtasks I have identified are the following: 1. Allow Greybus Linux driver to directly communicate with cc1352 2. Move SVC and APBridge roles into cc1352 3. Eliminate the need for GBridge
<p>The idea of this project is to make the same user space examples work with both BeagleBone Black and BeagleBone AI, using the same references to drivers for peripherals assigned to the same pins between BeagleBone Black and BeagleBone AI.</p>
<p>The idea behind the project is to make Xen hypervisor available and easy to use on beagleboard-x15. This implementation will allow users to experiment on embedded virtualization and in related fields like automotive, critical systems prototyping and processor's resources sharing. It might also provide very interesting possibilities for heterogeneous resources' utilization. The most interesting outcome is the availability of open-source virtualization on top of the open-source hardware.</p>
On several BeagleBone boards, there are an ultra-low latency 32-bit RISC CPUs called Programmable Real-time Units (PRUs) with register-mapped I/O directly to pins that is a custom architecture. The programmable nature of the PRU, along with its access to pins, events, and all SoC resources, provides flexibility in implementing fast real-time responses, specialized data handling operations, custom peripheral interfaces, and in offloading tasks from the other processor cores of the system-on-chip (SoC). To provide the capability of a Programmable Real-time Unit Industrial Control SubSystem (PRU-ICSS), I propose to deploy an existing RISC-V 32IM core with a customized Instruction Set Architecture on FPGA Fabric present on BeagleV-Fire. The goal of this deployment is to provide high bandwidth between the CPU and I/O, resulting in a on-board microcontroller. At project conclusion, BeagleV-Fire will host a fully functional PRU system that can execute Risc-V based instructions, and can be controlled by invoking specific functions within a C code using a PRU C library.
<p>Current Android system upgrade procedures usually fall into the following two categories, with inconvenience respectively:</p> <ul> <li>complete upgrades, which override the existing system entirely<ul> <li>require downloading large binary blobs altogether for small system upgrades</li> </ul> </li> <li>delta upgrades, which apply block-level or filesystem-level patches to the existing system<ul> <li>require the system to be untampered so that the patch can be applied</li> </ul> </li> </ul> <p>With <strong>Portage</strong> managing the different components of Android, it’s possible to perform small updates <em>painlessly</em>, while <em>retaining the ability to shape the system</em> as we’re pleased, such as to make it a full-blown <strong>GNU/Linux</strong> system.</p>
<p>While checkpointing (Dumping), CRIU stores some meta-information about the open/mmaped file and this is validated while restoring to make sure that the right file is being restored. Currently, the only meta-information stored is the file size. The goal of this project is to extend this meta-information to include other information so that the possibility of an incorrect restore is reduced. Two more types of validation will be present, in addition to the File Size validation, after the completion of this project - Build-ID Validation and Checksum Validation. The implementation must also be tested using the ZDTM test suite.</p>
P4 empowers developers to program the data plane of network devices—switches, routers, and NICs—at a level of detail previously only accessible to hardware designers. P4 software/simulated switches like BMv2 make the development even easier by having the programs and control plane run on developers' computers and give instant feedback. This project aims to further improve the capability of BMv2 and enable a potentially broader insight for developers to analyze their P4 program. While traditionally one packet only goes through one path within the switch and thus obtains only one result, there are many situations where it is more useful to have all possible outputs from a P4 simulation. For example, we use this for diff testing, to determine whether the switch is doing something correct or something incorrect. Multiple allowed behaviors and results usually arise from various multi-path constructs (e.g. ECMP, WCMP, or perhaps LAGs) which are often modeled as action profiles/selector in P4. BMv2 currently allows users to set a mode determining action profile/selector behavior, like `round robin` where every time one sends in the same packet, it would invoke the next possible forwarding action (eventually wrapping around). The goal of this project is to provide a new mode for BMv2 to output all possible behaviors. This will both require extending the action profile modes, and extending the notion of output from a set of packets to a set of sets of packets.
<p>Camera imaging pipeline is typically embedded in a camera hardware making it difficult to customize the imaging algorithm for developers.The project is aimed to develop a software camera pipeline within the libcamera framework, which also includes the GPU/SIMD acceleration.</p>
<p>Programming the PRU is a uphill task for a beginner, since it involves several steps, writing the firmware for the PRU, writing a loader program. This can be a easy task for a experienced developer, but it keeps many creative developers away. So, I propose to implement a REPL based control of the PRU, hiding all the low level things behind the REPL and providing a clean interface to uses PRU. This can be achieved by implementing a PRU firmware which only runs some specific user defined commands delivered by RPMSG, executes and then sends a appropriate response. This can be achieved by offloading major task like lexing, parsing to the linux core, and through RPMSG only certain set of commands will be run, the high level code will be converted to these set of commands, on the linux machine itself.</p>
<p>Bitbanging an SPI or/an I2C device in Linux leads to a lot of problems.It consumes a lot of valuable CPU cycles.And since Linux is an non-preemptive OS(And not an RTOS),once we start bitbanging,other important tasks that require CPU time would suffer.Thus,there are a lot of software overheads in doing the same. To avoid this on the BBB,we could offload the task of bitbanging I2C,SPI,UART, to the PRU.The PRU is a separate core and,hence,not affected by the Linux Scheduler. Hence the motivation for exposing the PRU as an I2C,SPI,UART device comes from the fact that they would be no software overheads in doing it and hence,we would gain extra serial interfaces without wasting valuable CPU cycles in bitabanging.</p> <p>This project involves writing Device Tree Overlays,Device Drivers and PRU firmware code for Bitbanging I2C,SPI and UART.</p>
This project is to improve the P4Sim module by enhancing its Traffic Manager and integrating ns-3's built-in QueueDisc class into it. This will help developers and researchers in testing P4 switches with more complex scenarios and get accurate results for their experiments.
Contemporary developments of Machine Learning Applications in real-time Networks to classify traffic for better security and performance are examples of cutting-edge research happening. This growing idea begs for an efficient framework of ML Models to adapt to needs and match the expected output, more like making a General ML Model into a Network domain-specific ML one. This project aims to adapt the SpliDT Framework, a partition-based approach for implementing decision tree inference directly in the data plane using P4. It will be optimized through TensorFlow, and HyperMapper and using Python libraries like scikit-learn.
<p>This project is mainly focused on implementing and testing the RHHH algorithm interfaced with Cold Filter that will be used to quickly and efficiently identify the IP destinations/prefixes/flows that need to be blackholed. This project will help enhance Gatekeeper's performance against denial-of-service(DoS) attacks.</p>
The project aims to centralize the P4 compiler (p4c) documentation by developing a new, well-structured documentation website using Doxygen for automated content generation. It will utilize GitHub Actions to automate build and update processes and introduce a PR preview system, enabling contributors and maintainers to review documentation changes before merging. These efforts will establish a clear, accessible, and organized website, making it easier for all members of the P4 community to navigate and maintain.
P4 (Programming Protocol-independent Packet Processors) is a domain-specific language for network devices. It allows programmers to specify how data plane elements (switches, NICs, routers) process packets without needing to deal with the specifics of the underlying hardware. The absence of a code formatter for the P4lang poses challenges for developers working on large codebases, hindering efforts to maintain consistent coding styles across projects.This project aims to address this gap by developing a code formatter specifically tailored for P4. This would enhance productivity by standardising coding styles, facilitating collaboration among developers, and improving code readability. By implementing this tool, developers will be able to efficiently format P4 codebases, ensuring adherence to coding standards and fostering a more streamlined development process.
<p>I have been under the guidance of XIA mentors since 3 months and have put in all my knowledge necessary to the project in my proposal.Hope i am up to the standard set by XIA developers.</p>