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.
NanoBSD has long provided a reliable framework for building embedded FreeBSD images, but its legacy pipeline remains monolithic and resource intensive, source based workflow. This project modernizes the NanoBSD image creation process by allowing decoupling of the build and assemble phases using pkgbase which is a package-driven assembly model. Furthermore by using tools like makefs, mtree, and mkimg, the new pipeline will enable fast, reproducible, and cross-architecture image generation without requiring root access. The key deliverables will include - PkgBase Integration into the current NanoBSD image creation pipeline, modernize the Boot support by implementing GPT layouts and UEFI booting for both x86 and aarch64 (ARM). The project will also focus on providing tier 1 support for Aarch64 devices. Also if time allows the support for ZFS filesystem will be added in the NanoBSD image with various eMMC storage optimizations to increase the life of those class of storages. Along with the support for automated first boot configuration will also be implemented using nuageinit.
<p>The objective of this project is to add processor support and a board support package (BSP) for the ARM Cortex-M4F microcontrollers on RTEMS. In addition, I will be adding an ethernet driver and lwIP for networking, and console and clock ticks support for the BSP.</p>
<p>The purpose of this project is to provide a shared and well-tested implementation of parsing package atoms and related support for pkgcore - alternative package manager for Gentoo, similar to portage, which aims for high performance, good extensibility and a clean design.</p>
This project aims to move the current V4L2 implementation of accessing and controlling cameras in OpenCV to libcamera, this will allow for better functionality for more advanced and complex cameras. This will be done by creating a videoio plugin for OpenCV to support libcamera and then creating suitable classes and functions to add the desired functionality.
The current FreeBSD environment lacks robust automated testing for Rust kernel modules and officially maintained Rust drivers. Past projects for Rust in FreeBSD started with Johannes Lundberg's Master's Thesis, where he created a RustKPI, e1000 Rust Network Driver, and a Rust kmod Hello World Example. From this, we saw Anatol Ulrich create a Hello World kernel module and a research article about writing FreeBSD kernel modules in Rust by David Young. Outside these contributions, Rust's current progress in FreeBSD is very shallow. This lack of depth makes it difficult for others to learn and build upon. I propose to analyze and extend the past work of others to assist anyone wanting to further the development of Rust in the FreeBSD kernel. My project will focus on these primary goals: 1. Creating tests in /usr/tests tree using ATF & Kyua for an existing Rust Driver 2. Use these tests to find errors in the driver logic, repairing them when needed. 3. Create a updated environment where developers can easily code and compile Rust FreeBSD device drivers. 4. Create both a Hello World driver and an Echo character driver with this environment. 6. Publishing clean and effective Rust device driver documentation for future developers to expand and work with the environment.
If a mount is unmounted using the MNT_DETACH flag, its information disappears from /proc/$pid/mntinfo. If CRIU tries to C/R an fd on such a mount point, it fails because it can't find the mount point in /proc/$pid/mntinfo. We aim to solve this problem by extending the statmount syscall to export mountinfo for such mounts and using it to add support to CRIU as well.
<p>During checkpointing and restoring, CRIU locks the network to make sure no TCP packets are accepted by the network stack during the time the process is checkpointed (to avoid the kernel from sending a RST packet). Currently CRIU calls out to iptables-restore to create and delete the corresponding iptables rules. Another approach which avoids calling out to the external binary iptables-restore would be to directly inject eBPF rules. There have been reports from users that iptables-restore fails in some way and eBPF could avoid this external dependency.</p>
<p>A stateless system based on Gentoo, which aims on making the maintenance of multiple machines easier, improve stability and usability on environments like Research or University computer labs.</p> <p>The project will attempt to cover two methods of mounting the system and two sync/upgrade styles for local systems. In addition to that, it will attempt porting the project over ARM architecture, to support Raspberry Pi machines, which are used on labs very often, to increase the productivity by minimizing resources required, making them available for computational work.</p>
<p>The forwarding information base (FIB) of principals that have flat XIDs uses the default hash table available in Linux XIA. However this hash tables does not have the shrink feature. There exists a data structure known as relativistic hash table that is dynamically resizable (can expand and shrink), scalable and concurrent. This hash table, also known as rhashtable, also requires less memory per item in the table. The final aim of the project would be to augment the Linux XIA kernel with the power of relativistic programming by upgrading the FIB hash table to the relativistic hash table.</p>
P4TC enables programmable packet processing in the Linux kernel via TC and eBPF, but its control plane is limited to the tc CLI and shell scripts. This project delivers idiomatic Python (cffi) and Rust (bindgen) wrappers for P4TC's C API, covering both provisioning and runtime CRUDSP operations. Deliverables include: (1) a Python package (p4tc_py) with context managers and type hints, (2) a Rust crate (p4tc-rs) with safe ownership semantics and Drop-based cleanup, (3) ported tutorial examples in both languages, and (4) API documentation with a shell-vs-Python-vs-Rust comparison guide.
BeagleMind is an AI-powered documentation copilot for BeagleBoard that uses Retrieval-Augmented Generation (RAG) and tool calling to assist contributors and developers. The assistant retrieves precise, context-aware answers from a vector database built from official BeagleBoard documentation, ensuring accurate and citation-backed support. With integrated tool-use capabilities, it can help users explore documentation, generate code, and automate development tasks. The MVP will be released as a Python package on the Python Package Index (PyPI), providing a lightweight command-line interface for seamless access. By streamlining access to technical knowledge and tools, BeagleMind will reduce friction in the development process and empower the BeagleBoard community.
Building upon the work done in GSoC 2021 to make programming the PRU easier for beginners, this project aims to add tests, features, and more compatibility for simpPRU, the simple Python-like language that compiles to PRU C and runs natively on the PRU. I will be adding assignment,bitwise operators which increase the efficiency of usage and write testcases for it, adding the compiler flags for generated C code and document their outcomes,the python test would be added to github actions for testsuite,I will be adding support for return statements,calling C from simpPRU,enhance error handling in parser,adding additional testcases for the features present. I will be writing a research paper on simpPRU quoting its need,implementation done and its preferable usage.This will make the overall language more robust and efficient, which will help beginners who are learning to use the PRU or experienced users prototyping something on the PRU.
<p>The BeagleBone AI is equipped with a high amount of processing power due to the Dual Core ARM Cortex-A15 chip as a main computing unit and its accompanying co-processors. This makes the AI a perfect fit for highly demanding applications regarding CPU consumption, like media applications which have extremely strong realtime constraints. Professional audio/video studios have to guarantee for small latencies when transmitting media signals between different devices. Different media channels in a transmitted stream need to be carefully synchronized to guarantee for e.g. lip synchronicity. To use the AI in such a scenario, the AVB protocol stack should be implemented in the Beagleboard Linux Kernel, which allows for synchronization of media streams within a local area network. Furthermore the CTAG Face audio drivers should be ported from BeagleBoard-X15 and HDMI audio out capabilities should be deployed, to allow the in- and output of audio data.</p>
<p>This project strives to support distribution of libraries for large-scale data processing and computation on Gentoo Linux. In particular, it will focus on big data software built upon the Java platform. The project will be based on <a href="https://github.com/gentoo/java-ebuilder" target="_blank"><code>java-ebuilder</code></a>, a tool that creates a Gentoo package for any Java library hosted on Maven Central, and a <a href="https://github.com/6-6-6/spark-overlay" target="_blank">Spark overlay</a> done by Zongyu Zhang for the previous year’s GSoC. It will improve upon these resources to ship the H2O Machine Learning Platform and Kotlin libraries on Gentoo, in addition to Apache Spark and the Java libraries that the Spark overlay already provides. It will also introduce utilities for testing both <code>java-ebuilder</code> and the software packages in the Spark overlay.</p>
<p>Many applications require mechanisms for high speed, real time and continuous data acquisition from a sensor that is essentially an ADC. Most hobbyists would want to use simple devices, rather than high end converters with differential serial interfaces to communicate as these high end devices can be expensive. The typical serial data communication protocols used for this are somewhat limited in terms of speed, while parallel data communication definitely has an advantage of higher speed data transfers.</p> <p>This GSoC project aims to utilize the two PRUs present in the PRUSS2 subsystem and their low latency architecture to get a fast, generic, parallel analog converter interface, in the form of parallel bus, ready for various applications. The project will provide a ready to use firmware, user-space library, kernel driver, and the subsystem to manage all the parallel data transactions. This will further allow developers to build some cool applications like function generators, oscilloscopes, voltmeter etc.</p>
Bela is an open hardware and software platform for creating beautiful interaction with sensors, sound and it is designed for artists, musicians, researchers and makers, Bela brings the power of ultra-low latency interactive audio and sensors to digital systems. Bela Platform uses the Bela software which is a customised Debian distribution including a custom xenomai kernel, minimal clutter, and custom systemd configurations and It takes advantage of features of the BeagleBone computers and can achieve extremely fast audio and sensor processing times. Bela Image development repo is heavily based and which was initially inspired by Beagleboard Image-builder scripts. Currently, the Beagle board Image development repo diverged greatly from a common functionalities of building Images. Now, there is a requirement to "rebase" the functionalities of the Bela Image builder repo to the Beagleboard Image builder one. As the two codebases are drastically different. This project is to Improve the maintainability of the Bela Image development by adding the functionalities of the Bela Image builder repo to the BeagleBoard Image builder repo.
Back in 1999, a new revision of the C standard removed several backward compatibility features. However, GCC still accepts these obsolete constructs by default. Support for these constructs is confusing to programmers and potentially affects GCC's ability to implement features from future C standards. But newer versions of compilers (for example Clang 16, expected March 2023) are planning on becoming significantly stricter with the C code they will accept or reject. This is a huge problem for the general Linux ecosystem. Even worse is that some of these failures are silent and lead to incorrect behaviour at runtime. Extra care must be taken to detect this and we must prioritize these cases because they're the most harmful. Also, in the coming years with C2x (likely C23), additional changes like removing certain depreciated prototypes will be made. All of these changes will affect Gentoo packages in the following ways: Lots of packages fail to build with these settings Sometimes packages build successfully but their ./configure scripts have mis-detected features or otherwise made the wrong conclusion about the system because they expect a test to succeed when it now fails.
This project seeks to advance the development of the x86_64 BSP by implementing ACPICA support, Symmetric Multiprocessing, Floating Point support and Thread Local Storage support. Additionally, it involves the addition of a BSP tester for the rtems-test tool, with the ultimate goal of ensuring the BSP successfully passes all tests in the test suite.
<p>RTEMS already supports the Raspberry Pi1 development board, and has a fair bit of support for the Raspberry Pi2. The Raspberry Pi Zero/ Zero W is a low cost board that can run RTEMS and is based on the same SoC as the Pi1, whereas the Raspberry Pi 3 is an upgrade on the Pi2 and is more widely used. My project aims to add RTEMS support for the Raspberry Pi Zero, Pi Zero W and the Pi 3.</p>
<p>QEMU supports exposing block devices to the guest OS over the virtio-scsi protocol. Currently, this is implemented using C code running in the main QEMU process. There is also support for using an external backend over vhost-user-scsi, but the existing backend is implemented in C, and is fairly limited, only supporting iSCSI.</p> <p>The goal of this project is to implement an alternate vhost-user-scsi backend in Rust. This would provide benefits to security, reusability, and performance.</p>
The objective of this project is to implement a new DTrace provider for dynamically tracing all instructions in a given function. FBT (Function Boundary Tracing) is a DTrace provider providing probes for the entry and return points of a kernel function. The new provider – we’ll call it `kinst` – will reuse parts of the FBT mechanism, but extend it to be able to put probes on arbitrary points in a given kernel function. This provider will be especially useful for tracing long kernel functions. It will also set the building blocks for inline function tracing.
<p>The project is to write a driver for Bosch BME680(4-in-1) sensor module using the Industrial I/O interface to effectively read data from each of the four channels which are Temperature, Pressure, Humidity and Gas. The sensor communicates via I2C and SPI communication protocol and the captured data read from the sensor is transported from kernelspace to userspace using the sysfs bindings to the IIO core. The goal is also to add support for triggered buffer readings from each of the channels to efficiently read samples. Finally, power management support is also required to support suspend/resume functions.</p>
<p>Currently <code>bpftool</code> as a userspace utility tool living in the linux kernel can do ebpf feature probing: <code>bpftool feature probe</code>. As the Go+ebpf user-base is growing, it would be useful to have the possibility to probe the kernel for available ebpf features from other userspace programs written in Go without having to shell out to <code>bpftool</code>. This proposal is about adding a feature probe API to cilium/ebpf that gives users a standardized interface to query the kernel for available ebpf features, furthermore encouraging the use of Go within a fast growing ebpf community.</p>
QEMU-NVMe is an important tool for developers to experiment with new features in the NVMe stack. However, its emulation performance has failed to catch up with the ever-increasing speed of modern storage devices. The goal of this project is to improve QEMU's NVMe emulation performance so that it becomes comparable to virtio-blk. We intend to implement the following optimizations: (1) Add Shadow Doorbell Buffer support to reduce doorbell writes. (2) Add Submission Queue Tail Doorbell register ioeventfd support. (3) Add iothread support to run emulation in a separate event loop. (4) Add Submission Queue Tail Doorbell register polling.