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

Cluster of Priority Features (Focused around User Profile, Compose Box, and Stream Settings)

intermediate
Zulip•2023$3k–$6.6k

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)

For my GSoC project, I wish to implement bigger full-stack features while continuing to investigate and fix bugs in the areas I'm familiar with. These areas include the settings panel, user Profile, compose box, popovers, message feed UI, and left sidebar. The issues I specifically aim to solve this summer are: - Unmute Topics within a muted stream - Add subscribe widget to user profile popover - Unsubscribed tab in stream settings - Make it possible to cancel uploads - Show empty conversation in left sidebar - Migrate manage user/bot to user profile - Special title and bug fixes for narrow titles. - copy drafts feature - Major bug fixes in user profile modal.

pythonjavascriptdjango+5
Student: Palash Baderia
Code
Proposal

Customizable Appearance of Canvas Controls

beginner
Inkscape•2023Varies90h (Small)

The proposed project aims to improve the visual appearance of canvas controls like nodes and handles, which are currently very unappealing and outdated, by introducing a customizable CSS file that will specify the styles of the controls. A default CSS file will be shipped with Inkscape, which can be overridden by a user-customized CSS file. The technical implementation would involve parsing the CSS file through libcroco and rendering the controls using cairo. The project aims to write simple and extensible code improving upon the existing hard-coded implementation.

pythonc++css+6
Student: sanidhyas3s
Code
Proposal

Rust and GTK 4 Bustle Rewrite

intermediate
GNOME Foundation•2023Varies175h (Medium)

Bustle is a powerful graphical tool for analyzing D-Bus activities. The current implementation, while still functional, cannot take advantage of the latest developments in the platform and is less accessible to potential contributors and users. However, through a GTK 4 and Rust rewrite, the tool could take advantage of more ergonomic libraries such as zbus, gtk4-rs and LibPCAP bindings and access to newer APIs such as Libadwaita widgets and the ListView API. The project will begin on continuing the basic implementation. Then carrying on to porting from GDBus to zbus, implementing the diagram, improving the loading implementation, implementing recording, and adding multiple recordings and opened files handling. For future deliverables, the following can be implemented: pair of logs opener, statistics view, command line interface, and exporting to other formats.

cpythonjavascript+4
Student: Dave Patrick Caberto
Code
Proposal

High Fidelity simulation using Unreal engine

intermediate
UC OSPO•2023Varies175h (Medium)

Existing frameworks for simulation autonomous vehicles use a gazebo simulator with ROS, which limits the development to only Python and C++ programming languages. I intend to develop an unreal engine-based simulator which the OSAVC team can use for development, taking inspiration from Airsim. This allows us to do high-fidelity simulation with the support of programming languages,i.e. Python and C++. In this project, I will add an example of simulating a custom-built CAD model and additionally controlling it using Matlab (Simulink). So that in future, the Vehicle control algorithm design and validation process will become easier. I intend to add detailed documentation of the weekly development period and examples to smoothen future development. Upon successful completion, the project will deliver a powerful simulator with realistic simulation using an unreal engine and the ability to test different vehicles like cars, UAVs and Rovers in future.

pythonc/c++visualization+5
Student: damodardatta
Code
Proposal

OpenGLES Acceleration for DL

advanced
BeagleBoard.org•2023Varies350h (Large)

Deep learning is a subset of machine learning that involves the use of neural networks with multiple layers. Neural networks consist of multiple layers of interconnected nodes, each building upon the previous layer to refine and optimize the prediction. The main goal of the project is to accelerate as many types of layers as possible using OpenGLES and Darknet as deep learning frameworks. Accelerating the performance of deep learning models is crucial for real-time applications. GPUs are widely used to accelerate the computations in deep learning models, as they can perform many operations in parallel.OpenGLES is a widely used graphics API that provides a framework for performing computations on GPUs. By using OpenGLES to perform computations, we can leverage the parallel processing power of the GPU to accelerate the performance of deep learning models.

cpythonlinux+11
Student: Pratham Deshmukh
Code
Proposal

LDAP Capture Capabilities

intermediate
Metasploit•2023Varies175h (Medium)

This project aims to deliver a module to add capture capabilities over the LDAP protocol. This module will allow the capture of LDAP traffic and logging of the captured information like authentication information. The logged information can be used by other auxiliary and post-exploit modules to perform future actions.

crubyasm+3
Student: JustAnda7
Code
Proposal

Refactor frontend-markdown processor using an extensible CommonMark parser

intermediate
Zulip•2023Varies175h (Medium)

Markdown provides a great ability to format messages and write structured documents using plain text format. Zulip uses two different markdown processors: for the backend, it is Python-Markdown and for the frontend, it is marked.js. While the backend markdown processor is highly extensible but the current frontend markdown processor doesn’t allow the same. Moreover, it is not upgradeable because of the Zulip customisations. The goals of this project are: Refactor the frontend-markdown processor with CommonMark parser. Make the same extensible for Zulip’s custom features like @-mentions. I’ll take the reference from commonmark.js to write the CommonMark parser for our frontend-markdown processor. And to make it extensible, I'll use the upstream marked.js. In parallel to this, I’ll focus on works in the markdown area. Integrating them with the Zulip will help to increase the overall users’ experience. The list of them are: Add support for link shortener Re-enable backslash escape inline pattern Add support for online mentions Add support for importing avatar from GitHub on account creation

pythonjavascriptdjango+5
Student: Akshat Akshat
Code

Autosave Feature

intermediate
Purr Data•2023Varies175h (Medium)

When working on a project in Purr Data, saving regularly is important to avoid losing any changes or progress. The auto-save feature provides an added layer of protection by automatically saving the project at set intervals, such as every 10 minutes. In case of a sudden power outage or system crash, the auto-save feature can help to recover the project files, reducing the risk of losing valuable work. This feature also helps to reduce the likelihood of accidentally closing the program or forgetting to save changes. The auto-save feature in Purr Data is a helpful tool for ensuring that project data is automatically saved and backed up regularly, providing peace of mind and added protection against data loss.

javascriptc/c++node.js+9
Student: Prakhar Agarwal
Code
Proposal

TensorLy: Multi-backend Tensor API Libraries

advanced
Ivy (lets-unify.ai)•2023Varies350h (Large)

The aim of this project is to use IVY as a framework and build that into TensorLy project so that TensorLy would be usable with any of the frameworks supported by IVY. This will allow TensorLy users to switch backends via IVY’s backend handler rather than their own native backend handler. Set of deliverables are as follows: Implementing the desired functions in tensorly/backend/ivy_backend.py which will enable users to now use IVY as a framework in TensorLy. Implementing TensorLy’s abstraction layer (functionalities like Tensor Decomposition, Tensor Regression and Tucker Tensors) by using IVY as the framework. Implementing new functions into Ivy’s Functional API which exists in TensorLy’s API but currently not present in IVY’s Functional API (for example: context, index_update, ndim, sign, logsumexp, Conj). Creating demos that demonstrate how the functionalities can be used while building projects using TensorLy when IVY’s backend handler is being used. Running tests and implementing benchmarks showcasing the difference in runtime performance. Documenting the benchmark evaluations in a notebook for further research. Extending features with suggestions from the community.

pythoncythontensorflow+2
Student: Amitesh Vatsa
Code
Proposal

Interface to interact with Brickschema

intermediate
BRL-CAD•2023Varies175h (Medium)

While Industry Foundation Classes (IFC)—the leading international standard for exchanging building data—offers generic descriptions for smart building equipment relationships, the BrickSchema semantic structure makes the format more scalable, simplistic, and fine-tuned. This project intends to further bridge the IfcOpenShell and BrickSchema open-source communities and shared mission to evolve the common exchange of building information. By upgrading the bare-bones BrickSchema module in IfcOpenShell’s Blender addon, BlenderBIM, this project will allow users to seamlessly edit Brick entities and relationships. Features include entity editing, feed relationship editing, undo/redo support, and save-to-file utilities. This is particularly important to the continued management phase of a building’s life cycle, so this project will contribute to BlenderBIM’s coverage over building lifetimes. Furthermore, although the IFC and Brick schemas exist separately, there is continued industry interest in utilizing IFC to enhance the granularity of BrickSchema—the project aims to contribute to this endeavor.

pythonc/c++opengl+6
Student: Riley Wong
Code
Proposal

Modern C porting of Gentoo packages

intermediate
Gentoo Foundation•2023Varies175h (Medium)

Back in 1999, a new revision of the C standard removed several backward compatibility features. However, GCC still accepts these obsolete constructs by default. Support for these constructs is confusing to programmers and potentially affects GCC's ability to implement features from future C standards. But newer versions of compilers (for example Clang 16, expected March 2023) are planning on becoming significantly stricter with the C code they will accept or reject. This is a huge problem for the general Linux ecosystem. Even worse is that some of these failures are silent and lead to incorrect behaviour at runtime. Extra care must be taken to detect this and we must prioritize these cases because they're the most harmful. Also, in the coming years with C2x (likely C23), additional changes like removing certain depreciated prototypes will be made. All of these changes will affect Gentoo packages in the following ways: Lots of packages fail to build with these settings Sometimes packages build successfully but their ./configure scripts have mis-detected features or otherwise made the wrong conclusion about the system because they expect a test to succeed when it now fails.

pythonc/c++perl+7
Student: listout
Code
Proposal

Adapting IR Load Semantics to Freeze All or Freeze Only Uninitialized Data

advanced
LLVM Compiler Infrastructure•2023$6k–$13.2k350h (Large)

This proposal outlines a continuation of the Google Summer of Code (GSoC) 2022 topic to move uninitialized memory to poison semantics. Starting with GSoC 2022 and continuing over the last year several potential solutions have been developed and shared with the community via patches and RFCs. This has helped to build further understanding of both front-end and internal LLVM limitations. Based on the latest RFC two possible semantic solutions have been identified that allow loads to migrate to poison by default and provide backward compatibility with the current load undef semantics. This is accomplished by either freezing all bits regardless of initialization state or byte-level freezing based on initialization state. By implementing both solutions real-world performance metrics and maintenance impact can be evaluated by the LLVM community. This work will increase use of poison semantics further contributing to the eventual deprecation of undef.

cllvmc+++3
Student: John McIver
Code

API and Mobile App: E2E encryption and security improvement in Talawa and Talawa-API

intermediate
The Palisadoes Foundation•2023Varies175h (Medium)

This proposal aims to implement E2E Encryption in the Talawa Ecosystem from the ground up. The initial aim will be to implement secure credential transfer and session storage, followed by E2E encrypted private chats. Then I will build upon the idea to implement the same for group chats and media files. In the end, all of this will be implemented in Talawa Admin and finally testing and documentation will be done.

javascriptmongodbnode.js+5
Student: literalEval
Code
Proposal

Improving user errors & Error Code Support for GCC Rust Frontend

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

The goal of this project is to enhance the user experience of gccrs by enabling it to emit error codes similar to rustc. This will help bridge the gap between the two test suites and eventually enable the rustc testsuite to run on gccrs. The project involves implementing necessary changes in gccrs to emit rustc error codes throughout its frontend code. Additionally, it entails expanding the code responsible for error emission to incorporate greater functionality. Furthermore, a comprehensive comparison between the rustc and gccrs test suites will be conducted to improve stability. The ultimate outcome will be an improved user experience for gccrs users, with an increased number of error emissions in various contexts and more informative hints on code resolution. By bringing gccrs closer to parity with rustc, this project aims to enhance its accessibility for users and developers alike.

cc++openmp+3
Student: Muhammad Mahad
Code

Dynamical Systems with Multiple Functions

intermediate
SageMath•2023Varies175h (Medium)

Sage does not have support for dynamical semigroups, which are dynamical systems involving multiple functions. This project aims to create a class that encapsulates dynamical semigroups, which can be use to further explore this field of mathematics.

pythoncython
Student: Dang
Code
Proposal

[Mpi4py in DaCe] Add support for Mpi4py in DaCe

intermediate
Scalable Parallel Computing Laboratory•2023Varies175h (Medium)

In this project, my job is to extend the existing Dace Distributed framework to support MPI4PY syntax. This will mainly involve extending the existing Dace parser to support MPI4PY syntax, as well as implementing MPI I/O and Comm World functionality. The entire implementation will be validated through a series of unit tests and mentor evaluations.

pythonc++mpi+2
Student: Fu-Chiang
Code
Proposal

Kotlin Multiplatform Library Version of Flogger

intermediate
Kotlin Foundation•2023Varies175h (Medium)

The project aims to create a Kotlin Multiplatform Library version of Flogger, which is a popular logging library for Java. The new library will work on multiple platforms including JVM/Android, Kotlin/Native (iOS), and Kotlin/JS. The goal is to provide a commonly-needed logging tool that works across various platforms, making it easier for developers to write better and more readable logging code. The project will involve designing and delivering a Kotlin Multiplatform library, with a greater priority on JVM/Android and Kotlin/Native (iOS) than other targets. Additionally, the project includes implementing integration with Logcat on Android, providing readable documentation with examples on how to use the library, and publishing the library on Maven Central.

gradlekotlinjvm+3
Student: Giancarlo Buenaflor
Code
Proposal

Demonstrating 2D Arrangements Embedded on the Sphere

intermediate
CGAL Project•2023Varies175h (Medium)

Abstract: Recently the "2D Arrangement" package of CGAL has been enhanced with the support of 2D arrangement of geodesic arcs embedded on the sphere. Demonstrating such an arrangement graphically requires rendering in three dimensions, a.k.a. 3D graphics. Implementation Plan: The project will proceed in 2 main-stages. The output of the second stage will be a stand-alone program with its source code and the corresponding documentation. First stage: Examining the 2D arrangements & 3D polyhedron demos and also Efi Fogel’s initial implementation which has its own set of dependencies. Second stage: Implementation of the 3D arrangements on the sphere program. Here, I will incrementally port Efi Fogel’s program to a stand-alone program that solely depends on CGAL and QT5.

githubc++git+4
Student: Deniz Diktas
Code
Proposal

Implement Incremental Re-Parsing in SwiftParser

advanced
Swift•2023Varies350h (Large)

Considering the performance, instead of reparsing the entire file every time, we could speed up the parsing procedure with the information provided by old AST, which is an ability provided by the old parser. In the old implementation, this feature was only applied to CodeBlockList and MemberDeclList. In the new implementation, It would be nice to apply node reusing to other syntax collections e.g. exprList, functionParameterList, etc. Also, It would be good to allow more fine-grained reusable nodes via expanding the definition of nodeAtCursorCanBeReused to allow reusing nodes such as FunctionDeclSyntax where only identifier is changed.

llvmc++cmake+5
Student: Ziyang Huang
Code
Proposal

Deriving planetary surface composition from orbiting observations from spacecraft

intermediate
Machine Learning for Science (ML4SCI)•2023Varies175h (Medium)

Multiple robotic spacecraft have been sent by NASA to collect orbital remote sensing data, which is used to analyze surface composition. Gamma-ray spectrometers are among the sensors used for this task. They collect position-dependent energy spectra whose shape is a function of the components from different elements present in the area observed by the sensor at a particular time. This data can be used to infer the relative abundance of each element (through a process called unmixing) and to map their distribution across a planet’s surface. However, accurately deriving abundance just from gamma-ray spectra is an intractable problem. Machine learning (ML) has been widely used to address intractable problems, including the unmixing of spectral signatures in the visible and near-infrared (VNIR) region of the electromagnetic spectrum. Therefore, this proposal outlines the development of an ML model for estimating elements from gamma-ray spectra. This goal consists of two sub-objectives: (i) identification of the best model/architecture using data from the Lunar Prospector Gamma-Ray Spectrometer (GRS); (ii) a trained model for estimating elemental abundances from GRS data.

pythonmachine learningc+++2
Student: Sandeepan Dhoundiyal
Code

Integrating ftbench into FreeType's Build Structure: A Performance Benchmarking Automation Project

beginner
FreeType•2023Varies90h (Small)

The goal of this project is to improve the ftbench program in FreeType's build structure for easier performance testing. The current manual process is slow and prone to errors. The plan is to create an automatic system to compare the performance of an older version with the current one. The project involves making a way to compare performance, creating an easy-to-read HTML report, and adding the report to FreeType's CI on GitLab. The final results include the comparison method, the HTML report, the CI integration, and clear documentation.

cpythongnu make+4
Student: Ahmet Göksu
Code
Proposal

Improving Compile Times

intermediate
LLVM Compiler Infrastructure•2023Varies175h (Medium)

This project aims to reduce the amount of time that LLVM spend on compiling code by focusing on hotspots in the code identified by profiling workloads both with and without optimization passes enabled. The main possibilities for improvements are identified in SelectionDAGISel (specifically DAGCombine), InstCombinePass and InlinerPass. Aside from these, the analysis passes and some machine passes are also identified as good opportunities for optimization. At the end of this project, there will be a noticeable improvement in compile times for the test cases considered and an overall improvement (if small) in general compile times for all inputs. Fatal cases from the LLVM GitHub issues page where compile time explosions occur will also be considered to fix edge cases where super-linearity of the optimizations come into play or where an extreme amount of input causes outliers in the compile time share of certain passes.

cllvmc+++3
Student: Dhruv Chawla
Code
Proposal

Develop a morphological analyser

intermediate
Apertium•2023Varies175h (Medium)

I will be working on creating a morphological dictionary for Kumaoni language and then use it for implementing a morphological analyzer. There are very few digital texts on Kumaoni language and no digital dictionary for it is available.

pythonc++xml+4
Student: Natasha Singh
Code
Proposal

Enhancements in linear algebra

intermediate
SageMath•2023Varies175h (Medium)

Sage incorporates state-of-the-art libraries for exact linear algebra computations, such as matrix multiplication, reduced echelon form, linear system solving, when the coefficients are in an exact domain such as the integers or finite fields. However, several aspects make the integration of these libraries not yet fully satisfactory. For example, working over a prime field with a prime below about 20 bits, the mere creation of a zero matrix in SageMath takes roughly as long as the call of the underlying fast reduced echelon form procedure (performed by LinBox / FFLAS-FFPACK in this case). Still about FFLAS-FFPACK: several available tools in this library are not offered through the Sage interface, constraining the user experience; for example, some pivoting strategies are not available, despite their usefulness in some situations e.g. when one is interested in the preservation of some rank profile properties. Finally, the integration of linear algebra implementations from Flint has been initiated, with a good amount of work already done, but is not fully finalized and has not been merged into Sage. This project aims to make this kind of enhancements, which would lead to more efficient and more versatile finite field linear algebra operations in Sage.

pythoncython
Student: Marie B
Code
Proposal
Showing 3625 - 3648 of 13453 Projects
150151152153154
Proposal
Proposal
Proposal
Proposal