Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters Clear
11996 Projects Found
Sort by

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

intermediate
Machine Learning for Science (ML4SCI)•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 →
175h (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
Proposal

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

Best of both worlds – let’s cherish the features of parametric AND explicit knowledge retrieval

advanced
INCF•2024Varies350h (Large)

The annotation of research data is essential to ensure its findability and reusability. High-quality data annotations require domain expertise, so that annotations are relevant, but also specific technical skills, such as knowing how to handle JSON/XML files. Additionally, people are often reluctant to change their workflows, and the technical affordances in the case of data annotation intensify this challenge. As a result, researchers tend to stick to their “data handling traditions” as soon as data operations become too complex. Unfortunately, this often means that even though projects like Neurobagel are working hard to make life easier for researchers, these tools are not widely adopted. My idea for contributing to the Neurobagel project is to combine a user-friendly interface with a Large Language Model (LLM) approach to make the annotation of tabular data even more effortless for researchers. For the end user, the process should be to provide a tabular file and get a first-pass annotation for review without any intermediate steps. From a technical perspective, this should be accomplished by using a Large Language Model (LLM) to categorize columns, such as participant ID or age. To improve the predictions of the LLM, already annotated data will be linked to explicit knowledge from existing ontologies such as SNOMED CT or the Cognitive Atlas and used to provide context for the LLM.

pythonjavac+++7
Student: Barbara Strasser
Code

TheTransitClock:-DetourDetective

intermediate
Open Transit Software Foundation•2024Varies175h (Medium)

DetourDetective is a proposed plugin for TheTransitClock that aims to automatically detect detours on transit routes. It is expected, this will further enhance the reliability and accuracy of arrival predictions produced by TheTransitClock during disruptions. TheTransitClock is an open-source transit information system. Its core function is to provide and analyse arrival predictions for transit systems. It takes a GTFS-realtime vehicle-position feed as input and produces arrival predictions in a GTFS-realtime trip-updates feed.

androidjavagolang+2
Student: Andrew Cunningham
Code
Proposal

High Altitude Non-GPS Position Estimation

intermediate
ArduPilot•2024Varies175h (Medium)

This project involves developing High Altitude Non-GPS Position Estimation algorithm for UAVs, so that they can localize and navigate in the GPS-Denied area with altitudes of at-least 100m using a downward facing camera. This project will involve development using python, opencv and pymavlink on a companion computer and other modifications on firmware using C++ for FCU. All the communication between FCU and Companion Computer will be over MAVLINK. If time permits a GPS/Non-GPS transition Lua script could be developed that switches between AHRS/EKF sources based on the pilot's source selection switch or using an automatic source selection algorithm. The script will automatically switch between GPS and gimbal based high altitude non-GPS navigation.

pythonrosc+++8
Student: Sanket Sharma
Code
Proposal

Intrinsic Mollification Schemes to Enhance Cotangent Weights Robustness

advanced
CGAL Project•2024Varies350h (Large)

The project aims to tackle the challenge of low-quality triangles in triangle meshes by mollifying each triangle, effectively simulating improved edge lengths to eradicate intrinsically thin triangles. The overarching objective is to establish a unified preprocessing step capable of managing such cases, thereby streamlining CGAL's cotangent weight calculation through intrinsic mollification. This endeavor encompasses multiple facets: firstly, the exposure of intrinsic mollification as an independent option for heat method computation; secondly, the implementation and comparison of advanced schemes delineated in recent research to refine intrinsic mollification. Furthermore, the project ultimate goal is to use intrinsic mollification to enhance the outcomes of other CGAL packages such as curvature flow, parameterization, skeletonization, and mesh fairing that use cotangent weights.

githubc++git+4
Student: Islam Omar
Code
Proposal

Adding GAM and Discriminant Classification Classes and Implementing Missing Methods

advanced
GNU Octave•2024Varies350h (Large)

This proposal aims to significantly extend the classification capabilities of the GNU Octave statistics package by implementing additional methods for the existing ClassificationKNN class and introducing new classification classdefs, namely ClassificationGAM and ClassificationDiscriminant. These enhancements will bridge the gap between GNU Octave and MATLAB in terms of advanced data analysis and machine learning functionalities, fostering a richer environment for scientific computing.

c++hg
Student: Ruchika Sonagote
Code
Proposal

Port libipuz to Rust

intermediate
GNOME Foundation•2024Varies175h (Medium)

Libipuz is a C library that loads puzzle files and used by Crosswords as the underlying data structure. It is written in C. Since it is used primarily to parse files from disk, rewriting it in Rust adds additional safety while (hopefully) improving the maintainability of this library.

cpythonjavascript+4
Student: pranjal_
Code
Proposal

ZenMatics

intermediate
Zendalona•2024Varies175h (Medium)

The proposal aims to develop an innovative, accessible mobile application to address the specific challenges faced by visually impaired students in their learning process. The app goes beyond traditional resources by utilising sound, touch, device sensors, and interactive elements to create a multi-sensory learning experience. This approach aims to improve engagement, understanding, and retention of key mathematical concepts. The proposal highlights my strong interest in accessibility software solutions, a relevant background in Android development, and a desire to use technology to make a positive social impact. Through my research, I have demonstrated the use of existing accessibility tools and outlined a comprehensive project plan that includes: 1.)Interactive modules: Lessons on basic arithmetic, cardinal directions, trigonometry, geometry, metric systems, and more. The modules thoughtfully leverage device features like magnetometers, gyroscopes, and accelerometers. 2.)Story-based learning: A story mode with auto-generated MCQs potentially using TensorFlow Lite for comprehension and assessment. 3.)Accessibility focus: Thorough consideration of screen reader compatibility, audio and haptic feedback, and support for Braille displays and switch access. 4.)Iterative development: A detailed timeline with a community bonding period, regular milestones, testing, and a phase for incorporating user feedback. The idea of this proposal aligns closely with Zendalona's mission.

pythonjavascriptandroid+2
Student: Ayush Prasad
Code
Proposal

Libreoffice Theme

intermediate
LibreOffice•2024Varies175h (Medium)

Libreoffice uses its own GUI Library VCL, which interfaces with various backends like GTK, QT, Windows UI, and macOS X UI. VCL gets colors for the UI from these toolkits(the operating system colors), and using a pair of Get*****Color() and Set*****Color() can customize them, but these customizations are limited. And thus it has to use system colors for other UI elements, which is limiting. The Idea is to introduce the concept of themes so as to make application colors independent of the Operating System Colors, and make themes available via extensions.

pythonandroidjava+2
Student: Sahil Gautam
Code
Proposal

FFIgenpad

intermediate
Dart•2024Varies175h (Medium)

A web interface in which you paste a C header in a textbox on the left, and it outputs dart:ffi bindings generated by package:ffigen in a textbox on the right. (Inspiration is https://godbolt.org/ which does this for a C file on the left and assembly on the right.) In order to avoid needing a server to do the backend, we'd like to compile the Dart code in package:ffigen and libclang to WASM. That way everything can run in the browser.

flutterdartprogramming-language
Student: TheComputerM
Code
Proposal

GDB UI

intermediate
C2SI•2024Varies175h (Medium)

The issue is to address the usability and accessibility limitations of GDB by developing a user interface (UI) utilizing React. This UI will leverage the GDB Python API to create a graphical dashboard that streamlines the debugging process. By providing a more intuitive and visually interactive interface that aims to enhance the debugging experience for developers, making it easier to execute commands, examine program state, and control operations within GDB. It contains features such as starting/stopping program execution, inspecting variables, registers, and memory, and a log or console view for command output and error messages.

pythonjavago+2
Student: Shubh Mehta197
Code
Proposal

Improvement Of openPIP (Data upload & Visualization)

intermediate
National Resource for Network Biology (NRNB)•2024Varies175h (Medium)

OpenPIP platform is typically necessary alongside a research paper detailing experimental data, alongside depositing the data into a standard repository. Setting up and tailoring the database and web portal doesn't demand any coding expertise. OpenPIP has been utilized in constructing the databases and web portals for two significant protein interactome maps: the Human and Yeast Reference Protein Interactome maps (HuRI and YeRI). o The current data import/upload module uses the standard Proteomics Standards Initiative Molecular Interactions (PSI-MI) format and connects to several public databases to collect further information for all proteins in the dataset. Possible improvements as data upload and visualization are the main goals of this milestone.

pythonjavascriptjava+11
Student: Mohamed Soudy
Code

Add AAC via S/PDIF and Bluetooth passthrough support

intermediate
VideoLAN•2024Varies175h (Medium)

The project aims to add AAC via S/PDIF and Bluetooth passthrough support for all major OS specific audioservers to VLC as opposed to the current implementation where PCM data is passed through.

copenglc+++10
Student: Advait Dhamorikar
Code
Proposal
Showing 2953 - 2976 of 11996 Projects
122123124125126
Proposal
Proposal
Proposal
Proposal