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

Upgrade the documentation system to git-based system

intermediate
FreeCAD•2023Varies

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)

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

Improving Site Performance and Implementing Subject Tags

advanced
Internet Archive•2023Varies350h (Large)

The objective of this proposal is to enhance the user experiences for readers of Open Library through a two-prong approach. The first prong, Improving Site Performance, addresses the poor site performance that negatively affects our patrons’ experience. This prong takes a metric-based approach to identify the key bottlenecks of performance using various performance measurement tools. This metric-based approach allows us to identify the areas for performance optimisation and quantify the effects of our changes. The second prong, Implementing Subject Tags, seeks to offer a more resourceful alternative to the Subject tags that are currently implemented for books in Open Library. The current Subject tags, which are implemented as a list of strings, are limited in extensibility and scalability, and are not an efficient tool in categorising and providing information about books. Subject Tags will be implemented as first-class objects, allowing for metadata to be included within tags. The metadata will provide relationships and hierarchy between subjects, internationalisation (i18n) information, additional description about tags and many other extensible information fields. Upon the success of this implementation, its utility will catalyse improvement within numerous avenues in the Open Library system which includes the search engine, Subject page interface, content advisory and many more. These two prongs work together to improve the overall patron experience, making the site more enjoyable to use and enriching the information about books.

pythonjavascriptpthon+6
Student: Jayden Teoh Jing Xiang
Code

A Pipeline for NeRF Experimentation and Visualization

beginner
OpenCV•2023Varies90h (Small)

The goal for this project is to develop a NeRF model training pipeline within the OpenCV library. The end result will be a fully functioning data processing pipeline that is well integrated with the NeRF model training procedure, as well as online documentation that detail how to use the pipelines properly. There are 3 key deliverables for this project. First, implement data loaders that can process user-taken images of real-world scenes. This will involve using the COLMAP and OpenCV data processing pipelines in order to extract the camera poses and epipolar geometry of the scene; these are requirements for the model's ability to learn a meaningful representation of the given scene. Second, build, train, and test the actual NeRF model. This will involve using PyTorch's built-in CUDA support and extensive usage of the PyTorch library as a whole in order to incorporate critical components of the NeRF architecture such as positional encoding, ray sampling, and regularization into our model design. This step will also include rendering procedures that will allow users to extract images/videos, depth maps, and other logging information such as the training loss curve from the fully trained model. Third, create simple and intuitive documentation on how to use both the data loaders and the NeRF code base. This will involve creating a page on OpenCV's documentation (via Doxygen) that will list out specific terminal commands that the user should use to train the model. It will also include a summary of required packages, recommended environment configurations, and links to other helpful resources such as YouTube video demonstrations, which will all be geared towards increasing the usability and accessibility of the pipeline.

pythonmachine learningc+++9
Student: Joshua Ahn
Code
Proposal

FURY: Update UI widget + Explore new UI Framework

intermediate
Python Software Foundation•2023Varies175h (Medium)

The main objective of this project is to update the existing UI system without impacting the current functionality, while also creating tests for each new change to ensure reliability. The project will focus on several key areas including Layout Management, Creating Scrollbar as an individual element, Completing Tree UI implementation, Spin Box Implementation, and Improving the Border Implementation. Additionally, the project will include fixing multiple UI elements such as ComboBox, TabUI, Filedialog, and Tree UI. Furthermore, the project will involve exploring a new framework with the existing UI element, which will enable selecting them together. Overall, the project aims to enhance the UI system while ensuring that it remains stable and reliable.

pythonmercurialjavascript+3
Student: ganimtron_10
Code

DICOM & BioFormats

advanced
caMicroscope•2023Varies350h (Large)

My project goal was to add DICOM file support to caMicroscope, a Whole Slide Image viewer. The viewer backend (OpenSlide) didn't support DICOM, so we needed a second backend. Surprisingly, before the coding period started, OpenSlide did get DICOM file support and this gave me the opportunity to tackle the bigger challenge of integrating BioFormats into caMicroscope. This would be extraordinary, as BioFormats is a Java library with no C wrappers available online. I started by refactoring caMicroscope code to use a single base Dockerfile which compiled OpenSlide. Then I made a Java wrapper and prepared its corresponding C caller. For this, I had chosen GraalVM C API, but once I found out about its level of performance and its requirement to achieve high code covergage first (for metadata collection), I rewrote it for Java JNI. To make it available to the two derivatives of our base image, I refactored this to be a separate project. We also needed to make this available to our Python image metadata server, so I wrote a wrapper in Python using cffi.

pythonjavascriptjava+5
Student: cgdogan
Code
Proposal

Parallel stacks for Kotlin Coroutines in the debugger

intermediate
Kotlin Foundation•2023Varies175h (Medium)

This project is focused on enhancing the functionality of Kotlin Coroutines by developing parallel stacks for use in the debugger. The goal is to provide developers with an effective means of debugging their asynchronous and concurrent code. To achieve this objective, an IntelliJ IDEA plugin will be developed that will communicate with the Kotlin compiler during a debugging session. The plugin will be able to retrieve relevant information about coroutines at any state of the program and leverage this information to generate a parallel stacks view. This will provide developers with a comprehensive overview of the execution flow of their coroutines, allowing them to more effectively identify and resolve issues in their code. Overall, this project represents a significant advancement in the toolset available to Kotlin developers, enabling them to build more reliable and performant coroutine-based applications.

gradlekotlinjvm+3
Student: Raehat Singh Nanda
Code

Mifos X Vulnerability Assessment and Penetration Testing Project Proposal

intermediate
The Mifos Initiative•2023Varies175h (Medium)

My mission is to perform a vulnerability assessment and penetration testing engagement on the Mifos X web application, and the Apache Fineract APIs, to identify vulnerabilities which can be exploited by malicious hackers and together with the developers, patch these known vulnerabilities. The deliverables for this project are : 1. Integrating a DAST into the Mifos X github workflow, to scan for security vulnerabilities in the running application. After the engagement, we can decide to run the workflow every now and then. 2. A penetration test engagement will be done to assess the security posture and test Mifos X application and Apache fineract APIs to assess if it is secure and free from the OWASP top 10 vulnerabilities, SANS/CWE top 25 security vulnerabilities and the OWASP API top 10 vulnerabilities. 3. A SAST will be integrated into our github workflow to scan our codes for insecure coding patterns that may lead to a security vulnerability. 4. A detailed VAPT report will be provided to help developers understand the vulnerabilities and make the patches where necessary. 5. DAST and SAST scanning reports would be made available as examples based on limited scan scope.

mysqljavascriptandroid+5
Student: Kerlyn Manyi
Code

Rendering Performance Optimization

advanced
Synfig•2023Varies350h (Large)

The project aims to improve the rendering speed of Synfig, a free and open-source 2D animation software. The project's primary goals are to document the rendering system, fix the thread issue, find the best way to schedule rendering tasks, improve the blending and color functions, optimize the contour rasterization algorithm, and stabilize the OpenGL renderer's core. The project's stretch goals include implementing a Contour Layer using shaders. The project will benefit the community by providing faster rendering, better user experience, and proper developer documentation. The project aims to deliver a solid, stable base for the OpenGL renderer and improve software renderer performance, reducing render times and making the viewport more responsive.

c++gtkgtkmm+2
Student: b23v
Code
Proposal

API: IMPROVED BACKEND PERFORMANCE AND SECURITY

beginner
The Palisadoes Foundation•2023Varies90h (Small)

The project aims to make the following changes to the talawa-api: Enforce a stricter, standard graphql-pattern to get rid of the current anti-pattern nature that exists in the API. Resolve the relations that exist within the application optimally. Caching data for MongoDB collection entities having significantly higher number of read operations than write operations using Redis in memory Cache. Monitoring changes in the API schemas and relaying the changes to the client apps using Graphql-Inspector for better versioning migrations. Implement Data Normalization on the Client side(admin-portal and talawa mobile app) cache-store using Apollo Client Normalization. Providing a standard, scalable Error Handling mechanism within the graphql API using unions and interfaces to allow a consistent relay of Errors to the Client apps which will allow them to have more control over customizing UI behavior in case of errors. Implement stricter and simpler RBAC in the API resolvers in line with the business logic. Implement SSL in the client-server layer to encrypt all data exchanged between the client apps and API. Encryption of PII data within the SSL layer and in the Database at rest for added security using AES algorithm to encrypt and decrypt PII fields.

javascriptmongodbnode.js+5
Student: Kanishka Bansode
Code
Proposal

TypeScript Migration and UI/Integrations Improvements

intermediate
Zulip•2023Varies175h (Medium)

The Zulip messaging app currently relies heavily on JavaScript, which lacks certain types and safeguards for developers. To improve the experience and speed of creating modules, the project aims to migrate to TypeScript, which provides missing types and additional safeguards. In addition to the migration, improving the UI and Integrations of the Zulip Web App could bring significant enhancements to the app.

pythonjavascriptdjango+5
Student: Satyam Bansal
Code
Proposal

Admin UI redesign

intermediate
The Palisadoes Foundation•2023Varies175h (Medium)

The proposal suggests redesigning the UI of Talawa-Admin to make it more intuitive and user-friendly. The new design should be deployed incrementally and should be reactive to all screen sizes. The layouts should be coded in Typescript and standardized templates should be created for commonly expected functions. The expected outcomes include improved workflows for managing multiple organizations, CRUD activities, filtering people and tags, viewing organization events, requesting volunteers at events, doing event check-ins, and managing pinned posts on the newsfeed. The proposal also suggests adding a properly documented design system and style guide to the Talawa-Docs repository.

javascriptmongodbnode.js+5
Student: Rishav Jha
Code
Proposal

An Integrated CONTROL-CORE experience

intermediate
Department of Biomedical Informatics, Emory University•2023Varies175h (Medium)

At present, all the Concore methods such as build, debug, run etc. are executed from CLI by user and Concore-editor does not serve the functionality of performing these methods directly from frontend. Therefore, to achieve the following this project aims to integrate Concore-editor with Concore so that on studies developed in Concore-editor, the specific Concore functions can be performed straight away. This project implements the above using the approach of making custom API calls from Concore-Editor to Concore Backend with custom arguments which are essential for Concore Backend to function. Making necessary checks to execute API calls in order is another aspect of the approach taken.

pythonjavascriptjava+4
Student: Rahul Jagwani
Code

Eclipse Gradle KTS editing

intermediate
Kotlin Foundation•2023Varies175h (Medium)

Project focused on improving the user experience of editing Gradle Kotlin Scripts (KTS) in Eclipse. With contributions to the Gradle Eclipse plugin, users will benefit from improved code error highlighting, code completion, and Ctrl-Click to definition functionality. By improving support for editing KTS in Eclipse, developers will be able to work more efficiently, resulting in faster and higher quality software development.

gradlekotlinjvm+3
Student: Nikolai Vladimirov
Code
Proposal

Automation tools for LibreMesh firmware build and monitoring

intermediate
freifunk•2023Varies175h (Medium)

Create a set of automated tasks to install services on a Raspberry Pi to meet the needs of small community-network with an administration/tech team, e.g. a set of commonly needed monitoring tools, such as Prometheus, Prometheus-node-exporter, Blackbox-exporter, Altermanager, Grafana, VPN and an editing map service. Create a set of tasks to replicate the OpenWrt build-system, to provide a reproducible and automated set of instructions, to speed-up the process of self-building images for OpenWrt and/or LibreMesh for newcomers, and to easily setup a dedicated machine. These Ansible roles would include tasks to build for: different architecture and targets, different Openwrt and Libremesh versions, keeping trace of devices with specific packages or particular needs and related patches; keeping a local list of supported targets. With the possibility to later extend the process of build to other automated tasks, like a pub-keys-exchange needed for configuring a VPN, update documentations, or to update the configurations of monitoring services.

cluaopenwrt+15
Student: samlo
Code
Proposal

GNOME Control Center: List and handle IPP print services for the New Architecture

beginner
The Linux Foundation•2023$1.5k–$3.3k90h (Small)

Modern printers usually are driverless IPP printers, and those get discovered fully automatically by CUPS; no CUPS queue needs to be explicitly created. Same for remote CUPS printers and also Printer Applications . They are all discovered as IPP print services. And listings of IPP print services have different requirements: One server can have more than one individual print service and these should get listed together. This could be a print queue and a fax out queue of the same multi-function printer, or two physical legacy printers supported by one Printer Application. Also the user interaction coupled to each listing is different. We do not need to configure PPD option settings, but instead, we need access to the IPP service's web administration interface and also to an IPP System Service configuration panel by a simple mouse click. Several parts of this were already coded in previous GSoCs, but we need to get everything smoothly integrated in the “Printers” part of the GNOME Control Center. I will work together with the upstream maintainer of the “Printers” module, Marek Kasik and also with the UI/UX design teams of GNOME and of Canonical.

cpythonmysql+7
Student: Mohit Verma
Code

Improving Efficiency and Readability of the gprMax codebase and preparing a custom support chatbot.

intermediate
gprMax•2023Varies175h (Medium)

The major objectives of the project are: 1. Refactoring the Python code to increase efficiency and readability and increase the overall code quality of the entire codebase of the software. 2. To enhance user engagement and support by creating a comprehensive FAQ dataset which is used to train a custom Chatbot. 3. Investigate and discuss different possibilities for multi-GPU model execution, i.e. allow a model to execute (and share memory) across multiple GPUs.

pythoncythoncuda+3
Student: V. Sai Suraj
Code
Proposal

Project 7.1: Working on Implementing CSV Data Browser and Querying Component

beginner
INCF•2023Varies90h (Small)

We are trying to solve the difficulty of collaboration among multiple users working on large datasets, particularly in analyzing datasets with many parameters and essential features that need to be filtered, measured, and analyzed. The solution is AnalySim, a data-sharing platform that simplifies collaboration by providing easy sharing, analysis, visualization, and collaboration capabilities on datasets. The first deliverable is the ability to embed Jupyter notebooks, Observablehq notebooks, and Google Collab notebooks on the website using an interactive panel. The second deliverable is an interactive panel or interface that displays a dataset's different types of features, including minimum, maximum, mean, number of non-zero, and the number of invalid values. The interface should show other visualization options like histograms, pie charts, multi-series line charts, pie charts, graphs, and visualizations representing data with more than two dimensions, e.g., 3D Scatter plots, 3D Mesh Plots, 3D line plots, box plots, and bubble charts. The third deliverable is the ability for users to add publications related to the datasets in a project. We will achieve this by creating a text editor page where users can add content, edit content, remove content, add tables, and add images. The text editor should allow users to add latex code so that users can publish mathematical analyses of the findings. We will also implement a page that gets the list of publications, which should contain clickable items that redirect to another page that details the publication. Finally, we will refactor some of the code to maintain a better project structure, encapsulate numerous fragments of the same code in another method to improve the readability of the code and remove deprecated methods.

pythonjavac+++7
Student: Kshitiz Sareen
Code

Jax Support in DocArray v2

intermediate
Jina AI•2023Varies175h (Medium)

DocArray is a library for representing, sending, and storing multi-modal data, with a focus on applications in ML and Neural Search. It currently supports several deep learning frameworks, including PyTorch and TensorFlow. Jax is becoming increasingly popular for deep learning, so we want to integrate it into DocArray. The project we propose is to add Jax as a backend for DocArray, alongside PyTorch and TensorFlow. The first part would involve rewriting and translating all of the computational backend functions of DocArray with the Jax framework. Then, we would battle-test the implementation against a real Jax use case, such as integrating DocArray with Jax support for model training and serving.

pythonmachine learningmicroservices+2
Student: aman0
Code
Proposal

Manash Kumar_Proposal_Rocket Launcher Visualizer / SpaceX Rocket Visualizer_350 Hours Duration

intermediate
Liquid Galaxy project•2023Varies350h (Large)

I am planning to build the app using flutter for frontend and calling APIs using dart package called “retrofit” for collecting data of rocket launches from APIs such as “https://www.rocketlaunch.live/api” and “https://docs.spacexdata.com/” and “https://spaceflightnewsapi.net/” this API to access different news articles and related information about the launch to show on the app also Celestrak API “https://celestrak.org/” for satellite data. We use “google_maps_flutter” for the live location of the user, “google_directions_api” for finding routes to the nearest launch site and “geocoding” to convert the named launch site location to coordinates. After calling the API it will return data in JSON format which we will convert to KML format file and store it locally using “shared_preferences” and then will send it to Liquid Galaxy for visualisation. There will be a map screen as well in the app to visualise the launch in the app itself if it is not connected to Liquid Galaxy. I will use embedded code sent to LG Rig using the KML format of placemarkers of the launch site with a YouTube live video link pasted by users (of which instructions will be mentioned) in the input text field which will telecast live launch video on LG alongside visualisation.

javascriptrosgis+14
Student: Manash Kumar
Code

Support CycloneDX report

intermediate
FOSSology•2023Varies175h (Medium)

Currently, FOSSology generates SBOM in SPDX format, which allows for integration with various tools. However, CycloneDX is another popular format for generating SBOMs. By integrating CycloneDX report generation in FOSSology, it will be possible to work with other tools that use CycloneDX. Although a PHP library exists for generating CycloneDX reports, it cannot be used because it is licensed under Apache-2.0, while FOSSology is under GPL-2.0. Therefore, a custom implementation of CycloneDX report generation in FOSSology is necessary. So the main goal of this project focuses on the implementation of CycloneDX report generation in FOSSology.

linuxpostgresqlc/c+++7
Student: Sushant Kumar
Code
Proposal

Improve the UI and Visual design of Zulip

intermediate
Zulip•2023$3k–$6.6k175h (Medium)

This GSoC project aims to significantly enhance the user experience of Zulip, an open-source team chat app, by implementing several features that will improve the user interface and usability of the application. The project will specifically focus on redesigning crucial areas of the application, including the top bar, sidebars, Compose box, and Topics, to make them more intuitive, user-friendly, and visually appealing.

pythonjavascriptdjango+5
Student: Hardik_Dharmani
Code
Proposal

Support Vespucci preset extensions in JOSM

intermediate
OpenStreetMap•2023Varies175h (Medium)

Vespucci, the Android editor for OpenStreetMap, uses the JOSM-compatible presets for tagging. Vespucci, however, has evolved to support far greater functionalities than those supported in JOSM. These functionalities include attributes like 'deprecated', which indicates a deprecated preset item, 'regions', and 'exclude_regions' for localisation, and 'value_type' to indicate the type of value, among many others. The project aims at adding these additional attributes to JOSM. Incorporating these attributes will provide a better user experience across the editors, improving the usability and functionality of JOSM.

javascriptjavaopengl+10
Student: Sarabjeet Sodhi
Code
Proposal

License as a Service

intermediate
FOSSology•2023Varies175h (Medium)

It provides a convenient and effective way for organizations to manage their use of open-source licenses. With the growing popularity of open-source software, organizations are finding it more difficult to keep track of the various licenses and terms under which they are permitted to use open-source components. Open-source licenses can be complicated, making it difficult to understand how they apply to a specific piece of software or interact with other licenses. It can be used for various purposes by organizations like FOSSology and SW360 like license identification, filtering, and managing licenses.

linuxpostgresqlc/c+++7
Student: K-vya
Code
Proposal

Implementing an out-of-band identity verification system for Kanidm

intermediate
openSUSE Project•2023Varies175h (Medium)

As of now, Kanidm doesn't provide a way to allow two users to mutually authenticate each other. I would like to design and implement such feature, building upon and further polishing the design already discussed between the maintainers and me (see pull request #1416). The idea is to use ECDH to compute a unique TOTP for each user, make the users exchange said TOTPs with an out of band channel and then verify if they are correct, with no online communication required between the involved kanidm servers. To begin with I'll have to implement a feature that allows kanidm to store ECDH keys for its users, as they are required for the Identity verification system to authenticate subjects. Afterwards I will work on the core server-side logic of the system, and finally, if time will allow it, I am going to implement a frontend interface in the kanidm client for the identity verification system. I also plan on writing a journal of my experience with this project.

pythonlinuxjavascript+11
Student: Sebastiano Tocci
Code
Showing 3577 - 3600 of 11996 Projects
148149150151152
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal