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
5976 Projects Found
Sort by

DuckDB Backend for Martin TileServer

intermediate
OpenStreetMap•2026Varies

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)

This project aims to provide first-class DuckDB support for Martin TileServer. DuckDB, with its spatial extension and native ST_AsMVT and and ST_AsMVTGeo functions, enables efficient vector tile serving directly from analytical file-based datasets such as GeoParquet. With PostGIS, this is not possible since it’s a transactional database and not suitable for reading analytical columnar datasets. Martin currently has support for PostGIS tables and views as well as file formats such as MBTiles and PMTiles to build and server vector tiles. This project will extend Martin’s architecture to DuckDB and provide support for persistent DuckDB databases with spatial tables as well as local and remote GeoParquet files.

javascriptjavaopengl+10
Student: ManbhavSugla
Code
Proposal

Add new math.h and complex.h functions as built-ins.

advanced
GNU Compiler Collection•2019Varies350h (Large)

<p>GCC has support for built-in functions in C99/C11 standards along with features of IEEE standards. These functions do appropriate calculations according to the requirements of the users taking various types of arguments and returning values as required on supported data types of GCC like int, float. Such inbuilt functions help users, developers and GCC developers to minimize the repetitive calculations and efforts. There are optimization steps carried out to have faster compilation and running time of programs, folding and inlining being one of them. The purpose of this project is to implement more such functions in GCC which are added in ISO/IEC TS 18661 (supporting features of IEEE 754), folding them and expanding them inline wherever appropriate.</p>

c/c++gnu autotools
Student: Tejas Joshi
Code
Proposal

OpenMRS GSOC-21 Proposal

intermediate
OpenMRS•2021$3k–$6.6k175h (Medium)

<p>The aim of the project is to implement improve/fix security issues in various OpenMRS Modules. This proposal presents my timeline of the corresponding Action items and answers during GSoC 2021. Security plays a pivotal role to protect users against unintended security breaches and attacks. A polyglot webapplication like OpenMRS has multiple modules written by multiple developers, and the OpenMRS security team has identified potential security issues. Thus it is paramount to ensure that the identified security issues among various Modules are fixed timely. Through this project proposal I present my timelines and work action items with focus on fixing on those identified issues, ultimately ensuring the safety of OpenMRS users.</p>

javahtml5groovy+11
Student: Parth Kanakiya
Code
Proposal

Improving the OpenMRS Developer Experience: Updating the SDK

intermediate
OpenMRS•2023Varies175h (Medium)

This project aims to improve the OpenMRS SDK to better support the evolving needs of OpenMRS development. The project objectives include spinning off a version of the SDK to support OpenMRS 1.x releases based on Java 7, upgrading the SDK to take advantage of Java 8 features, and improving the documentation system for all plugins. Additionally, the project seeks to rework the build-distro and setup commands to allow for per-version customizations, such as producing Docker images based on different versions of Java depending on the OpenMRS version. By achieving these objectives, the updated SDK will provide better support for newer versions of OpenMRS while maintaining a legacy interface for existing features.

javahtml5groovy+11
Student: wikumC
Code
Proposal

Edit-Mesh Mirror Improvements

intermediate
Blender Foundation•2025Varies175h (Medium)

This project addresses Blender’s edit-mode mirror limitations by enhancing its functionality to support multiple axes and operators. It will enable artists to edit symmetrically without relying on workarounds like deleting half the model to apply a mirror modifier which is a method impractical for nearly finished models and incompatible with shape keys, which require actual vertex positions rather than modifier-driven symmetry. I’ll analyze the transformation system, refine the mirroring utilities, and extend support to operators that do not support mirroring. The deliverables include these enhancements, detailed documentation for users and developers, and a set of tests to ensure consistent operation. This will make symmetrical modeling more efficient for artists.

cpythonopengl+3
Student: Tariq
Code
Proposal

ExtX File System Improvement

beginner
KolibriOS Project Team•2026Varies90h (Small)

This project improves the file system driver of KolibriOS, specifically for extX file systems. Currently, the driver only supports 1 INCOMPAT feature fully implemented for R/W, and 2 for R. And can only guarantee reading and writing to ext2 filesystems. My primary goal is to achieve read/write support for modern ext4 file systems by implementing the remaining key INCOMPAT then RO_COMPAT features, and write support for the two currently implemented INCOMPAT features that are missing it. If time permits later, I might start in the simple action of recovery in case the file system was not safely unmounted, providing a simple foundation for future contributors (or me) to fully complete this huge and useful feature.

cassemblyasm+2
Student: Mathieu Morcos
Code
Proposal

Implementing backward bounded model checking in CPAchecker

advanced
Software and Computational Systems Lab at LMU Munich•2023Varies350h (Large)

Backward bounded model checking is a technique for program analysis that aims to solve the error location reachability problem by searching for execution paths from an error location to the initial location and determining their feasibility, whereas regular forward techniques search for paths from the initial location to an error location. The main aim of this project will be to formulate the backward bounded model checking algorithm within the framework of CPA and develop an implementation in CPAchecker. This will also require figuring out which components already provide support for backward analysis in CPAchecker and developing support where it does not already exist. Once backward analysis is supported and the algorithm is implemented, it can be tested and benchmarked on a set of programs to evaluate its performance.

pythonjavascriptjava+2
Student: Bas Laarakker
Code

Generalized graphical data rendering representation

intermediate
Graphite•2026Varies175h (Medium)

This project refactors Graphite to create a more generalized graphic representation of paints. It introduces dedicated Gradient and Pattern nodes, as well as updated Fill and Stroke nodes that can consume generalized graphic sources, not just the current fill and color types. The project also enables the standalone rendering of colors, gradients, patterns, and other compatible graphics as ordinary layers. The implementation will update Graphite's graphics, nodes, and Vello/SVG renderers to support gradient strokes and pattern fills. Additionally, SVG import will be supported for the MVP subset of these features. Stretch goals include broader gradient support, such as focal points, conic gradients, and gradients along strokes.

machine learningrustvulkan+2
Student: Yohei Yamasaki
Code
Proposal

Drop-in replacement for vscode-json-languageservice

intermediate
JSON Schema•2026$3k–$6.6k175h (Medium)

vscode-json-languageservice, the library powering JSON editing in VSCode currently supports only JSON Schema draft-07. The architectural coupling between its validator and editor features means draft support cannot be extended by simply swapping the validator. This project aims at building a drop-in replacement that matches the exact API surface of vscode-json-languageservice while replacing the validator with @hyperjump/json-schema, bringing full support for draft-04 through draft-2020-12. By the end of GSoC, all 13 features of the existing library will be implemented and tested, backed by a MatchingSchemaCollector EvaluationPlugin as the core data layer, a working VSCode extension, and a test suite verifying drop-in compatibility with the existing implementation.

pythonjavascripttypescript+2
Student: srivastava-diya
Code
Proposal

Enable cross-talk between Python and C++ kernels in xeus-clang-REPL by using Cppyy

intermediate
CERN-HSF•2023Varies175h (Medium)

xeus-clang-REPL is a C++ kernel for Jupyter notebooks using clang-REPL as its C++ Interpreter. Cppyy is an automatic, run-time, Python-C++ bindings generator, for calling C++ from Python and Python from C++. Allowing C++ and Python to talk between themselves in a Jupyter notebook will allow users to switch between Python and C++ at will. This means that data analysts can set up their analysis in Python while running the actual analysis in C++. Thus reducing the time to write and debug their analysis pipeline. Initial support of cross talk between the two kernels has been implemented but this only supports passing primitive data types. This project aims to use Cppyy to extend this to support classes and functions.

pythonc/c++machine learning+6
Student: Smit Shah
Code
Proposal

Kart CLI Help Improvements

intermediate
Kart Project•2022Varies175h (Medium)

Kart currently makes use of a CLI tool built using Click for supporting their CLI users as they interact with the commands and the data in their repositories. This project aims to improve the experience of the CLI users of Kart by creating a maintainable framework for generating and distributing man pages with Kart and also provide tab completion for Kart commands, sub-commands, options and also user-specific datasets, branches, tags, files, metadata, features, and other context-relevant information. To support the GIS developers using Kart across all the different platforms the shell completion and man-style pages are designed to be cross-platform as much as possible, supporting bash, zsh, fish and more including PowerShell on Windows.

pythonc++git+1
Student: Amal Thundiyil
Code
Proposal

Cluster API Provider GCP

Intermediate
•Varies175h (Medium)

Cluster API Provider GCP (a.k.a. CAPG) enables the creation of Kubernetes clusters in GCP with Cluster API. Currently the clusters it creates do not support running workloads in them that take advantage of GPUs and so this rules out things like highly performant machine learning and computational heavy work workloads. We want to enhance CAPG so that it supports GPUs so that users can run these type of workloads. This will require creating a proposal for the change (i.e. design work) and then implementing the propsal which may include changes to the api/controllers, base images and driver installation. Expected outcome: This work will enable CAPG to support the creation of Kubernetes clusters where workfloads can take advantage of GPUs.

TBA
Proposal

Upgrade the documentation system to git-based system

intermediate
FreeCAD•2023Varies175h (Medium)

The project aims to migrate the FreeCAD documentation system to a file-based, versioned system based on Git and Markdown so that it supports multiple languages for users globally and allows switching between offline and online versions. The current system is at constant risk of losing data due to the MediaWiki software used to support it. The project involves community interaction to research solutions and then upgrade the entire system to new software. The completion of the project will result in a better documentation system for the FreeCAD software that is robust and supports version control. It will also allow the user to download, or pack, the entire FreeCAD documentation to be able to access it on a machine with no internet connection, which is the goal of switching from MediaWiki to a file-based solution.

pythonc++qt+2
Student: Gauri_Maheshwari
Code
Proposal

Modernize Data Fetching API with TanStack Query

beginner
Plone Foundation•2023Varies90h (Small)

The objective of this proposal is to implement a new data fetch layer for frontend in Plone CMS. I intend to implement a library “@plone/client” that will work as a client for “plone.restapi”, using Tanstack Query. This client will enable Plone to move away from the “AsyncConnect” data fetch layer that is based on Redux. Then Redux can be used as the application-level data store only. TanStack Query brings many benefits with it, like caching support, de-duplication of queries, cancellation, refetch, easy-to-use hooks, SSR support, and more. A modern API client should use these features fully. The primary goal of this client is to be robust, yet flexible enough to support all use cases, and be easily extensible.

pythonjavascriptrest+4
Student: Hemant Chaudhary
Code
Proposal

SAFECode’s Memory Policy Hardening

intermediate
LLVM Compiler Infrastructure•2016Varies175h (Medium)

<p>Monolithic kernels, like linux, did not provide a hardening mechanism on the kernel modules’ memory access. Modules in Linux could do almost everything. Arbitary write and read may cause system crash, information leak, and even rootkit injection. There is a great need to implement a memory hardening mechanism to limit the behavior of a kernel module.</p> <p>This projects will enhance the ‘Baggy Bounds with Accurate Checking’ (BBAC). By adding information to the memory object’s padding area, we can perform various safety checks with limited overhead. I will mainly focus on providing runtime access policy hardening. This work will prevent most of illegal memory accesses efficiently.</p>

cllvmc+++3
Student: Zhengyang Liu
Code
Proposal

Add OpenMAX state tracker in Mesa/Gallium that uses Tizonia

advanced
X.Org Foundation•2017Varies350h (Large)

<p>Currently the OpenMAX state tracker in Mesa/Gallium uses. Bellagio has not been updated for a few years and only supports the OpenMAX IL 1.1 specification while the latest OpenMAX specification version is 1.2. The main aim of the project is to provide a new state tracker that conforms to the latest OpenMAX 1.2 specifications using Tizonia. Tizonia is actively maintained and also up to date with latest OpenMAX IL 1.2 provisional specification. This project is a step towards completely replacing the old bellagio state tracker. In addition to that the project would also be focused on enhancing the performance of the new state tracker by adding support for reference frame management (optional) and adding support of OMX_UseEGLImage.</p>

copenglc+++5
Student: Gurkirpal Singh
Code
Proposal

Eclipse ThreadX Getting Started: A Modern Board Enablement Framework

intermediate
Eclipse Foundation•2026Varies175h (Medium)

Eclipse ThreadX powers billions of devices, yet its developer onboarding experience is hindered by legacy Azure IoT dependencies and limited board support (currently only the MXChip AZ3166). This proposal aims to solve this by creating a modern board enablement framework that extends the existing IoT DevKit architecture to support three distinct evaluation boards: two from STMicroelectronics and one RISC-V target. The project will deliver complete Board Support Packages (BSPs) featuring use-case-driven demo applications that exercise real RTOS primitives, alongside comprehensive documentation, CMake build infrastructure, and Renode virtual hardware emulation scripts to allow community contributions without physical hardware.

c/c++javageospatial+15
Student: Ali Eissa
Code

Enhanced Strategy Functionality for PRISM

advanced
PRISM Model Checker•2016Varies350h (Large)

<p>Prism is a probabilistic model checker, by which, the users can model and analyse real time systems. Prism provides its own modelling language. A user can model a system using this language, see a graphical representation of the model and check the behaviour of the model against the optimal strategy (adversary).</p> <p>The aim of the project is to enhance the support for strategies, which will enable more flexible/complex types of strategies/checks which are currently not supported. It will also allow the users to visualize the behaviour of the optimal adversary in a more user-friendly way, and to modify it and re-check with the model. And it will enhance the support for the features like exporting, importing and re-verification of strategies, which are already available in the tool, but not with full functionality.</p>

javac++
Student: Ganindu
Code
Proposal

EDGAR-crawler 2.0: Enhancing Information Extraction of Company Reports

intermediate
Open Technologies Alliance - GFOSS•2024Varies175h (Medium)

This project aims to expand the information extraction capabilities of the EDGAR-crawler, a project which allows users to download different types of company-published reports on the SEC managed platform EDGAR. More specifically, the project will add support for the 10-Q and 8-K report types. Additionally, it is planned to explore the possibilty of using large language models in order to automatically create regular expressions to support the current workflow in two ways: First, when an already supported extraction mechanism is facing a report with structural errors, using automatic regex generators could fix the problem online. Second, using this technology would allow for the addition of many more report types to the crawler much more quickly than if it were done manually.

pythonmysqljava+7
Student: Fabian Billert
Code

Implement group chats in Moxxy

beginner
XMPP Standards Foundation•2023Varies90h (Small)

Group chats are an integral component of instant messaging clients used in everyday communication. However, Moxxy, currently lacks support for group chats. Hence, the objective of this project is to incorporate basic group chat functionality into Moxxy by integrating MUC support (XEP-0045) into the underlying Moxxmpp library. The proposed solution aims to be highly extensible, allowing for easy integration of future feature additions. The deliverables of this project include the addition of XEP-0045 support to Moxxmpp, along with basic MUC features such as joining and leaving rooms, sending messages, and changing nicknames, among others. By implementing these features, users of Moxxy will be able to enjoy group chat functionality, which is essential for effective communication.

javascriptjavac+++10
Student: Ikjot Singh Dhody
Code
Proposal

Port WasmEdge and WASI-NN ggml backend to s390x (2025 Term 2)

Intermediate
•Varies175h (Medium)

WasmEdge provides cross-platform support for amd64 and arm64 for executing AI/LLM applications. We would like to support as many new hardware platforms as possible, so developers and users will no longer need to worry about the actual hardware. All they need to do is develop their AI agent or LLM applications once and deploy their services anywhere. For more information, please check the upstream issue. Expected Outcome: 1. Make the WasmEdge toolchain support the s390x platform, including the interpreter and the AOT mode. 2. Ensure the WASI-NN ggml plugin can execute without any issues on the s390x platform. 3. Implement test suites to verify the above behaviors. 4. Write a document discussing the compilation, installation, execution, and verification of the work.

TBA
Proposal

Text-Extraction Libraries

intermediate
Xapian Search Engine Library•2020$3k–$6.6k175h (Medium)

<h3>Project: Text-Extraction Libraries</h3> <p>Currently, Omega has support for various file formats such as .htm, .html, .pdf, .csv etc. This project will focus on adding functionality for various other file formats to Omega.</p> <ul> <li>The project is based on adding support for extracting data from various file formats using some external filters or shared libraries. </li> <li>There has already been a <a href="https://trac.xapian.org/wiki/GSoC2019/TextExtraction" target="_blank">GSoC 2019 project</a>, which defined a way to safely use external libraries.</li> <li>This project will be built on top of this and proposes to add support for various other file formats.</li> </ul>

androidc++golang+3
Student: Parth Kapadia
Code
Proposal

GNOME Control Center: Finalizing the New Printing Architecture for GNOME

intermediate
The Linux Foundation•2025Varies175h (Medium)

The latest CUPS 3.x versions support only driverless printing through the new IPP Everywhere architecture. Modern printers predominantly use driverless technology, supporting IPP printing and automatically configuring themselves via CUPS. Unlike traditional setups, these IPP printers do not require a permanent print queue. However, many printers still rely on drivers (PPD + filter). To address this, the Genome Control Center (GCC) must be adapted to support both driver-based and driverless printers. While significant progress has been made, substantial work remains before this new approach can be fully integrated into GCC. The project aims to complete all remaining tasks, ensuring a seamless user experience for GCC printers while refining all aspects for the final release.

cpythonmysql+7
Student: K_V
Code

Android App Improvements

intermediate
Amahi•2019Varies175h (Medium)

<p>Amahi is a personal/Home server media software with the support of mobile apps and other devices that allow us to stream and access all types of media files present in our own servers (also called as HDAs). Currently, the android app works great, but there’s a lot of scope to improve it. This project mainly focuses on improving the following areas of the app:</p> <ol> <li>Enhancing the UI / UX improvements of the app.</li> <li>Adding support for secondary user login for both local and remote connection.</li> <li>Support to share folders and shares with other servers (Friending feature)</li> <li>Enhancing the media streaming of the app</li> <li>Enhancing the user experience of the app while accessing the files.</li> </ol>

androidruby on railsgolang+6
Student: Balaji Ramavathu
Code
Proposal
Showing 3049 - 3072 of 5976 Projects
126127128129130
Proposal
Proposal
Proposal
Proposal