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.
My project’s primary goal is to create unit tests using KUnit for the AMDGPU driver focused on the Display and Compositing Engine (DCE) 11.2, which will be tested on the GPU “RX 580”. The motivation for that comes not only to assert that the APIs work as expected, but also to keep their behavior stable across minor changes in their code, which can allow for great improvement to the code readability and maintainability. There is a great probability that KUnit will have some limitations in regards to testing GPU’s drivers’ functions, so the secondary goal will be to enhance its capabilities. It’s expected that there will be other people working with KUnit on DCN in parallel, so there will probably be some code review to be done as well. I will keep track of my weekly progress on my blog, reporting the challenges I will face and trying to create an introductory material that could help future newcomers.
RTEMS real-time operating system utilizes a stack checker to detect stack overflows during execution. While this feature is essential for system stability, the current error handler provides limited options for customization. This project aims to enhance the RTEMS stack checker by developing a configurable error handler. There are some features we are proposing that would help in making the stack checker more flexible and configurable, like enabling/disabling certain types of stack checking, giving the user the ability to set up a threshold for maximum allowable stack usage and performing some action based on how much stack is used relative to this threshold. In addition, we can rearrange the code so that we separate the stack checking functionality from the reporting functionality, which we believe will help to improve the code organization and readability
The proposal is about improving the QEMU emulator for the armv7 architecture on FreeBSD OS, it's goal is to get a simple C++ hello-world program to compile and run inside an armv7 jail hosted on an amd64 machine, using clang. To achieve this, about 32 syscalls need to be implemented for the qemu-bsd-user master branch, they are already implemented in the blitz branch, by the project mentor. The project is to add them to the master branch, perform testing and debugging of any errors, add them in a series of patches, each should pass the code review guidelines set up by QEMU developers. The solution starts by getting a stack trace of the syscalls that the compiler calls when using the blitz build of qemu-bsd-user, then compare them to the ones that succeed when using the master build of the qemu-bsd-user. Having done this, now we know which syscall are already added and those that are not. Now we proceed to add the missing ones, the project plan is included in the proposal. I will be delivering 32 patches to the qemu-devel mailing list, each one corresponding to a missing syscall.
<p>This project proposes to implement a thread pool inside perf, which could be used first to improve the existing parallelization in the synthetic threads and then to parallelize perf-report. Furthermore, the thread pool could be reused in future work in perf to efficiently implement new parallel portions.</p>
Network Block Device (NBD) is a protocol for exporting block devices, either between processes or across the network. Libnbd is a client library for talking to NBD servers. Currently, this library has bindings in various languages, including C, Golang and Python, but not in Rust. This project aims to make ergonomic Rust bindings for libnbd. The bindings should be automatically generated from the API of libnbd, so they will keep in sync as the library evolves. Apart from the actual bindings, several tests and examples will be created and good documentation will be written.
This project aims to rewrite the PJDFSTest suite. Today, the tests are written in a mix of shell script and C. This approach has provided some flexibility and usability, allowing to use syscalls within a shell environment. However, it also has disadvantages, the main ones being performance, code duplication and higher entry barrier for potential contributors. We want to improve the test suite, by switching to a unique language, Rust. Rust has numerous advantages, in particular, fearless multithreading, low-level handling and increased safety.
<p>This project proposes eBPF implementation for FreeBSD. It will have very basic functionality such as maps, interpreter, JIT compiler for x86-64 and character device + ioctl interface which is an alternative of Linux bpf(2). To introduce how it is useful, we will implement eBPF extension module for VALE software switch which can be used to write very fast middle box (firewall, load balancer and so on) easily.</p>
This project aims to build a complete end-to-end LiDAR perception pipeline for Automotive Grade Linux (AGL) using ROS 2 and the CARLA simulator by establishing a Hardware-in-the-Loop (HIL) architecture where CARLA generates LiDAR data on a host system, which is processed through a ROS 2-based perception pipeline and visualized on an AGL-powered Raspberry Pi via a Flutter-based HMI. The system will include a PCL-based LiDAR detection pipeline, real-time visualization interface, and a Yocto layer (meta-agl-lidar) for seamless integration into AGL builds. Deliverables include a ROS 2 perception node, Flutter HMI, RViz configuration, Yocto integration layer, and comprehensive documentation to enable reproducibility and adoption by the AGL community.
<p>I plan to package Kotlin 1.1.1 so that the android sdk tools packages that depend on Kotlin can finally be packaged. I am also planning on updating the other android sdk packages that are still in android 7.0.0.</p>
Problems to solve: - Porting and stabilizing Arduino CLI for FreeBSD - Fixing USB and serial communication workflows for reliable device interaction - Developing a unified CLI-based workflow for building, flashing, and monitoring devices Standardize device detection and access using FreeBSD’s /dev interfaces and devd. Address permission and driver issues, implement reliable serial port identification, and ensure stable communication for flashing and monitoring through tested configurations. Build a wrapper CLI that integrates Arduino CLI, ESP32 tooling, and serial monitoring into a single interface. Automate common tasks (build, flash, monitor), reduce manual setup, and provide a consistent developer experience with clear commands and documentation.
<p>The eBPF eXpress Data Path (XDP) allows eBPF programs to be run to filter received packets as early as possible, avoiding unnecessary processing overhead before the filter is run. The goal of this project is to extend an existing FreeBSD network driver (a virtual NIC like a VirtIO if_vtnet ) to be able to call into an eBPF program when processing a newly received packet. As in XDP the driver must PASS (accept and process normally), DROP, TX or REDIRECT the packet as specified by the program. eBPF helper functions and maps for aiding in packet filtering will also be implemented.</p>
<p>Using Ceph's JSON dump we can create a utility to help decipher whether or not a disk is safe to remove from within a Ceph cluster. Since Ceph shuffles placement groups when a disk is added or one dies then the user must be able to discern which disks are safe to remove. Using Ceph’s JSON output of a given cluster a user can be presented with an easy to understand representation of removable disks.</p> <p>This project consists of one main component, a standalone command line utility.</p>
This project aims to formally verify that the Rust vmm (a Rust implementation of the VirtIO specification used in virtualization platforms like QEMU) behaves correctly according to the VirtIO specification. The approach involves writing unit proofs for critical functions in Rust vmm and verifying them using Kani, a Rust-based bounded model checker. These proofs, which will be integrated into continuous integration (CI), will not only check correctness for all executions within a bound but also verify memory safety, especially in areas mixing safe and unsafe Rust. Community Benefits: 1. Increased trust in Rust vmm’s conformance to the VirtIO spec, benefiting all dependent projects. 2. Maintainable proofs using the Code-As-Spec paradigm, making them accessible to Rust vmm developers. 3. Demonstrates the practical value of formal verification for ensuring correctness in critical open source infrastructure.
<p>The project involves the task of enhancing the ipptool where I will be writing ipptool scripts in order to cover operations and attributes that are required by the IPP Everywhere standard and have not been yet tested by the IPP Everywhere Self-Certification process. Besides this I will be working on scripts for various other IPP Specifications for the developers.</p>
<p>Haiku is an operating system aimed at mainstream desktop users, it currently lacks a centralized preferences panel. This project proposes development of a shared control panel for all the preferences with its respective quick settings, and also a search bar for quick filter based on keywords.</p>
<p>Collaborate with Artifex to implement a resource efficient print function that bypasses common drivers found throughout desktop computers in order to maximize memory efficiency.</p>
The spdx-license-diff browser extension compares selected text on a webpage against the SPDX License List, showing the best matching license and a similarity percentage. The tool is currently broken in modern browsers due to Chrome’s Manifest V3 migration and Firefox compatibility issues. This project will restore compatibility, enhance its matching accuracy based on SPDX guidelines, improve the user interface and ensure accessibility compliance.
<p>Currently, if an incoming print job is a PDF file and the printer is not a PDF printer, the file will be rasterized and the converted to PWG/CUPS Raster. This is needed when the file contains vector graphics, etc. but is unneeded and can even produce bad interferences if each page is a simply a full-page bitmap (raster graphics). To reduce unnecessary computation, we can recognise such files (there is even an official file format, PCLm, which describes PDFs as full-page raster graphics), and extract the bitmap from each file and convert it to PWG Raster.</p>
<p>The purpose of this project is to build a convenient framework for managing ZFS boot environments in FreeBSD. Currently, boot environments are managed manually, or with scripts such as <code>beadm</code>. The approach that this project will take is to first create a boot environment library to offer simplified boot environment interaction to userspace applications (for example, TrueOS' SysAdm perhaps), and then write an application that provides users with a command that retains all of the features of <code>beadm</code>, with added functionality. Among the new features are: the ability to recursively create boot environments containing child datasets, the ability to activate an environment for the next boot only, and the ability to attach/detach a boot environment to a jail.</p>
<p>QEMU uses a single-threaded tiny code generator (TCG) which translates instructions of the guest ISA to instructions of the host ISA. These translated instructions are then executed on the host in an execution thread. For SMP guests, this single thread is scheduled to execute translated instructions of all the CPUs in a round robin manner. This is a significant performance bottleneck in utilizing all the available cores on the host machine. Multi-threaded TCG (MTTCG) project was started to solve this problem by designing and implementing a multi-threaded TCG. In this design, multiple threads are concurrently scheduled, and each thread executes the translated instructions from one guest CPU. Various consistency issues were identified in this design and the current work aims to solve them.</p>
<p>The aim of this project is to create a bot for Gerrit that would use haiku-format tool for checking whether the patch submitted follows the community guidelines of Haiku and post the report in the comments. The architecture will include the existing concourse CI and Gerrit review tool and their interaction using REST APIs.</p>
Intel™’s Advanced Configuration and Power Interface (ACPI) is an industry standard specification that revolutionized power management by putting it in the hands of the operating system, rather than the BIOS. As it currently stands, it is widely available across 32-bit and 64-bit architectures, with specially tailored manuals towards Windows™ and UNIX. FreeBSD has implemented ACPI, utilizing Intel™’s ACPI Computer Architecture (ACPICA). The major contention point is that it is outside the loader. In this state, it is inefficient; information that’s only available to ACPI, is therefore unavailable to the boot loader. As such, the boot loader essentially has to guess what that information is, and is often wrong. This proposal aims to alleviate this bottleneck by bringing a lightweight version of ACPICA into the loader. With this integration, ACPI will not only be more efficiently managed, but it will also be script-able with Lua, providing FreeBSD users ease of configuration. Deliverables include: (1) stand/efi/acpica/Osd/ with necessary ACPICA/AML initialization, (2) stand/efi/loader/arch/$ARCH for arm64 and amd64 specific glue code, (3) complete integration of both architectures: ACPI initialized in the loader, (4) the ACPI namespace enumerated in C, (5) an ACPI API layer, (6) Lua bindings, and (7) updated FreeBSD ACPI handbook and man pages.
<p>Goals: Design a dbus interface for the common print dialog(CPD). Switching over to a dbus interface for communicating to print backends would also make it more efficient, and easier to add new backends. Also, develop CUPS and IPP print backends for the CPD using the new CUPS API.</p>