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

A Procedural Watercolor Brush Engine for Krita

advanced
KDE•2017Varies

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 →
350h (Large)

<p>Watercolor is one of the most complex tools for imitation. The painting, painted with watercolors, depends to a large extent on the motion of the pigment solution, on the paper worn. This process is rather difficult to model, because, depending on the environment, the system will continue to change for some time after the artist finished painting.</p>

c++qtcmake+2
Student: Grigory Tantsevov
Code
Proposal

Advanced syscall tampering and filtering with Lua/LuaJIT

advanced
strace•2017Varies350h (Large)

<p>A support for Lua-scriptable syscall tampering and filtering will be added. It will be possible to inspect syscall arguments (including structures/unions of arbitrary complexity, given that their definitions are provided), passed both by value and by pointer (and write modified values back in case of the latter) using LuaJIT's FFI library or a compatible one (there are currently <a href="https://github.com/jmckaskill/luaffi" target="_blank">a standalone implementation of FFI library abandoned since 2013</a> and <a href="https://github.com/facebook/luaffifb" target="_blank">its fork by Facebook</a>).</p> <p>It will also be possible to perform fault/success/signal injection.</p> <p>A pull-style C API, as <a href="http://luajit.org/ext_ffi_semantics.html#callback_performance" target="_blank">LuaJIT's FFI documentation suggests</a> for minimizing context switching between C and Lua and thus maximizing performance, will be implemented, but a helper library written in Lua will wrap it to provide a convenient push-style one.</p> <p>Of course, everything added will be documented and tested well.</p>

clinuxshell script+6
Student: Viktor Krapivenskiy
Code
Proposal

Efficient Finite Difference Discretizations of Partial Differential Operators

intermediate
The Julia Language•2017Varies175h (Medium)

<p>JuliaDiffEq is the most popular github organization for solving differential equations in Julia.Currently, it has an assorted collection of Ordinary Differential Equations (ODE), StochasticDifferential Equations (SDE) and Algebraic Differential Equations (DAE) solvers.</p> <p>But currently, there is no support for Partial Differential Equations (PDEs) which form an integral class of Differential equations found ubiquitously in natural sciences and engineering. PDEs are generally solved approximately by discretizing them to form ODEs which can then be solved separately.</p> <p>A toolbox to solve a large family of scientifically-interesting PDEs is thus sought. In light of this, I propose to create a toolbox of methods for discretizing PDEs in Julia.</p>

cjavascriptc+++12
Student: Shivin Srivastava
Code

Improved Tools for Genetic Diversity Modelling

advanced
Canadian Centre for Computational Genomics (C3G) - Montreal node•2016Varies350h (Large)

<p>Interpreting genomic data largely relies on simulation software. One important family of software simulates population-level diversity over the course of evolution as a function of selection and demography. The ∂a∂i open-source package, developed by Ryan Gutenkunst (<a href="http://gutengroup.mcb.arizona.edu" target="_blank">http://gutengroup.mcb.arizona.edu</a>), is the leading software in the field, but is limited when handling large datasets.</p> <p>This project aims to overhaul the computational engine of the ∂a∂i software by implementing a recently developed approach for solving partial differential equations. The project will use ∂a∂i's interface and code-base, but introduce a new spectrum simulation engine. Using a moment-based approach will improve performance and reduce numerical uncertainty, offering the genetics community with a general-purpose simulation tool that can address larger and more complex datasets than previously possible.</p> <p>A prototype version of the computational engine is already running. The goal of this project will be to optimize the engine and embed it efficiently in the existing code-base.</p>

pythonjavascriptsql+2
Student: wlong799
Code

DigiKam MySQL/MariaDB Database Support

advanced
KDE•2016Varies350h (Large)

<p>DigiKam is an advanced digital photo management application which enables user to view, manage, edit, organize, tag and share photographs under Linux systems. Currently, DigiKam use SQLite database support which is embedded database i.e. limited to local storage with one user. The goal of this proposal is to use MySQL database, which will provide the ease of more than one DigiKam accessing a remote and common database storage located on a remote server.</p>

c++qtcmake+2
Student: Swati
Code
Proposal

Implement Ext4fs support in ReadOnly mode

intermediate
The NetBSD Foundation•2016Varies175h (Medium)

<p>NetBSD currently doesn’t support Ext4fs. The aim of this project is to extend the code of Ext2fs to add Ext4fs read-only support. Additionally, the new functionality is supposed to be implemented in new files rather than making invasive changes in the files that are shared to some extent with UFS.</p>

networkingkernelbsd+13
Student: hrishikesh
Code
Proposal

Improving static analysis tools for MediaWiki

intermediate
Wikimedia Foundation•2016Varies175h (Medium)

<p>MdeiaWiki-CodeSniffer is a linting tool based on PHP_CodeSniffer. It helps MediaWiki to improve its code quality. This proposal aims to fix existing issues in the project, complete linting rules, add supports for linting method usages and standarize test files. <strong>Possible mentors: @Addshore, @EBernhardson, @Legoktm</strong>, <strong>Task Number: T89682</strong>, <strong>Proposal Task: T130574</strong></p>

javascripthtmlphp+7
Student: Lethe
Code
Proposal

Teach the Clang Static Analyzer to understand lifetime annotations

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

The Clang Static Analyzer (CSA) can find a wide range of temporal memory errors such as use-after-free and dangling references. Some of its checkers, like cplusplus.InnerPointer, rely on hardcoded knowledge about the behavior of specific APIs. The Clang community has introduced lifetime annotations: [[clang::lifetimebound]] and [[clang::lifetime_capture_by(X)]] that let developers express lifetime relationships directly on their declarations and -Wlifetime-safety makes use of them. However, in partially annotated code, a single missing annotation is enough to prevent -Wlifetime-safety from finding the bug. The CSA can help in these situations by inlining the unannotated function. In my proposed project, I intend to implement a new standalone checker that reads lifetime annotations and tracks the resulting dependencies along different execution paths, using them as a fallback when the analyzer cannot inline a function body. The expected result is that the CSA detects lifetime bugs in both annotated and partially annotated code that it currently cannot catch, complementing the coverage provided by -Wlifetime-safety.

cllvmc+++3
Student: Benedek Kaibas
Code

StablePay: Enabling a Multi-Stablecoin Payment Experience

intermediate
AOSSIE•2026Varies175h (Medium)

Currently, the StablePay ecosystem only processes payments for Djed Osiris. As the Djed protocol expands to include new variants like Djed Shu, Tefnut (ETH-backed), and Isis (ERC-20-backed), the payment infrastructure must evolve. The goal of this project is to refactor the StablePay widget, merchant dashboard, and demo sites to seamlessly support any Djed variant without hardcoded assumptions. Additionally, this project will introduce support for the Gluon protocol, which entails deriving the essential mathematical formulas required for pre-calculating neutrons and protons. To achieve this, I will develop protocol adapters that interact with abstracted Djed interfaces, allowing different stablecoins to be plugged in via configuration. I will upgrade the merchant dashboard to enable multi-stablecoin management, allowing merchants to set preferred price feeds and monitor per-stablecoin revenue. Additionally, I will build deployment tooling to auto-generate config bundles from on-chain metadata and improve the end-user UX to handle coin selection, oracle status, and fallback logic gracefully. Ultimately, this project will transform StablePay into a highly scalable, agnostic payment gateway. Deliverables will be secured with comprehensive integration testing (using Foundry/Hardhat) and frontend end-to-end testing, alongside detailed documentation for merchants to easily onboard new networks and protocol versions.

pythonjavascriptswift+8
Student: Amrit Kumar Yadav
Code
Proposal

Integrating the Faust Programming Language into Bespoke Synth

intermediate
GRAME•2026Varies175h (Medium)

The goal of this project is to provide an interface in Bespoke Synth for editing and running Faust programs in real time. This will provide Faust developers with access to a modular synthesizer that can be used as an IDE, and it will provide Bespoke Synth users with an accessible way to extend and modify the DSP of Bespoke Synth without having to recompile. This project will be implemented using C++, and will use the Faust embedded compiler.

cpythonjavascript+3
Student: Blake North
Code
Proposal

Developing a FHIR Resource Tabular Viewer for Efficient Data Exploration.

beginner
Data for the Common Good•2025Varies90h (Small)

Healthcare data is critical for decision-making, but the FHIR (Fast Healthcare Interoperability Resources) format, while powerful, can be challenging to navigate for many users. Our project addresses this accessibility gap by creating an intuitive tabular viewer that transforms complex nested FHIR resources into easy-to-understand tables. We're developing a Python-based solution that will automatically extract and organize FHIR data into user-friendly tables, making it immediately more accessible to researchers, clinicians, and community organizations. By simplifying how people interact with health data, we remove technical barriers that often prevent valuable insights from reaching those who need them most. Our deliverables include: A Python library that converts FHIR resources to tabular format An interactive web interface for exploring and filtering the data Documentation and examples to support adoption by various user groups Integration with existing FHIR servers for seamless data access This tool will democratize access to health information by making complex data structures approachable for everyone from data scientists to community health workers. When healthcare data becomes truly accessible, it empowers better decisions and ultimately improves health outcomes in our communities.

pythonjavascriptkubernetes+2
Student: Manjula
Code

ATIA: A BENCHMARK FOR ADVERSARIAL TOOL INFILTRATION IN AGENTS

advanced
Google DeepMind•2025Varies350h (Large)

As multimodal agents become increasingly integrated into real-world applications, ensuring their safe and reliable tool-use behavior is paramount. We introduce ATIA, a novel evaluation suite designed to systematically assess the vulnerability of tool-calling agents to adversarial inputs. ATIA focuses on crafting malicious multimodal inputs—combinations of images, text, and other modalities—that covertly manipulate an agent's decision-making process regarding external tool invocations. By simulating a variety of attack vectors, including visual prompt injections, image–text conflicts, and spurious cross-modal cues, ATIA quantifies critical metrics such as tool call correctness, unsafe tool invocation rate, and adversarial success rate. This benchmark not only exposes potential weaknesses in current multimodal agent architectures but also provides actionable insights for developing robust, safe, and aligned systems. ATIA aims to serve as a reproducible and extensible framework, driving forward research in adversarial robustness and security for next-generation AI agents.

pythonjavascripttypescript+2
Student: Matthew Nguyen
Code
Proposal

Advanced Features and Inhancements for Vert.x Http Proxy

advanced
Eclipse Foundation•2024Varies350h (Large)

vertx-http-proxy is a programmable reverse proxy based on Vert.x. The current implementation uses interceptors to modify requests and responses during the HTTP calls. However, it’s inconvenient for developers to create interceptors for each rule they want to apply. This project will mainly focus on improving user experience by providing a builder API for transforming requests and responses from HTTP calls and enabling configure proxies by configuration files. Besides, it will also implement other useful features, such as cache storage integration and fine-grained management.

c/c++javageospatial+15
Student: Zengyi Wang
Code
Proposal

Pycxxwrap

intermediate
Ste||ar group•2023Varies175h (Medium)

Pycxxwrap is a versatile Python decorator used to wrap C++ code into Python using Pybind11. It serves as a wrapper around Pybind11, a lightweight, header-only library that facilitates the exchange of C++ types between Python and C++. The primary goal of this project is to provide a Pythonic interface for C++ libraries, simplifying their usage and enabling the creation of Python libraries from existing C++ ones. Additionally, Pycxxwrap includes special support for the HPX library, a C++ Standard Library for Concurrency and Parallelism, using custom header files.

c++cudaopencl+10
Student: Matrixbot
Code
Proposal

Tor’s SnowFlake: Revitalising Snowflake's Landing Page for a Better User Experience

beginner
The Tor Project•2023Varies90h (Small)

Snowflake is a pluggable transport that helps users bypass censorship and access the Tor network. It uses webRTC technology to create a peer-to-peer connection between the user's browser and a volunteer proxy server. The Tor project aims to create a new and improved website for Snowflake that provides a better user experience for both new and existing users. As the Snowflake has gained a lot of popularity recently, it has seen a significant increase in the number of visitors with various doubts and queries The existing website does not effectively address these concerns, so our goal is to create a user-friendly static & secured website that is easy to navigate and provides clear information about Snowflake and its proxies. At the End of this summer: 1. A new static website with a modern and intuitive layout for desktop and mobile devices integrated with other Tor Web products & follows tor's brand guidelines. 2. Improved Snowflake proxy guide for new and existing user 3. Ensuring the website is sustainable and easy to maintain by new contributors & developers over the long term.

cpythonjavascript+4
Student: SoniAshish
Code

Continous-Time Collision Detection for CGAL

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

Funded by GSoC this summer, I propose to add collision detection to CGAL in a way that naturally builds on and extends CGAL’s existing AABB-tree functionality. The project will focus on implementing trusted collision-detection methods, which are attested to by their use in projects like the Godot game engine as well as their continued academic propagation through works like Ericson’s “Real-Time Collision Detection” and courses like UT Austin’s “CS395T: Physical Simulation”. I envision the project having the following deliverables: - Modifications to CGAL’s existing AABB tree functionality where necessary, e.g. to handle moving bounding boxes and dynamic restructuring of the bounding volume hierarchy - Broad-phase collision detection routine that utilizes CGAL’s AABB tree to quickly rule out unnecessary collision queries and identify potential collision pairs - Narrow-phase collision detection routine that performs fast collision tests on the pairs of primitives identified in the broad phase - Tests to cover all changes and new functionality - Documentation of the above The full proposal can be found here: https://hackmd.io/@1V1uNkwcQMiMbp_OanOjUA/r1kG1v_-3

githubc++git+4
Student: Jeffrey.D.Cochran
Code
Proposal

Self-Adaptive controller for path following

intermediate
RoboComp•2022Varies175h (Medium)

Self-adaptation is a key ability for future autonomous robots. Thanks to this capability, a robot is able to automatically adapt to changes during its operation. In the case of autonomous navigation, if the robot is endowed with this skill, it can automatically adjust a set of free parameters to improve its functioning given a cost function or metric. The effect of this adaptation is safer, more efficient, and, possibly, better socially aware navigation. The aim of this project would be to design and implement a sliding variable based adaptive controller that can self-adapt under varying circumstances. Through this the robot would be able to successfully navigate and self adapt under social constraints as well if required.

pythonc++cmake+12
Student: Swati Dantu
Code
Proposal

reimplement `cabal check`

advanced
Haskell.org•2022Varies350h (Large)

`cabal check` is a tool to check the correctness of a `.cabal` file and more generally to provide more useful output (warnings, especially related to uploading the package to Hackage). As now `cabal check` is an imprecise tool, outputting spurious warnings on well formed `.cabal` files. The mistakes become more and more annoying the more complex your package is (compilation flags, etc.). Picking up an AST, transforming it appropriately and *traversing* it is the only way to practically solve these problems. This proposal aim to do so.

haskellghccabal+3
Student: Francesco Ariis
Code
Proposal

Typescript Migration

intermediate
The Palisadoes Foundation•2022Varies175h (Medium)

The project aims to completely migrate the codebase of talawa-api from javascript to typescript. The project will introduce a strong type system in the codebase making every contributer adhere to that type system while contributing to the project. This will reduce the margin of errors that are introduced at runtime because of the dynamic nature of javascript. Other than that potential bugs will be addressed/fixed and other additional functionality will be introduced as needed by the project.

javascriptmongodbnode.js+5
Student: xoldyckk
Code
Proposal

PyQuotient

intermediate
Matrix.org•2021Varies175h (Medium)

<p>PyQuotient are Python bindings to libQuotient, a Qt-based library to make client applications for Matrix and. The proposal includes also a basic Matrix client application in Python using PyQuotient.</p>

pythonandroidreact+9
Student: Vladyslav Hnatiuk
Code
Proposal

Ruma's Automated Checks

intermediate
Matrix.org•2021$3k–$6.6k175h (Medium)

<p>I am applying to work on Ruma's automated checks issue <a href="https://github.com/ruma/ruma/issues/221" target="_blank">https://github.com/ruma/ruma/issues/221</a> to build a special-purpose tool to check code style rules and formatting specific to Ruma. I will use <code>rust-analyzer</code>'s <a href="https://github.com/rust-analyzer/rust-analyzer/tree/master/crates/syntax" target="_blank">syntax</a> crate to parse Rust files into a typed AST that is checked against rules. I plan to use this AST to be able to format code inside macros since this is a big part of Ruma. I have started a proof of concept tool <a href="https://github.com/DevinR528/ruma-check" target="_blank">ruma-check</a> that I will complete during GSoC.</p>

pythonandroidreact+9
Student: Devin Ragotzy
Code
Proposal

Creating a MIME Sniffing Library for Scrapy

intermediate
Python Software Foundation•2021Varies175h (Medium)

<p>This project is about creating a python library that implements the complete MIME Sniffing Standards. MIME stands for “Multipurpose Internet Mail Extensions.” This method is used to examine the type of content in a web request or response to determining the content’s format. Usually, we can determine a resource’s MIME type by looking at the Content-Type response header in an HTTP response but some developers set values for Content-Type headers that are not suitable for the response’s content. This is where MIME Sniffing comes into play to determine the actual MIME type by analyzing the response’s content.</p> <p>Misinterpreting MIME types can cause bugs while using Scrapy frameworks in projects. Therefore, we should implement the python library that can handle all the MIME sniffing standards. This library will follow the standards described in <a href="https://mimesniff.spec.whatwg.org/" target="_blank">https://mimesniff.spec.whatwg.org/</a>.</p>

pythonmercurialjavascript+3
Student: Akshay_Sharma
Code
Proposal

Measuring QUIC and TLS censorship with OONI Probe

intermediate
Digital Impact Alliance (DIAL) at UN Foundation•2021$3k–$6.6k175h (Medium)

<p>My goal for Google Summer of Code is to make OONI better at measuring TLS and QUIC blocking. OONI develops the open source software OONI Probe which provides tools for measuring internet censorship. QUIC is an emerging transport protocol that was initially designed by Google to solve problems with the existing TCP/TLS architecture. With increasing traffic volumes, it is significant to observe and measure QUIC blocking.<br> I want to identify and resolve existing inconsistencies with the QUIC code that I have contributed earlier this year.<br> Eventually, the QUIC code should get to a point where it can be used in production by the Desktop client. Therefore, the first deliverable of my GSoC project will be to integrate QUIC support into the OONI Web Connectivity experiment.<br> The second part of my project will be to implement the capability to parrot the TLS fingerprints of popular web browsers. TLS fingerprinting is a censorship method which identifies browsers based on the structure of the TLS ClientHello message. The ability of parroting TLS fingerprints will enable OONI Probe to measure and circumvent TLS fingerprinting.</p>

pythonjavascriptandroid+4
Student: Kathrin Elmenhorst
Code

Robotics-Academy exercises on Evolutionary Robotics

intermediate
JdeRobot - Universidad Rey Juan Carlos•2020Varies175h (Medium)

<p>JdeRobot’s Robotics-Academy is a framework for learning robotics and computer vision. It consists of a collection of robot programming exercises using Python language where the student has to code the behavior of a given (either simulated or real) robot to fit some task related to robotics or computer vision.</p> <p>The idea for this project is to introduce Evolutionary Robotics into Robotics-Academy developing exercises with mobile robots. Implementing Neural Networks and their related exercises are the main goals of the exercise.</p>

pythonc/c++ros+4
Student: Sakshay Mahna
Code
Proposal
Showing 7489 - 7512 of 13453 Projects
311312313314315
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal