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

Cool enhancements and an advanced feature set for Riot iOS

advanced
Matrix.org•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>The purpose of this project is to implement some of that missing features as well as functionality that will be unique to the iOS client. Various advanced features will be implemented like CallKit, 3D Touch, Onboarding tooltips, etc.</p>

pythonandroidreact+9
Student: Aram Sargsyan
Code
Proposal

3rd Party Authorised Room Membership

intermediate
Matrix.org•2022Varies175h (Medium)

This project aims to develop an application that has the ability to delegate membership of a room based on the user’s interaction with other third party services. A user can either be invited, kicked or put in a “standby” state for a room based on their past interactions. There are five main components in this project: 1) A reusable frontend component that handles the login UI for both Matrix and other third-party services. 2) A server-side component and a bot that verifies a user’s authorization to a room and decides their membership. 3) An admin panel to configure the relationship between matrix rooms and groups in third party services. 4) An external invite URL that can be used to get an invite to a room. 5) Token authenticated account registration for existing authorized users. I will be using the matrix-nio library mainly for building the bot since it has most of the functions required for interacting with the server and building a feature-rich tool.

pythonandroidreact+9
Student: Munukurthi Binesh
Code
Proposal

Queue Interface

intermediate
The syslog-ng project.•2018Varies175h (Medium)

<p>The aim of this project that is to develop a Redis based queue interface which could be an alternative to the disk queue.</p>

cpythonjava+5
Student: Mehul Prajapati
Code
Proposal

Improvement in i18n for games

beginner
Godot Engine•2020Varies90h (Small)

<p>The goal of this project is to improve internationalization (i18n) support in Godot. In particular, we wish to make the localization process simpler for users, and also enhance the existing system to support more features. Work includes:</p> <ul> <li>Building in-house tools in the editor to generate translation template (POT) files and smoothen some of the localization process for users.</li> <li>Adding extra functionalities to existing i18n system such as plurals support, context support and translators' comments generation.</li> </ul>

openglgithubc+++7
Student: Jia Jun CHAI
Code
Proposal

First-Class Email Bridge

intermediate
Matrix.org•2021Varies175h (Medium)

<p>Email is one of the longest standing communication methods since the beginning of the internet and is still widely used and almost every internet user has an email address. One of the core ideas of Matrix is interoperability. Having the option to communicate with everyone without having to worry if the other person is also on the same platform as you are is a major concern while switching to another communication platform.</p> <p>The entry barrier to the Matrix ecosystem is lower as compared to similar projects due to the support of bridges. IRC, Telegram, Slack, Signal and Gitter bridges, to name a few, have reduced the barrier very much. By bringing email support to the ecosystem, we will be able to push the barrier to almost nil. Imagine the matrix system which will be able to communicate with virtually everyone that has a personal internet address!, i.e, the email ID.</p>

pythonandroidreact+9
Student: Abhinav Krishna C K
Code
Proposal

Add pseudo-localization to better spot untranslated strings and unexpected layout changes caused by long strings

intermediate
Godot Engine•2021Varies175h (Medium)

<p>The project aims at implementing support for pseudo-localization in Godot. Pseudo-localization is an important tool for internationalization. It offers the developers a way to check if the project is internationalized properly without actually translating the project. For example, the <a href="https://en.wikipedia.org/wiki/Pseudolocalization" target="_blank">wikipedia article</a> on pseudo-localization gives an example on how pseudo-localization would translate <code>Account Settings</code> to <code>[!!! Àççôûñţ Šéţţîñĝš !!!]</code>. Thus, Pseudo-localization involves replacing all characters in localizable strings by some special characters along with adding some constant padding to check whether the UI is robust enough to handle changes due to change in locales.</p>

openglgithubc+++7
Student: Angad Kambli
Code

Refactor and UX Updates of ColorPicker

intermediate
Godot Engine•2022Varies175h (Medium)

ColorPicker has RGB, HSV and Raw mode, but they never were properly separated, resulting in messy code. With OKHSL mode going to be added soon that adds even more messy code. The aim of this project is to make code in ColorPicker refactored and cleaned up to make multiple color modes more maintainable and easier to add, also to update the UX of ColorPicker.

openglgithubc+++7
Student: Vitika Soni
Code
Proposal

Version Control System Improvments

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

<p>To help users to collaborate and use version control tools easily, Godot 3.2 introduced the version control system. The initial project to integrate VCS (Version Control System) into Godot was created in GSoC 2019 by ironicallySerious. It had been an excellent initial effort. However, there are still many things to improve. This project aims to improve the compatibility, usability and reliability of the VC system in godot and godot-git-plugin.</p>

openglgithubc+++7
Student: Patel Meru
Code
Proposal

Implementing a DAP backend for debugging Godot projects

intermediate
Godot Engine•2021Varies175h (Medium)

<p>This project aims to add a new debug backend to the editor, compliant with the <strong>DAP</strong> <a href="https://microsoft.github.io/debug-adapter-protocol" target="_blank">specification</a> <em>by</em> Microsoft. This allows for more integrated development environments for people who use external text editor/IDEs to develop Godot projects.</p>

openglgithubc+++7
Student: Ricardo Subtil
Code
Proposal

Analysis of Scalable Solutions for UPS database with Apache Kafka, Apache Spark and HBase

intermediate
JBoss Community•2017Varies175h (Medium)

<p>The Unified Push Server Database is currently based on MySQL/PostgreSQL, and the data is all stored in one schema. Database updates are handled by a JMS broker. However, when this system is put under pressure with a high level of users and an intense quantity of push metrics it is unable to perform optimally. The reality here could be a poor user experience with slow message delivery, dropped messages or the possibility of service unavailability. As messages begin to exceed millions, this will become a bottleneck for the system and one which needs to be addressed and engineered with scalability in mind.</p> <p>This project will investigate the possibilities of using different types of databases and methods to process large volumes of data. This will be a Proof of Concept that will aim to research Apache Kafka and Apache HBase as possible solutions to improve the real-time experience of the push metric of the AeroGear Unified Push Server.</p>

androidjavaide+12
Student: Dimitra
Code

Updating the Multi-select Plugin in Blockly and Cross-testing Other Plugins

advanced
MIT App Inventor•2024Varies350h (Large)

This project aims to enhance the multi-select plugin in the Blockly workspace by integrating the IDragger feature of Blockly 11. Currently, the plugin uses a custom block dragger, which has limitations, such as the inability to select certain workspace components like comments. The project proposes to implement a new MultiselectDraggable class that captures all selected blocks, allowing for individual drag operations. Additionally, the proposal includes testing the updated multi-select plugin with other existing Blockly plugins to ensure compatibility and resolve any conflicts. The tentative schedule outlines tasks for integrating IDragger and cross-testing with other plugins, with deliverables including code implementations, test environments, reports on errors and fixes, and a tentative timeline for completion. Future work suggestions include fixing issues related to the DragSelect library, improving performance, and integrating the plugin into App Inventor.

javagwtgoogle app engine+7
Student: Chang Min Bark
Code

Sandboxed and Deterministic Proc Macro using Wasm

intermediate
The Rust Foundation•2024Varies175h (Medium)

Add experimental support to rustc for building and running procedural macros as WebAssembly. Procedural Macro crates can opt in for being compiled to WebAssembly. This wasm-proc-macro will be a wasm blob sandboxed using WASM. It will interact with the compiler only through a stream of token and no ability to interact with the outside world.

pythonrust
Student: Apurva Mishra
Code
Proposal

Strimzi - Bridging HTTP to Apache Kafka.

intermediate
JBoss Community•2018Varies175h (Medium)

<p>Strimzi is a project about running Apache Kafka on Kubernetes and OpenShift. An important component of Strimzi is Amqp-Kafka bridge which as the name suggests bridge Amqp clients to Apache kafka. The idea is to extend the capability of bridge to support HTTP client too. As proposed, The bridge will be able to provide an interface to link HTTP clients and kafka bridge.</p> <ul> <li>HTTP clients can publish messages to kafka.</li> <li>Clients can consume messages from kafka.</li> </ul>

androidjavaide+12
Student: Shubham Vashisht
Code
Proposal

Parallel Macro Expansion

advanced
The Rust Foundation•2025Varies350h (Large)

A lot of work has been done to parallelize the Rust compiler frontend, with notable success in code generation and some post-HIR lowering stages. Other critical components, such as lexical parsing and macro expansion, are still implemented serially. Macro expansion is fundamental in Rust, enabling code generation at compile-time based on patterns and user-defined rules in the source code itself. However, due to dependencies between macros and the strict ordering of name resolution, its inherently sequential nature poses a significant challenge for parallelization. Currently, macro expansion and import resolution are tightly coupled and executed sequentially, making parallel execution difficult. This project aims to develop a parallel and order-independent algorithm for these two processes, improving compiler performance while maintaining correctness. Addressing the dependencies and execution order constraints could significantly reduce compilation time and enhance the compiler's overall compilation speed.

pythonrust
Student: Lorrens Pantelis
Code
Proposal

Unicode Support for GCC Rust Frontend

intermediate
GNU Compiler Collection (GCC)•2023Varies175h (Medium)

The Rust programming language supports Unicode in identifiers, similarly to other modern programming languages such as Go, C++, and JavaScript. The main goals of this project are supporting Unicode identifiers in GCC Rust and improving their location information for better error messages.

cc++openmp+3
Student: Raiki Tamura
Code
Proposal

lpython: Interactive shell and improved debuggability

advanced
Python Software Foundation•2024Varies350h (Large)

lpython is a statically typed compiled programming language with syntax inspired by Python programming language. lpython also aims to have first-class support to work with Python and C libraries. lpython has multiple backend targets like C, C++, and LLVM IR that can be compiled to target executables with appropriate C/C++ compiler or the LLVM compiler toolchain. As lpython is statically typed and ahead-of-time compiled it offers much better performance than cpython. The current state of lpython is not feature-complete nor bug-free. I propose to add an interactive shell for lpython, so that the developers can quickly prototype ideas, and improve the debug information generated for the LLVM backend so that users can execute a single line of code at a time and pretty print variables and complex datatypes.

pythonmercurialjavascript+3
Student: Vipul Cariappa
Code

PyElastica: Binding PyElastica with Elastica++

advanced
Python Software Foundation•2024Varies350h (Large)

The goal of the proposal is to implement bindings for C++ based Elastica++ to the python based PyElastica, to achieve speedups. It covers selecting a suitable C++ build system and setting up the compilation architecture, writing binding code using pybind11 or alternative methods, benchmarking against existing Python implementations, expanding unit tests, polishing documentation and typestubs, and updating the CI pipeline for building and testing on multiple Python versions.

pythonmercurialjavascript+3
Student: Ankith
Code
Proposal

Reorganizing tests/ui/issues

intermediate
The Rust Foundation•2026Varies175h (Medium)

Currently there is obsolete `tests/ui/issues`directory in `rustc` test suite which was used to store regression tests in it. Now with the growth of compiler this folder is basically unmanageable, test names don't explain object of testing, and they are not sorted in any way. Nowadays new regression tests are getting into the fitting `tests/ui/`subdir, and my project proposes reorganization of `tests/ui/issues` directory by observing and sorting each test to matching directory.

pythonrust
Student: zedddie
Code
Proposal

Prepare stable_mir crate for publishing

intermediate
The Rust Foundation•2025Varies175h (Medium)

StableMIR aims to provide a stable Rust compiler interface via a stable_mir crate on crates.io, shielding external tools from internal changes. Currently, the dependency between stable_mir and rustc_smir requires hard-coded versions in the rustc_smir crate, making it harder for the user to select which stable_mir crate to depend on. This project will invert the dependency, refactor the crates, and establish infrastructure—including build checks, testing workflows, and automation, easing maintenance for rustc developers and future contributors.

pythonrust
Student: Makai
Code
Proposal

General Graphics Improvements

advanced
Scilab Enterprises•2016Varies350h (Large)

<p>This project aims to polish the current graphics features of Scilab such as zooming, datatips and interactive curve edition through plotting. Usually the Scilab is widely used by students and engineers as a completely free and open source numerical software solution for fast prototyping and data visualization. In this context the user experience is dictated by how well one can view and easily interact with its data. This makes the plotting capabilities and interactions, besides performance, a key factor of the perceived easiness and software quality.</p>

cjavac+++2
Student: Caio Souza
Code
Proposal

gccrs - Inline Assembly Support

advanced
GNU Compiler Collection (GCC)•2024Varies350h (Large)

gccrs is a full alternative implementation of the Rust language ontop of GCC with the goal to become fully upstream with the GNU toolchain. One of the steps to reach its implementation counterpart's parity (rustc) is the support of inline assembly. Enabling this feature allows programmers to work on low level situation where some extra performance is always needed. The project focuses on adding implementation for two built-in Rust macros: asm!(), and global_asm!(). The gcc compiler will be able to detect parse the assembly code within asm!, and global_asm! macro, converting them to gcc assembly format to eventually generate code.

cc++openmp+3
Student: jjasmine
Code
Proposal

Editor Support for Typed Lua

intermediate
LabLua•2017Varies175h (Medium)

<p>Lua is a powerful, efficient, lightweight and dynamically typed scripting language supporting a variety of different programming paradigms. Typed Lua extends Lua with an optional type system allowing the use of both static and dynamic typing in the same code base, while preserving existing Lua run-time semantics. It achieves that by introducing optional type annotations and applying local type inference. This richer type system not only enforces stronger program behavior guarantees, but also facilitates the development of more powerful developer tools.</p> <p>Programmers nowadays expect that their editors/IDEs suggest accurate completion candidates, perform asynchronous - as you type - error checking and support type queries such as "go to definition" or "find all references".</p> <p>The main goal of the project is to add such features for Typed Lua in a wide range of popular editors. Furthermore, it shall be investigated how a modern, asynchronous editor plugin architecture could be designed.</p>

luacéuelasticsearch+5
Student: Marc André Tanner
Code
Proposal

Pharo Dj App With Phausto, Spec and Bloc

intermediate
Pharo Consortium•2026Varies175h (Medium)

To build a DJ application with two decks in Pharo, I will make use of three libraries: Phausto for audio file playback (at variable speed), equalization, and filtering. Spec for building a browser to visualize audio files in a folder together with their metadata, and to organize these files into playlists. Bloc for the visualization of audio waveforms and the rendering of UI widgets to control playback speed, pitch, levels, the equalizer, and filter cutoff and resonance. As a first step, Phausto will be used to load and simultaneously play two audio files, mixing them via the Phausto API. Once the audio engine is in place, a Spec application will be built to browse audio files and load them into either of the two decks. With the file browser complete, a conventional user interface will be added to control the mix between the two tracks and their equalization. The Phausto standard library will then be used to add a delay effect per deck. With the DJ application running, final polish can be applied in the form of BPM detection and track quantization, which requires implementing peak detection for audio files within Pharo. Deliverables: The Spec application with audio file browsing and audio playback will be delivered before the first evaluation. The audio visualization and UI built with Bloc will be delivered halfway between the first and final evaluations. Extra features (BPM detection and quantization) will be added and tested before the final evaluation.

smalltalkroassalpolymath+7
Student: Lucia Cardin
Code
Proposal

Faust Integration in HISE

intermediate
GRAME•2022$3k–$6.6k175h (Medium)

The proposed GSoC project aims at integrating support for the Faust audio programming language into HISE, an extensive framework for the creation of sample-based virtual musical instruments. There are multiple ways to accomplish the integration, ahead-of-time compilation and just-in-time compilation, each with their specific benefits and shortcomings. The most straight-forward method involves ahead-of-time compilation of the Faust code into a dynamic library which the HISE instrument can interface with. This works well for finished products which will be exported and compiled once, but run many times. During prototyping, however, build time is essential and relinking the complete instrument would be excessive. In that case machine code will be generated just-in-time (JIT) from the Faust source code whenever it is modified without recompiling or linking the rest of the instrument. Faust already provides the necessary mechanisms for just-in-time compilation via LLVM, which will be tied to suitable data structures inside HISE. Lastly HISE also provides an integrated development environment (IDE) with a syntax-highlighting text editor to the instrument developer. Programming the instruments in Faust should be an on-par experience to the developer when comparing to other supported languages, e.g., SNEX and JavaScript. Therefore the existing development environment will be extended to support the Faust language, while allowing the developer to still use their editors and tools outside of HISE.

cpythonjavascript+3
Student: etXzat
Code
Proposal
Showing 1321 - 1344 of 3883 Projects
5455565758
Proposal
Proposal
Proposal
Proposal