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

bowtie-perf: a Performance Tester for JSON Schema Implementations

advanced
JSON Schema•2024Varies

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)

Bowtie is a meta-validator of the JSON Schema specification, giving users a way to use and compare implementations supported. Bowtie currently only supports validating instances against a given JSON Schema using the specified implementation and comparing implementations to one another on the basis of how correct an implementation is wrt the JSON Schema specification. This project primarily focuses on creating a performance tester for implementations and integrating it within Bowtie itself. This would allow implementations to be performance tested and also the comparison b/w the performance of implementations enabling performance optimisation of the various implementations giving users another dimension to compare different implementations on.

pythonjavascripttypescript+2
Student: DhruvSingh
Code
Proposal

mesa-frames: Vectorized Operations for Performance and Scalability

advanced
Project Mesa•2024Varies350h (Large)

mesa is renowned as the premier Python framework for agent-based modeling, combining powerful functionality with ease of use. However, the framework's reliance on standard Python objects to represent agents poses scalability challenges, hindering performance as the number of agents grows. This limitation renders the execution of even modestly sized models, comprising a few thousand agents, impractical. The community has long requested a more performant version of mesa. While a refactor using Cython could address performance issues, it would introduce significant complexity and require users to adapt their methods to Cython, compromising Python's simplicity. The mesa-frames initiative proposes leveraging vectorized operations on dataframes, utilizing libraries such as pandas and polars, to enhance performance and scalability. This approach benefits from the optimized, out-of-the-box operations these libraries provide and their intuitive, well-documented APIs, which simplify custom agent creation.

pythonui/uxLLMs+4
Student: Adam Amer
Code

Spatial (GIS) functions in MariaDB

advanced
MariaDB•2024Varies350h (Large)

As MariaDB continues to evolve and improve, MySQL users may consider it as a better alternative. The absence of some spatial functions could be a drawback for some of them and potentially make the migration process difficult. My goal is to implement the following spatial functions: ST_IsValid, ST_Validate, - MBRCoveredBy, ST_Collect, ST_GeoHash, ST_Simplify, ST_LatFromGeoHash, ST_LatFromGeoHash and ST_PointFromGeoHash. For each new function to implement, I will start by importing the corresponding tests from the MySQL test suite. These tests serve as an optimal starting point. Given that the primary goal is to ensure compatibility between MySQL and MariaDB, passing the same set of tests on both codebases ensures uniform behaviour. Additionally, these tests serve as a valuable supplement to the documentation, offering detailed insights into the expected behaviour of each function while also documenting edge cases. Moreover, as new tests are written when fixing a bug, we can mitigate the risk of encountering previously resolved issues by the MySQL developers. The spatial functions already implemented, are defined in the sql/item_geofunc.h file. The new functions will also be placed in the same file and will be implemented by extending the interfaces that are already defined. For instance, ST_IsValid will extend Item_bool_func_args_geometry which is the class that defines the interface for all the MariaDB native functions returning boolean measurements of a single GEOMETRY argument. In MySQL, the functions ST_GeoHash(longitude, latitude, max_length) and ST_GeoHash(point, max_length) do not return a special datatype but a string. I want to make a more in-depth analysis regarding this function and evaluate if defining a custom datatype would be a viable option and if it would grant meaningful performance improvements.

cmysqlmariadb+7
Student: Stefano Petrilli
Code
Proposal

add threats by element for STRIDE/LINDDUN/PLOT4ai/CIA/DIE

intermediate
OWASP Foundation•2024Varies175h (Medium)

Reinstating automated threat suggestion per element was a feature in the threat dragon threat model designing system. Hence, upon migration to Vue.JS framework, not all features where migrated as that would take much effort to be completed. Yet, the project is continuously reinstating old features with new ones to make threat dragon an even better threat model designing system. This specific project is about suggesting threat type automatically for an element upon creation when drawing a threat model. My solution is about tracking our current existing threats for this element. and upon creating a new threat, the algorithm would check the existing threats and with the map it has for matching suggestions, it would pick the threat type suggestion for the next created threat.

pythonjavascriptjava+10
Student: Mohamed El-Bohy
Code

Smart Scheduling App Assistant

intermediate
rocket.chat•2024Varies175h (Medium)

Setting a calendar event is a small, but important process in our day-to-day job. It can take some of your time when you want to set up another meeting if you 1) Already have a tight schedule; 2) Your coworkers are in different time zones; and 3) Have to switch back and forth between the calendar and the messaging app. Hence, this project aims to streamline the process using a scheduling assistant, that can create meetings or set up a reminder using a prompt. A slash command can simply trigger it through a messaging app (in this case, Rocket.Chat). The solution will involve a lot of large language models (LLM) experiments for the user prompt. Therefore, this project can act as a semi-research in which the result of LLM experiments can be used to approach similar cases.

javascriptwebrtcmeteor.js+18
Student: Maria Khelli (Deprecated)
Code
Proposal

Chromestatus.com - tech stack unification

intermediate
Chromium•2024Varies175h (Medium)

The project focuses on the modernization of Chromestatus.com, a critical tool for tracking feature launches in Blink. This will be achieved through the migration of the codebase from JavaScript to TypeScript and the implementation of the next version of the Chromestatus API using OpenAPI. The goal is to improve the health of the codebase, making it more maintainable and robust, while enhancing developer productivity and code quality.

pythonjavascriptjava+2
Student: Mark Xiong
Code
Proposal

Implementing RISC-V Cache Management Operation Extensions in OpenPiton

advanced
Free and Open Source Silicon Foundation•2024Varies350h (Large)

The project aims to integrate RISC-V Cache Management Operation (CMO) extensions into the OpenPiton processor framework. This integration will improve cache coherency and management, resulting in enhanced performance and efficiency for systems built on the OpenPiton platform. The project will involve understanding the RISC-V CMO specifications, modifying the OpenPiton cache subsystem, and extensive testing to ensure compatibility and performance improvements.

pythonjavascriptfpga+11
Student: Suraj Shirvankar
Code
Proposal

Modernize CC Resource Archive

intermediate
Creative Commons•2024$3k–$6.6k175h (Medium)

The goal of this GSOC program is to modernize the CC Resource Archive website by implementing a comprehensive visual overhaul to align with current Creative Commons aesthetics and functionality standards. Utilizing the Internal Design System (Vocabulary), the project aims to upgrade the visual design, implement semantic, accessible, and standards-compliant HTML, CSS, and JavaScript, and improve user experience (UX) for resource submission while ensuring site stability on GitHub Pages. Through these efforts and solid documentation, the revamped Resources Archive will meet modern standards, enhance usability, and facilitate maintainability for both users and developers.

pythonpostgresqljavascript+6
Student: Ayush Sahu (Murdock9803)
Code
Proposal

Automating Release Notes Generation & Simplifying Linux Download Experience

intermediate
Synfig•2024Varies175h (Medium)

This project aims to improve and automate the generation of release notes for Synfig and make Synfig easier for Linux users to download. This is done by: 1—Creating a script that uses Synfig's repository git conventional commits history to automatically generate nice-looking Synfig release notes grouped by change type (fix, feature, etc.), automatically adding them to new GitHub releases, and showing contributors using a GitHub bot how their pull requests will affect the release notes when merged. This aims to enhance the pull requests and release notes descriptions and give Synfig’s pull requests a more professional feel to attract more contributors. 2—Currently, Synfig is bundled to work on Linux using AppImage v1.0 complicated scripts. AppImage v1.0 is outdated and has the critical issue that it doesn’t work smoothly on newer systems (Ubuntu v22.04 and others); the AppImage scripts will be updated to use the latest AppImage version to run smoothly on old as well as newer Linux distributions.

c++gtkgtkmm+2
Student: Ahmed Khaled (Akayiz)
Code
Proposal

Awesome Game Demo project(350 hours)

intermediate
International Catrobat Association•2024Varies350h (Large)

ReZero is a rogue-lite, Dead Cells-inspired action-platformer, allowing you to explore a sprawling, ever-changing castle… assuming you’re able to fight your way past its keepers. To beat the game, you’ll have to master 2D "souls-lite combat" with the ever-present threat of permadeath looming. Kill, die, learn, repeat. The gameplay will be very similar to Dead Cells with cinematic cutscenes, high-paced action, and magic items. This project aims to showcase the true potential of Pocketcode by creating a good quality high-level game. The game will be playable on a phone as well as on smart TV.

javascriptandroidswift+4
Student: Tushar Banik
Code
Proposal

Seldon-Code: Python Bindings for Seldon

intermediate
Python Software Foundation•2024Varies175h (Medium)

This project focuses on bridging the Seldon C++ engine with Python using Pybind11, enabling seamless interoperability between the two languages for Seldon. It involves creating Python bindings to expose the functionality of the C++ engine to Python to facilitate the integration of simulations with post-processing and visualisation tools in the Python ecosystem. Afterward, ensuring the integration is correctly configured by conducting comprehensive testing to validate its functionality using pytest. To facilitate broader adoption across diverse communities, our plan is to package the bindings into a format installable via pip for streamlined distribution and usage. We will utilise Python wheels to create the package, ensuring compatibility across various platforms. Additionally, we'll employ cibuildwheel to enhance compatibility and streamline the build process. The primary objective is to make the robust capabilities of the Seldon engine accessible to Python users through efficient bindings and packaging. Our goal is to empower Python users with the robust capabilities of the Seldon engine, revolutionising the field of Opinion Dynamics.

pythonmercurialjavascript+3
Student: Daivik K. L. Karbhari
Code
Proposal

Embedded Chat 2024

intermediate
rocket.chat•2024Varies175h (Medium)

Embedded Chat provides enough features to be integrated into various web applications as an in-chat app, but its current UI lacks personalization and configurability. This proposal focuses on enhancing the UI by making components modular, providing pre-built themes, and allowing users to modify the UI using a layout editor. It also aims to improve security via HTTP-only cookie-based authentication and enhance configuration capabilities by making the instance configurable through RC-app.

javascriptwebrtcmeteor.js+18
Student: Zishan_Ahmad
Code
Proposal

Self-Supervised Learning for End-to-End Particle Reconstruction for the CMS Experiment

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

The End-to-End Deep Learning project within the CMS experiment at the Large Hadron Collider plays a critical role in identifying and reconstructing single particles, jets, and event topologies in collision events. This proposal aims to leverage state-of-the-art Self-Supervised Learning (SSL) techniques to develop robust models that outperform existing supervised baselines. By exploiting unlabelled data, these SSL approaches can allow models to learn rich representations enhancing the efficiency and accuracy of particle reconstruction and identification tasks at fine-tuning stage with labelled data. I-JEPA (Joint-Embedding Predictive Architecture) is a new approach, which aims to improve the semantic level of self-supervised representations without relying on extra prior knowledge encoded through image trans- formations. Given a context block, I-JEPA is trained predicting missing information in an abstract representation space. The targets are representation blocks obtained by dividing the input into non-overlapping patches and encoding them with a target-encoder. A subset of these representations is randomly sampled for loss computation. The context block, on the other hand, is derived from a single block randomly sampled from the input and processed through a context encoder. Overlapping regions between context and target blocks are removed to maintain a non-trivial prediction task. This approach represents a novel direction in self-supervised learning, addressing limitations of previous methods in producing high-level semantic representations suitable for various downstream tasks. I-JEPA has shown to be computationally efficient and outstanding results in image classification by linear probing its learnt representations. Deliverables: -Implemented SSL training pipeline. -SSL pre-trained model. -Fine tuned models on specific tasks. -Preprocessed datasets ready for training and evaluation. -Documentation covering implementation details, and experimental results

pythonmachine learningc+++2
Student: 3podi
Code

Validation Rule builder for the form builder

advanced
OpenMRS•2024$6k–$13.2k350h (Large)

This GSoC proposal aims to build a UI-based validation rule builder for the form builder. This user-friendly interface will eliminate the need for BAs to write complex JavaScript expressions for validation. Users can use the Rule builder in the interface to create conditional logic for the forms, and the form fields are rendered conditionally. The project will simplify validation creation by leveraging React Hook Form, reduce development time, and improve form maintainability through clear visual representations of validation rules.

javahtml5groovy+11
Student: Senthil Athiban
Code
Proposal

Scribe-iOS: Add multilingual translation and internationalized interfaces

intermediate
Wikimedia Foundation•2024Varies175h (Medium)

This project is centered on the Scribe keyboard app for iOS, which is a keyboard for language learners featuring translation and conjugation of foreign languages. The project in particular focuses on the implementation of localization for languages other than English, so that the app may be reached by many more users. This will be achieved by letting the user choose any keyboard of their liking to translate to the other language from. Additionally, the app itself will change its localization structure by relying on interchangeable JSON files, controlled by a separate project as a dependency for the app. This will also unify localization preemptively across the planned Scribe versions for Android and desktop as well. Smaller quality of life changes to core Scribe functionality are also planned, to improve user experience while using the app and keyboard.

javascripthtmlphp+7
Student: Jag-Marcel
Code

Scala Sampler for Functional Soundscapes

advanced
Scala Center•2024Varies350h (Large)

This proposal aims to develop a sampler instrument for the Sounds of Scala project. Sounds of Scala is a web audio and music library that runs on the Web Audio API via Scala.js. The sampler will be a digital music instrument with features including sample loading, playback controls, looping, and sample manipulation, along with advanced functionalities such as adjusting playback speed, pitch, and direction. Its applications range from music composition to educational purposes. This project seeks to expand the creative possibilities of the Sounds of Scala library, providing a valuable tool for music enthusiasts, developers, educators, and artists.

#scala#scala_lang#jvm+7
Student: Johanna Odersky
Code
Proposal

Synchronization Support in Internal Libraries

intermediate
Unikraft•2024Varies175h (Medium)

This project aims to integrate additional memory allocators with the Unikraft core library, enhancing support for multithreaded applications and expanding options for developers seeking specialized memory allocation solutions tailored to their needs.

cpythonxen+3
Student: Yang Hu
Code
Proposal

Compute summary for all detected packages.

intermediate
AboutCode•2024Varies175h (Medium)

The project aims to improve scanning accuracy by computing summary and license clarity scores for each package and its files, rather than for the entire scan. This involves enhancing package models, storing license detection references, and ensuring proper attribute collection for all package ecosystems.

pythonjavascriptc/c+++6
Student: swastkk
Code
Proposal

Enhancing User Interface for Viewing Grades

intermediate
Submitty•2024Varies175h (Medium)

After taking time to discuss the Submitty system with a professor that uses it daily as a grading tool for their classes, a place for improvement that I have found lies in the design and depth of accessible statistics and reports on how students are doing in their class. The Submitty system currently does not have a user-friendly way of viewing student grades for the instructor or TA. This creates an issue for the instructor in being able to clearly see how their students are doing in the class, trends in which problem sets might cause issues. Having a clearer user designed portion for instructors and graders to easily access understandable graphs, stats, and updates on student progress would benefit the Submitty system greatly by having a better user experience on the instructor and graders end.

pythonc++databases+5
Student: Sophia Oliinik
Code
Proposal

Enhancements for Erddap administrators

beginner
IOOS•2024Varies90h (Small)

Erddap is a data server used by many organizations as a way to download scientific data in various formats. However, adding these datasets to Erddap is by no means a simple task and this project aims to improve that experience for all Erddap administrators who wish to serve their datasets on their Erddap servers. The primary focus of this project would be to improve the existing XML parser that Erddap uses to incorporate new features done by either exisiting libraries or by enhancing the parser source code. Other features that will be worked on are a better way to generate xml for a large number of datasets instead of just the current GenerateDatasetsXML script along with a notification system which tracks for problems while loading the datasets and mails them directly to the administrators.

pythonocean sciencejava+3
Student: ayushsingh01042003
Code
Proposal

Raw Camera File Decoding in Rust

intermediate
Graphite•2024Varies175h (Medium)

Professional-grade cameras capture photos in a raw format before being processed into actual pixel data by a photo editing application. The Rust ecosystem lacks a library for decoding and processing raw files that meet's Graphite's requirements for being modular, pure Rust, and permissively licensed. This project aims to develop a crate that will enable Graphite to begin its growing focus on the envisioned photo editing feature set.

machine learningrustvulkan+2
Student: Elbert Ronnie
Code
Proposal

Frontend visualization and incorporation of single cell data in cBioPortal

intermediate
cBioPortal for Cancer Genomics•2024Varies175h (Medium)

My project aims to bridge the gap between single-cell gene expression data analysis and existing cancer genomics workflows, particularly within the cBioPortal platform. Currently, cBioPortal lacks support for visualizing single-cell data alongside bulk genomics data, hindering researchers from gaining a comprehensive understanding of cancer biology. To address this, I propose the development of a dedicated single-cell analysis module within cBioPortal, focusing on the MSK Spectrum dataset. The key problem I am addressing is the inability to integrate single-cell gene expression data with existing cancer genomics workflows. By incorporating single-cell data into cBioPortal, researchers will be empowered to identify specific cells with altered gene expression, understand their contribution to overall expression patterns, and connect this information with genetic alterations. My solution involves developing a custom Single-Cell Tab within cBioPortal's study view. The tab will include features such as dataset information, gene selection, interactive visualizations (boxplots, scatter plots, stacked bar graphs, and pie charts), filtering options, and download capabilities. To achieve this, I will aggregate the single-cell data to a gene-cell type-sample level, creating a pseudo bulk representation to manage the large dataset size effectively. I will utilize existing charting libraries like CanvasJS and React primitives for visualization components, ensuring seamless integration with cBioPortal's design language. My deliverables include: Custom Single-Cell Tab within cBioPortal study view. Dataset information panel for study description and cell type/sample details. Gene selection panel with autocomplete functionality. Interactive visualizations including boxplots, scatter plots, stacked bar graphs, and pie charts. Filtering options for focused data exploration. Download options for data and plots in common file formats.

javascriptjavaweb+9
Student: SURAJ SHARMA
Code

Open Science Labs: PyDataStructs: Add a C++ Backend for tree data structures and their algorithms

advanced
NumFOCUS•2024Varies350h (Large)

PyDataStructs aims to be a Python package for various data structures and algorithms (including their parallel implementations). My project involves adding a C++ backend for tree data structures and their algorithms available in PyDataStructs. This will be linked to the Python frontend via Python C-API. The user will have an option to run algorithms in this C++ backend, by simply passing a backend parameter to the existing Python functions. This will greatly enhance the computation speed, making it extremely valuable for scientific computing and high-performance applications. I will test my implementations against the existing Python testcases to ensure that they are fully compatible with the Python frontend.

pythonjavascriptr+3
Student: Kishan Ved
Code
Proposal

Expansion of Swift Macros in Visual Studio Code

intermediate
Swift•2024Varies175h (Medium)

“Implementing a Code Action in Visual Studio Code to show the expansion of a Swift Macro in a peeked editor”. Swift Macros allow the generation of source code at compile time. While this provides concise code and avoids repetition of common paradigms, understanding the source code can become harder if it is unknown what the macro expands to. Visual Studio Code using the Swift Extension currently has limited ability to show the code generated by a macro by invoking a code action that replaces the macro by its generated code inside the current source file. The project’s goal is to implement a code action to show the macro-generated code without modifying the current source file. This includes the implementation of a request in sourcekit-lsp to compute the contents of the macro expansion and support in the Visual Studio Swift Extension to display that content. As a stretch goal, Visual Studio Code should also offer semantic functionality like jump-to-definition inside the macro expansion and allow the expansion of nested macros. *Deliverables*: 1. An Expand Macro Code Action in VS Code that shows the generated contents of a swift macro in a peeked editor 2. Support for Semantic Functionality such as jump-to-defintion, hover, syntax highlighting in the peeked editor 3. Allow expanding macros generated from macro in the peeked editor i.e. Nested Macro Expansion 4. Add a standard request support for other LSP-based editors giving them ability to expand macros upto the first level.

llvmc++cmake+5
Student: Lokesh T R
Code
Proposal
Showing 3073 - 3096 of 13453 Projects
127128129130131
Proposal
Proposal
Proposal
Proposal
Proposal