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 objective is to enhance the Beagle-Tester framework for BeagleBoard devices by adding mikroBUS support and updating it for mainline kernel testing. This project aims to develop an automated regression test suite for Linux kernel on BeagleBoard hardware, enabling continuous validation within the OpenBeagle CI server. The approach includes developing comprehensive test cases for interfaces such as PWM, ADC, UART, I2C, SPI, and GPIO, integrating automated power cycling capabilities for test farms, building a web interface for real-time monitoring of test results, and optimizing the framework for seamless Buildroot deployment. Key deliverables include an enhanced Beagle-Tester with mikroBUS support, an automated regression testing framework for kernel updates, a GitLab CI pipeline for weekly testing, a modular test farm design with power cycling capabilities, a web-based monitoring interface, and comprehensive documentation with tutorials.
<p>Allpix-Squared is a free and open-source simulation framework for silicon tracker and vertex detectors written in modern C++. Its goal is to facilitate in-depth studies of silicon-based particle and radiation detectors widely used in high-energy physics. During simulation, Allpix-Squared run events that contains a series of modules that operate on input data — usually in the form of a previous module’s output data. These events aim to mirror the behavior of a particle interacting with a specific detector hardware. Some modules are independent of others, so they can be run in parallel; this is the current state of the multithreading used in the framework, but it does not make good use of available CPU cores. The aim of this proposal is thus to run full events in parallel instead, greatly enhancing CPU core utilization. This however requires some internal restructure and presents new problems not shared with the current approach, such as the issue of event execution order. I aim to solve this issue with dependency graphs. When done, the new multithreading approach should allow better execution time, independent on core count and simulation parameters.</p>
<p>This project aims to enable Chapel with its own module which would be a collection of both secure hash functions(such as SHA256) and various encryption algorithms(such as AES / DES / RSA/ ElGamal, etc) by using the crypto primitives of native libraries such as OpenSSL or libsodium in Chapel (libtomcrypt in our case). This module will be a part of Chapel’s standard library and enable it to compete with other cryptographically secure languages and increase Chapel's range of applications.</p>
The Fabric Token SDK allows developers to create token-based distributed applications on Hyperledger Fabric. While the Fabric Token SDK offers many features (i.e., configurable privacy, p2p transaction orchestration, atomic swaps, and audits,...), performance is yet another important aspect. The Hyperledger Caliper project is a blockchain performance benchmark framework, which allows the evaluation of blockchain solutions. How about using Caliper to benchmark token-based applications built on top of the Fabric Token SDK? The goal of this project is the design and the implementation of a Caliper plugin to evaluate applications using the Fabric Token SDK. This includes the creation of appropriate documentation and performance evaluation of sample applications. The project requires a solid understanding of theory and practice of software development using Golang and Node.JS, distributed systems, and performance benchmarking. During the project you will get hands-on experience with the deployment of Fabric networks, the transaction lifecycle, the Fabric Token SDK, and Hyperledger Caliper.
<p>The new version of QGIS has introduced an API break. The key changes in QGIS 3.0 are as follows:</p> <p>Updated from Qt4 to Qt5</p> <p>Updated from PyQt4 to PyQt5</p> <p>Updated from Python 2.7 to Python 3.0</p> <p>QGIS API is improved , many classes have been deprecated or renamed.</p> <p>The above changes have implications that the pgRoutingLayer plugin is no longer compatible with QGIS 3.0 . For my GSoC project, I propose to accommodate these changes in pgRoutingLayer plugin code and also make use of the new features introduced in QGIS 3.0 to improve the functionality of plugin’s GUI. Also currently there is no test coverage for plugin code which makes it difficult to change features efficiently, so a complete unit test coverage will be built which not only will help in this project but also in future ventures. In addition to this I propose to add functionality for the proposed stable functions of following families:</p> <p>Astar : pgr_astarCost , pgr_astarCostMatrix</p> <p>Bidirectional astar : pgr_bdAstarCost , pgr_bdAstarCostMatrix</p> <p>Bidirectional Dijkstra : pgr_bdDijkstraCost , pgr_bdDijkstraCostMatrix</p> <p>Flow</p>
<p><strong>Relibc</strong> is a libc implementation for both that supports both <strong>linux</strong> kernel and <strong>redox</strong> kernel. Unlike most of the currently available libc implementations, Relibc is written mainly in <strong>Rust</strong>, that makes it very easy to write secure code with a very small additional footprint thanks to zero cost abstraction.</p> <p>The main objective of this project is to improve relibc support to linux, mainly by improving the toolchain compatibility for relibc. The ultimate goal is to provide a fully working <em>x86_64-pc-linux-relibc</em> <strong>Gentoo stage3</strong> transparent enough for end users where they don't have trouble with almost any package they install via Gentoo.</p>
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.
<p>Industrial I/O subsystem, the home of Linux sensors, as Daniel Baluta rightly calls it, provides software support for sensors, ADCs, DACs, clock generators, etc. under the Linux kernel tree. The increasing demand for consolidation due to the bloom in fields of Internet of Things (IoT) and the Automotive industry requires increased efforts to provide kernel support for novel devices being manufactured at pace; this project, a small step in the similar direction, aims to implement an IIO driver for Analog Devices, Inc.’s (ADI) ADXRS290 gyroscope with support of IIO Channels, Buffers, Triggers and Events for both its pitch and roll axes.</p> <p>The ultimate goal is to:</p> <ul> <li>merge ADXRS290's compatible driver upstream to ADI's kernel tree</li> <li>deliver corresponding ABI documentation</li> <li>implement device-tree bindings for ADXRS290 in YAML</li> <li>exhibit a working example with the evaluation board on Raspberry Pi 3B, utilizing the SPI protocol.</li> </ul>
This project extends QEMU FUSE export with support for FUSE-over-io_uring, a modern Linux interface that enables asynchronous, high-performance communication between FUSE daemons and the kernel. Unlike the traditional /dev/fuse path, io_uring reduces system calls, supports batching, and lowers CPU overhead. This project will integrate FUSE-over-io_uring into QEMU as an optional mode, enabling more efficient access to disk image contents through the FUSE export. The work includes implementing queue setup and negotiation with the kernel, supporting multiple inflight FUSE requests, enabling multi I/OThreads, and benchmarking performance using fio. Deliverables include: FUSE-over-io_uring support in QEMU Multi-inflight and multi-IOThread support Performance benchmarks Documentation
Bhyve is a modern type 2 hypervisor originally written for FreeBSD. The goal of this project is to enhance the functionality of its debugging server. Several existing features related to single-stepping are tied to Intel-specific VM mechanisms, which severely impairs bhyve's debugging functionality on other platforms. Thus, the first major goal of this project is to rework the single-stepping mechanism to use the RFLAGS.TF VMEXIT mechanism. This will allow bhyve to support debugging guest operating systems on AMD platforms, which would facilitate kernel development for more 64-bit x86 hardware (other than Intel). The second goal is adding support for hardware watchpoints (and optionally hardware breakpoints) using the guest OS's hardware debugging registers. This will improve the kernel development workflow and allow easier and faster fixes for various kernel memory corruption bugs.
<p>Very often, the QEMU emulator is used to emulate user level processes that are compiled for a different architecture set than the "host" machine on which they are running. This operating mode in QEMU is called the user mode and it is much simpler than the more commonly known system mode in which the full computer system is emulated. The user mode is useful for fast cross execution and debugging and is usually executed on Linux based systems. It achieves this cross execution by having its' own implementations of system functions from the Linux kernel interface. Although many system functions are supported in QEMU, the kernel is constantly extended by addition of new system calls. QEMU user mode can't consistently follow this kernel extension and thus many kernel functions are left unimplemented. The goal of this project is to significantly extend this QEMUs implementation of system functions so that many user programs that depend on these system calls can be safely cross executed. This projects' contribution also extends to the Linux Test Project by developing unit tests for system functions implemented within QEMU.</p>
Current SoCs frequently feature heterogeneous remote processor units in asymmetric multiprocessing (AMP) setups, which may be running several Linux or other real-time OS instances. One such SoC is TDA4VM, with heterogeneous multicore support it can run multiple operating systems simultaneously. TDA4VM has Dual 64-bit Arm® Cortex®-A72 microprocessor subsystem at up to 2.0 GHz, Six Arm® Cortex®-R5F MCUs at up to 1.0 GHz, Two C66x floating point DSP, up to 1.35 GHz, 40 GFLOPS, 160 GOPS and 3D GPU PowerVR® Rogue 8XE GE8430, up to 750 MHz, 96 GFLOPS, 6 Gpix/sec. Zephyr is a small real-time operating system for connected, resource-constrained and embedded devices supporting multiple architectures. Zephyr allows for easy handling of multiple configuration options, APIs and external components, and is well suited to structured application development. Another benefit of Zephyr is that it targets some very serious protocol and standard implementations, being e.g. the first open source RTOS to introduce TSN support – by way of Antmicro’s contribution. The rising popularity of TSN in automotive and aerospace applications, and just about everywhere else, could be a very important reason to start using Zephyr in your TSN-capable product. The goal of the project is to add Zephyr RTOS support to run on Cortex R5 processor core loaded from A72 core running Linux through remoteproc and add few peripheral support (Interrupts, Gpio, UART, Timers) for TDA4VM. The Cortex R5 processor cores are built to provide deeply embedded real-time and safety-critical systems. Adding Zephyr RTOS support for R5 cores in TDA4VM will be very helpful for the Users.. Programming Languages: Assembly Programming, C.
The Greybus module for Zephyr currently exists as an out-of-tree component, making maintenance, testing, and contributions difficult. This project aims to upstream Greybus as an official Zephyr module, improving maintainability, accessibility, and seamless integration within the Zephyr RTOS ecosystem. By upstreaming Greybus, BeagleConnect and other Greybus-enabled platforms will gain native support in Zephyr, removing the need for custom patches or kernel modifications. Originally developed by Google as part of Project Ara, Greybus is a lightweight, high-speed protocol designed for efficient, low-power communication across diverse hardware interfaces. While initially intended for modular smartphones, Greybus has since expanded into IoT and industrial applications, particularly in wireless sensor networks. This project will focus on cleaning up and refactoring the existing Greybus module, revamping its testing infrastructure, and ensuring compatibility with Zephyr’s CI/CD workflows. The successful completion of this work will enable seamless hardware-software interaction, making Greybus more accessible for embedded systems development within Zephyr.
<h4>Dataplane batching</h4> <p>FRRouting uses the concept of a data plane which is the part of the code that processes thedata requests. It is used in communication with kernel i.a. to update routing tables. There areseveral different methods for reading kernel routing table information, updating kernel routingtables, and for looking up interfaces. One of them is Linux Netlink - asynchronouscommunication between kernel and user. FRRouting with its dataplane abstraction, uses aqueue of dataplane context objects for messages waiting to be sent. A separate thread loopsover this queue and sends the context objects to the appropriate dataplane. Every singlemessage is handled and sent separately, but there’s room for improvement. Certaindataplanes allow for sending multiple messages to them at once, so we could benefit from it.This would improve overall processing time. My proposal will involve implementing one ofthe proposed ideas, namely “Dataplane Batching”.</p>
CRIU currently supports unprivileged checkpoint/restore in limited cases, but rootless containers remain unsupported because they introduce additional challenges around user namespaces, ptrace permissions, seccomp suspension, cgroup handling, and UID/GID mapping. This project aims to add a dedicated rootless-container checkpoint/restore path to CRIU rather than extending the existing --unprivileged mode. The implementation will introduce a user-namespace-aware helper architecture for dump, preserve cgroup state when delegation permits it, correctly capture and restore UID/GID mappings using newuidmap and newgidmap, and establish proper restore ordering for user and mount namespaces. Deliverables include the new rootless-container support path in CRIU, cgroup handling improvements, UID/GID mapping support, expanded rootless zdtm coverage, and documentation for the workflow and limitations.
This project aims to improve the debugging experience on RTEMS by enhancing GDB with support for pretty-printing C++ STL objects and kernel structures. By implementing initialization hooks in Python and extending pretty printing to kernel structures, developers will gain clearer insights into program state, aiding in debugging complex RTEMS applications.
IIO (Industrial I/O) subsystem provides support for various sensors in the Linux kernel. It hosts drivers for a wide array of ADCs, accelerometers, temperature sensors, etc. This project aims to implement a driver under the IIO Subsystem for Analog Devices, Inc.’s (ADI) AD7294-2, merge it upstream to the kernel tree, and exhibit a working example on Raspberry Pi 3B+.
<p>The main goal of this project is to make kw ready for it’s Beta release. The work is divided into two stages. The first one, corresponding to the period before the first evaluations, consists of varied tasks. It will serve the purpose of getting completely familiarized with the different parts of the program by working on bugs, documentation, tests, user interface and implementing important features for kernel development. The second stage consists of improving the efficiency of the most costly processes that kw supports: kernel build and deploy. It corresponds to the period between the two evaluations.</p>
<p>The Kernel Mode-Setting (KMS) is a mechanism that enables a process to command the kernel to set a mode (screen resolution, color depth, and rate) which is in a range of values supported by graphics cards and the display screen. Create a Virtual KMS (VKMS) has benefits. First, it could be used for testing; second, it can be valuable for running X or Wayland on a headless machine enabling the use of GPU. This module is similar to VGEM, and in some ways to VIRTIO. At the moment that VKMS gets mature enough, it will be used to run i-g-t test cases and to automate userspace testing.</p>
BATMAN (Better Approach to Mobile Ad-hoc Networking), as developed and used by the Freifunk project, is a routing protocol for (primarily wireless) multi-hop ad-hoc networks. Freifunk is a German initiative to build an open Wi-Fi network at city-scale, based on the principles of net-neutrality. BATMAN's motive is to be a completely decentralized protocol; no one node in the network knows or has to care about the topology of the whole network. Support for this protocol is provided by the batman-adv kernel module on Linux, and, with this project, I'd like to bring that to FreeBSD. This will include the kernel module itself, but also userland networking libraries and tools necessary to create BATMAN networks.
The FreeBSD mac_do(4) and mdo(1) utilities enable controlled transitions of user and group credentials without relying on inherently risky setuid executables. Currently, mac_do only authorizes the /usr/bin/mdo executable, and does not fully support granular group transitions or per-jail executable authorization. This project enhances security by allowing configurable paths for authorized executables (beyond mdo), implementing granular group management via mdo(1) (new -g and -G flags), and integrating comprehensive jail support for isolating credential rules. Key deliverables include kernel-side implementation of allowed executable path lists, enhanced per-jail rule management, extended userland functionality for group management, password authentication integration, and complete documentation updates.
This project aims to implement the udmabuf (User DMA Buffer) driver on FreeBSD, a crucial mechanism for zero-copy memory sharing between userspace applications and kernel subsystems. The absence of udmabuf currently limits FreeBSD's capability to efficiently support modern graphics and virtualization stacks, particularly preventing tools like QEMU from utilizing virtio-gpu with blob resources. The proposed solution involves developing a loadable kernel module that acts as a dma_buf exporter, deeply integrating with FreeBSD's virtual memory subsystem and extending the linuxkpi compatibility layer. Key deliverables include a fully functional udmabuf module implementing the complete set of dma_buf_ops, necessary linuxkpi API extensions for DRM compatibility, end-to-end integration patches for QEMU, and comprehensive ATF test cases accompanied by thorough documentation.
Linux profiling tool a.k.a perf is the home for analyzing the entire system. It provides the support to analyze the stacks end to end leading from hardware events such as instructions executed, cache-misses suffered, or branches mispredicted to software events such as CPU-clock, page-faults, task-CPU etc. The linux perf tools help us to point out exactly where the specific event is leading to performance downturn in kernel, BPF or userspace application. The increasing demand for consolidation due to the bloom in fields of AI and the cloud technology requires increased efforts to provide best performance for novel devices. As software systems become increasingly complex, identifying and resolving performance bottlenecks becomes more challenging. In an effort to address this issue, this project seeks to enhance the support for performance data analysis in various formats commonly used by software developers. Specifically, we aim to enable the export of performance data to formats such as Firefox's Gecko profile format and Chrome's trace event format, making it easier for developers to analyze and optimize their code for different platforms and environments. By doing so, we hope to improve the overall performance and user experience of software applications.
Modern printer testing remains heavily dependent on physical hardware, making it slow, expensive, and difficult to scale for regression testing. While OpenPrinting already provides a Go-based MFP simulator and a Python-based image evaluation framework, these components are not yet integrated into a unified, automated testing system. This project proposes to build an end-to-end, hardware-free print testing pipeline that bridges this gap. The system will be implemented as a Go-based orchestration tool that directly leverages the simulator’s internal libraries for efficient control, while embedding Python to execute advanced image evaluation. It will automatically load printer models, create CUPS queues, enumerate all supported print modes, execute print jobs, capture simulator outputs, and evaluate them against expected results. The pipeline will support both single and batch testing modes, enabling scalable regression testing and seamless CI/CD integration. It will generate detailed, structured reports with quality metrics (e.g., SSIM, PSNR) and pass/fail analysis. By transforming isolated components into a cohesive, automated system, this project will significantly enhance reliability, reproducibility, and scalability of printer testing in the OpenPrinting ecosystem.