Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters Clear
4718 Projects Found
Sort by

Beaglebone Black BSP Improvement

intermediate
RTEMS Project•2016Varies

Ready to Apply?

Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.

Start Proposal
Proposal Status
0% ProgressNot Started
Accepted Proposals
3 SimilarView →
Proposal Guide
Tailored DocsOpen →
Checklist & Review
Readiness AuditCheck →
175h (Medium)

<p>RTEMS is mainly designed for Real time applications, embedded systems that implements a single process, multi threaded environment. The project focuses on the improvements of the BSP for Beaglebone black that consists of development of various peripherals support like PWM,I2C,USB,SPI etc. Future task would be to fix the failing tests over Beaglebone Black as well as qemu. As Beaglebones are one the popular boards. So full BSP support will be significantly useful for developers to develop applications with RTEMS.</p>

cpythonembedded systems+5
Student: Punit Vara
Code
Proposal

Utilizing full power of RISC-V architecture via usage of RTEMS on top of SiFive FE310 processors

beginner
RTEMS Project•2017Varies90h (Small)

<p>This project aims to provide the RTEMS community with a new capability of utilizing the power of SiFive FE310 processors. The main objective of this project is to implement a simple board support package which will allow to switch tasks, to use console and clock drivers. The outcome of this project is an easy-to-use alternative POSIX-compliant real-time operating system for processors with a modern architecture. The outcome for the RTEMS community is a new processor architecture supported, which will bring new developers to the project.</p>

cpythonembedded systems+5
Student: Denis Obrezkov
Code
Proposal

NVMe SSD Driver Proposal

intermediate
KolibriOS Project Team•2024Varies175h (Medium)

NVM Express (NVMe), also referred to as Non-Volatile Memory Host Controller Interface Specification (NVMHCIS), is an open specification documenting how to access and control the computer's non-volatile storage media. Currently, NVMe drives have limited support in KolibriOS, and with their increasing popularity in newer computers, it is important that a driver conforming to the latest specifications is implemented. The project deliverables are to implement basic NVMe SSD driver written in FASM conforming to the NVMe base specification 1.4 and add namespace support.

cassemblyasm+2
Student: Abdur Rahman Mansoor
Code
Proposal

PAPPL API Bridging for Scanner Applications

intermediate
The Linux Foundation•2024Varies175h (Medium)

The PAPPL API Bridging for Scanner Applications project aims to extend the functionality of PAPPL by integrating the comprehensive scanner API. Building on previous work on eSCL scanning and SANE retrofitting, the project plans to complete the development of a wrapper API that supports scanner applications within PAPPL. This entails creating a fully functional Scanner Application prototype, similar to setting up Printer Applications. Additionally, this project aims to explore the potential of IPP Scanning and extend functionality to support efficient document management and data extraction.

cpythonmysql+7
Student: Akarshan Kapoor
Code
Proposal

KDE Print Manager vs. CUPS 3.x

intermediate
The Linux Foundation•2025Varies175h (Medium)

The KDE Print Manager, a critical component of the KDE desktop environment, requires updates to support the advancements introduced in CUPS 3.x. This project aims to modernize the Print Manager by enabling compatibility with CUPS 3.x while maintaining backward compatibility with CUPS 2.x. The focus will be on incorporating support for IPP (Internet Printing Protocol) print destinations, which allow users to print to driverless network printers, IPP-over-USB printers, and Printer Applications without the need for traditional CUPS queues or PPD files.

cpythonmysql+7
Student: Tarun Srivastava
Code
Proposal

HD Audio device model in userspace for bhyve

intermediate
FreeBSD•2016Varies175h (Medium)

<p>The bhyve hypervisor does not have any sound card emulation at the moment. This project is proposed by Peter Grehan and aims to implement the High Definition Audio Specification which is one of the best performant and supported device in the nowadays operating systems. Some of the reasons to have this device are: support for multiple input and output streams, up to 16 channels per stream, command-response codec communication, DMA channel for each stream and it is interfaced with the PCI bus. The main goal is to have a functional implementation by the end of the summer that will allow playing sounds inside a bhyve virtual machine.</p>

c/c++llvmshell script+4
Student: Alex Teaca
Code
Proposal

Hardware virtualization for Haiku’s QEMU port

intermediate
Haiku•2024Varies175h (Medium)

QEMU is a virtual machine which allows running an operating system inside of another. While there already is a Haiku port, it currently does not support any acceleration system through native virtualization (through Intel VT-x and AMD SVM.) This makes it too slow for many uses. Fixing this would allow Haiku users to run another system, such as Windows or Linux, when they need to run an application that is not yet available for Haiku. This would make using Haiku as their primary operating system a viable approach for more people. This project aims to port NVMM's virtualization driver and library to Haiku, so that QEMU can support virtualization acceleration on Haiku.

c++posixffmpeg+6
Student: Daniel Martin
Code
Proposal

USB Device Redirection for qemu-rdp

intermediate
QEMU•2026Varies175h (Medium)

Implement MS-RDPEUSB protocol (client & server) in IronRDP with libusb backend and qemu-rdp integration. The goal of this project is to add USB device redirection support to IronRDP, the Rust implementation of the Remote Desktop Protocol. This enables client-attached USB devices (webcams, scanners, security keys, etc.) to be transparently accessed by applications running on the remote server. MS-RDPEUSB is a Dynamic Virtual Channel (DVC) extension that provides low-level USB packet redirection. Unlike high-level device redirection (like file system or audio), USB redirection transfers raw USB packets, allowing any USB device to work remotely without device-specific driver support on the client.

cassemblykvm+4
Student: uchouT
Code
Proposal

Netlink Payload Decoding Infrastructure for FreeBSD Tracing Tools

intermediate
The FreeBSD Project•2026Varies175h (Medium)

This project improves Netlink support in FreeBSD tracing tools by enabling structured decoding of Netlink message payloads. Currently, truss(1) shows raw hexadecimal output for Netlink calls, making it difficult to interpret structured Netlink messages used by subsystems such as pf . The project will implement decoding within libsysdecode by parsing Generic Netlink headers (genlmsghdr), safely iterating over Type-Length-Value (nlattr) attributes, and dispatching to family-specific decoders. Deliverables include Generic Netlink support, a bounds-safe TLV parsing engine, a modular dispatch framework, and at least one functional decoder (pf), enabling human-readable output and providing a scalable foundation for future Netlink decoding.

c/c++llvmassembly+5
Student: IshanAgrawal
Code

GNOME Control Center: Finalizing the New Printing Architecture for GNOME

intermediate
The Linux Foundation•2024Varies175h (Medium)

The latest CUPS 3.x versions exclusively support driverless printing through the new IPP everywhere architecture. Modern printers now predominantly utilize driverless technology and support IPP printing, automatically configured by CUPS. Unlike traditional setups, these modern IPP printers do not require a permanent print queue. However, a significant number of printers still rely on drivers (PPD + filter). As a result, the Genome Control Center needs to be adapted to accommodate both driver and non-driverless printers. While substantial progress has been made in this direction, there remains a considerable amount of work to be done before this new concept can be released with GCC. The project aims to complete all remaining tasks while providing a user-friendly UI for GCC printers, refining all aspects for release

cpythonmysql+7
Student: Kaushik Vishwakarma
Code

Videoconvert plugin for PipeWire

advanced
X.Org Foundation•2023Varies350h (Large)

Sharing video buffers via PipeWire requires at the moment consumers and producers to provide a common capability set of buffer type, buffer format and in case of hardware buffers drm\_modifier. To mitigate mismatch issues, the goal is creating a PipeWire plugin, similar to the existing audioconvert one, using vulkan as the underlying technology for efficient video format conversions on hardware buffers and optional downloads to system memory. This approach allows producers to focus solely on the most efficient buffer type and format, removing the necessity to provide a fallback to system memory buffers, or its own rendering capabilities, while consumers on the other hand get increased compatibility and don't have to support any possible format. This eases the development of a working PipeWire client, making it possible to implement support for a wider range of formats and more advanced features later.

copenglc+++5
Student: columbarius
Code
Proposal

Full Disk Administration Tool for FreeBSD

intermediate
The FreeBSD Project•2025Varies175h (Medium)

FreeBSD currently lacks a tool to manage partitions and manipulate file systems like GParted does in Linux. The proposed project aims to use sade, a FreeBSD TUI tool that allows creation, modification, and deletion of partitions with UFS, ZFS, FAT16, and FAT32 filesystems, as a starting point to develop a new tool. This project will add operations like copying/pasting, moving, resizing, and checking partitions with different file systems, like the ones that are already supported as UFS, FAT16, and FAT32. As well as adding the same support for new filesystems like EXT2, EXT3, EXT4, exFAT, and NTFS. Another set of FreeBSD exclusive operations is labeling and encrypting partitions using the GEOM framework. Finally, the tool would handle ZFS too: creating pools, configuring mirrors, raids, and replacing disks.

c/c++llvmassembly+5
Student: Braulio Rivas
Code
Proposal

SDL2 Port for KolibriOS

intermediate
KolibriOS Project Team•2024Varies175h (Medium)

SDL is a free cross-platform multimedia library that implements an interface to graphics, sound and input devices. This library is actively used when writing cross-platform graphical applications (mostly games). The previous version of the library, SDL 1.2, is already ported for KolibriOS, but there is no SDL 2 port, which is the most up-to-date and supported version. Having support for SDL 2 in KolibriOS will not only allow developers to develop new applications using the updated functionality of the library, but also to port a huge number of existing open source programs (mostly emulators and games) from other platforms, because SDL 2 is often used to implement frontend/graphics in such applications. This will also allow to completely deprecate the current SDL 1.2 library as we can use a compatibility layer for applications relying on SDL 1.x.

cassemblyasm+2
Student: arnavbhatt288
Code
Proposal

Engineer a Feature Complete Port of Intel’s igt-gpu-tools for FreeBSD

intermediate
The FreeBSD Project•2022Varies175h (Medium)

Intel’s igt-gpu-tools serves as a generic testing suite for drm drivers on Linux. The igt-gpu-tools suite is seperated into tests and tools where tests are the primary focus of the project. These tests target the kernel API: specifically kms, memory management, and command submission. This low-level reporting allows for transparent tracking of kernel changes and efficient debugging. Development of igt-gpu-tools shifted in 2019 to focus on generic kms-driven tests. The vendor-agnostic foundation of kms allows for igt-gpu-tools to function on a wide range of hardware. This versatility makes igt-gpu-tools extremely helpful when developing and debugging new drm drivers. Porting the project to FreeBSD could introduce greater stability in future releases of FreeBSD’s LinuxKPI-driven drm drivers.

c/c++llvmassembly+5
Student: Jake Freeland
Code

TCP/IP Regression Test Suite

intermediate
FreeBSD•2016Varies175h (Medium)

<p>Regression testing is one of the most critical elements of the test artifacts and proves to be one of the most preventive measures for testing a software. Currently, within FreeBSD, there is no such tool to perform regression testing of the TCP/IP network stack. The purpose of this project is to develop tests using a regression testing tool which can then be integrated with FreeBSD. The wire level regression test suite will exercise various states in the TCP/IP protocol suite, with both IPv4 and IPv6 support. Once integrated, the tool will also facilitate further development of such tests. The regression testing tool of choice here is Packetdrill. Packetdrill currently supports testing multiple scenarios for TCP/IP protocol suite within Linux. The existing Linux test suite implemented within Packetdrill will provide a basis for understanding, and implementation of the FreeBSD test suite.</p>

c/c++llvmshell script+4
Student: Shivansh Rai
Code
Proposal

Improving and Extending Services Kit

intermediate
Haiku•2020$3k–$6.6k175h (Medium)

<p>Services Kit is the backbone of many Internet-based applications on Haiku such as Weather, HaikuDepot, WebPositive and more... This makes the kit one of the more important components in the system, as the majority of the user experience on Haiku is dependent on this kit.</p> <p>However, Services Kit is not without any issues. It's <a href="https://dev.haiku-os.org/ticket/10748" target="_blank">slow by design</a>, doesn't support HTTP/1.1 (which also contributes to the slowness), and may <a href="https://dev.haiku-os.org/ticket/13235" target="_blank">randomly crash on you</a>. All of which don't translate to a decent user experience.</p> <p>My project this GSoC is to dig into Services Kit, iron out annoying bugs, getting rid of the bottlenecks, adding some more features, like FTP support and give it some better documentation so that people outside of the project can make good use of the kit.</p>

c++posixffmpeg+6
Student: leorize
Code
Proposal

Zero-cost conditional execution mechanism

intermediate
The FreeBSD Project•2024Varies175h (Medium)

It is common for kernel subsystems to conditionally include functionality, based on compile time and runtime configurations which are relatively infrequently subject to change. Typical examples include: toggling of DTrace probes, boot- time optimizations based on hardware capabilities and inclusion of additional security checks. This is often done by examining the state of a global flag and executing a block of code conditionally based on that state. When this is done in a ”hot” (i.e. frequently executed) code path, the overhead of the conditional execution can become significant. Moreover, in situations in which the state of the inspected flags changes rarely, most of the performed checks are redundant. The primary goal of this project is to design and implement a low overhead mechanism for conditional execution in contexts in which the branching condition does not change often. The mechanism will be based on runtime code patching of instructions. The second major goal is applying the developed mechanism to an existing block of kernel code.

c/c++llvmassembly+5
Student: MarkoVlaic
Code
Proposal

Flattening non-static content (like filled forms) in PDF files for printing

intermediate
The Linux Foundation•2017Varies175h (Medium)

<p>At present, CUPS filter does not support printing the PDF files with dynamic form content. The dynamic form content includes digitally filled forms, tax forms or any kind of registration forms. When the user tries to print the PDF with filled forms, the content either gets vanished or is not displayed properly. CUPS uses a filter named pdftopdf to handle printing of PDF forms. This filter performs some manipulations on PDF file before printing it. These manipulations results into content loss of filled forms. This project aims at adding PDF form flattening support to pdftopdf filter of CUPS wherein, the filter will identify whether the PDF files contains dynamic content or not and if yes, then it will first convert the PDF into static content and then perform its manipulations. It includes adding the actual functionality in QPDF, a library that is internally used by pdftopdf filter for PDF file processing. And then using this functionality of QPDF library to perform the flattening work by the pdftopdf filter.</p>

cpythonmysql+7
Student: Pranjal Bhor
Code

A sandboxing tool for virtiofsd

advanced
QEMU•2023Varies350h (Large)

Virtiofs is a shared file system that lets virtual machines access a directory tree on the host. Unlike existing approaches, it is designed to offer local file system semantics and performance. Currently, virtiofsd integrates the sandboxing code and the server code in a single binary. The goal is to extract that code and create an external tool that creates a sandbox environment and runs virtiofsd in it. This will make it easier to develop sandboxing features and virtiofsd side by side. In addition, that tool should be extended to be able to run virtiofsd in a restricted environment with Landlock. Landlock is a Linux kernel module that allows unprivileged processes to restrict their own access rights. This will enable the tool to apply access restrictions to virtiofsd without requiring privileged access, in a way that is enforced by the kernel, thereby increasing the protection of virtiofsd users. This will allow greater flexibility when integrating virtiofsd into a VMM or running it inside a container, due to how Landlock enforces access restriction rules as composable security layers that are compatible with system access controls.

cassemblykvm+4
Student: Christopher Acosta
Code
Proposal

Porting amd64 libc SIMD enhancements to arm64 (aarch64)

advanced
The FreeBSD Project•2024$6k–$13.2k350h (Large)

This Google Summer of Code (GSOC) project aims to improve the performance of the libc string manipulation function of the FreeBSD operating system on ARM-based systems (aarch64 architecture). The focus is on porting existing SIMD (Single Instruction Multiple Data) optimizations from the amd64 libc library to arm64, enabling FreeBSD to take full advantage of the NEON instruction set and laying the groundwork for future SVE support. This work builds upon previous SIMD enhancements done by Robert Clausecker <fuz@FreeBSD.org> for amd64. Deliverables include: Introduce a new ARCHLEVEL flag for the aarch64 architecture, allowing selection between base, NEON, and SVE instruction set extensions. This will involve creating an `aarch64_archlevel.h' header file to manage the different levels of architectural support. Update the `simd(7)' manual page to document the new SIMD-accelerated string functions for aarch64, including details on the ARCHLEVEL flag and its usage. And port the functions with already existing SIMD implementations for amd64 to aarch64. A full list of those functions are available at /src/lib/libc/amd64/string

c/c++llvmassembly+5
Student: getz
Code

Debusine: debuginfod server

intermediate
Debian•2026Varies175h (Medium)

This project implements a debuginfod-compatible server within Debusine to provide automated debug symbol resolution for Debian developers. Currently, debugging binaries built by Debusine requires manual installation of -dbgsym packages. This project aims to eliminate this manual labor by allowing tools like gdb to fetch symbols automatically via HTTP. Based on an analysis of the elf_classify logic in elfutils, I have designed and prototyped a pipeline that identifies and extracts .debug ELF files from -dbgsym.deb packages and parses their Build-IDs. The implementation integrates this extraction into the isolated sbuild worker task. These symbols are then indexed as debian:debug-symbol artifacts and served via a custom Django view that supports the buildid/<id>/debuginfo and executable endpoints, including HTTP Range requests for partial content. Key Deliverables: 1) An isolated extraction pipeline using pyelftools within the sbuild task. 2) A Django-based artifact storage and indexing model (debian:debug-symbol). 3) debuginfod-compliant HTTP endpoints (/debuginfo and /executable) with support for mandatory headers and 206 Partial Content. 4) Documentation and integration tests for gdb symbol resolution.

pythonjavascriptc/c+++8
Student: Jugal59
Code
Proposal

Physical memory anti-fragmentation mechanisms

advanced
The FreeBSD Project•2023Varies350h (Large)

The use of superpages in modern hardware and operating system yielded important performance benefits. Unfortunately, allocating superpages can often fail due to a high rate of external fragmentation in physical memory. Thus external physical memory fragmentation in modern operating systems has once again become a serious issue. This project aims to design and implement several anti-fragmentation mechanisms for the FreeBSD kernel. At the time of writing, the FreeBSD kernel has no memory compaction mechanisms or any way of quantifying physical memory fragmentation. The first major goal is implementing several fragmentation metrics for the page allocation code. The second major goal is designing and implementing a runtime physical memory compaction mechanism. When invoked, this mechanism would identify sparsely populated and fragmented physical memory regions and rearrange the pages to eliminate any "holes" in the region. Aside from explicit invocation, a background daemon would monitor the relevant fragmentation metric and trigger the memory compaction mechanism should the value drop below a certain threshold. The last goal will introduce a passive anti-fragmentation mechanism for the demand paging mechanism. The key idea is to enhance the page placement code to use contiguous spans of pages instead of allocating random pages.

c/c++llvmassembly+5
Student: Bojan Novković
Code
Proposal

NetFPGA SUME FreeBSD device driver

intermediate
The FreeBSD Project•2020Varies175h (Medium)

<p>NetFPGA is an open-source project aimed to foster networking hardware prototyping. Their latest and de-facto standard development board is NetFPGA SUME with a Virtex-7 FPGA and 4 SFP+ (10 Gbps) ports. The board’s open-source repository includes 14 designs: 'reference' projects to be used as a first step to building customized NICs, switches, routers, etc., as well as community member contributed projects. The NetFPGA software ecosystem, including the device drivers, is unfortunately Linux-centric, with no support for FreeBSD.</p> <p>This project will enable using NetFPGA SUME as a 4x10 Gbps NIC on hosts running FreeBSD. There are already FreeBSD drivers for older (now obsolete) versions of NetFPGA 10G (if_nf10bmac(4)) and NetFPGA 1G (<a href="https://github.com/wkoszek/freebsd_netfpga" target="_blank">https://github.com/wkoszek/freebsd_netfpga</a>), both incompatible with the SUME board but could provide some valuable insight. Writing a device driver on top of the iflib(9) framework should inherently provide support for netmap(4), which would enable high-speed traffic exchange between (custom) NetFPGA designs and userspace network applications, paving the way for experimentation with new hardware / software network processing paradigms.</p>

c/c++llvmassembly+5
Student: denisSal
Code
Proposal

Make a native printer Application from Gutenprint

advanced
The Linux Foundation•2024Varies350h (Large)

Abstract - Gutenprint is a high-quality printer driver for a wide range of inkjets, especially Epson and Canon, dye-sublimation printers and even monochrome PCL laser printers. It does not only cover many printers to give them support under Linux and free software operating systems at all, but also is optimized for highest possible print quality, so that at least on some printers and with the right settings you can even get better print quality than with the original (Windows/Mac) drivers. Right Now We only have retrofitting application that supports gutenprint so we need Native Gutenprinter application. Solution to the Problem - Here We create a native printer applcation by using pappl and libgutenprint library. Here on an incoming get-printer-attributes IPP request we call the same functions which the PPD generator calls, but instead of translating the responses into a PPD file we translate it into the IPP answer for the get-printer-attributes request. And when we have a job to print, we call the library functions which the filter calls, but directly. My task to implement above is - - Create a PAPPL-based Printer Application using the libgutenprint library and PAPPL - Make sure all options and parameters of the Gutenprint driver are accessible from the Printer Application's web admin interface. - Package the Printer Application as a Snap Deliverables - My goal is to deliver a native printer application from Gutenprint. It uses pappl and libgutenprint for performing all the tasks of Printer Application.

cpythonmysql+7
Student: Ankit Pal Singh
Code
Proposal
Showing 1369 - 1392 of 4718 Projects
5657585960
Proposal
Proposal
Proposal
Proposal
Proposal