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

macOS app bundle (175 hours)

intermediate
Synfig•2025Varies

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 current macOS app bundle creation process for Synfig relies on an outdated Bash script that is slow, error-prone with incorrect paths, and lacks code signing, hindering efficient distribution and user trust. This project aims to replace the script with a robust, automated solution to streamline bundle generation, ensure macOS security compliance, and enhance the native user experience. By leveraging Python for dependency collection, C++ for environment setup, and CMake/CPack for packaging, the project will deliver a signed, distributable SynfigStudio.app bundle. Key improvements include faster dependency gathering, proper code signing, embedded environment setup, Python/lxml integration, and macOS-native interface enhancements. Approach: • Develop a Python script to efficiently collect and stage dependencies, optimizing with caching and parallelization. • Implement code signing in reverse dependency order using codesign, including Python and lxml binaries. • Remove the external launcher script by embedding environment setup in the C++ entry point. • Package Python and lxml into the bundle, ensuring compatibility and signing. • Integrate CPack into CMake to generate a polished .dmg installer. • Enhance the UI with macOS-native menu bar and window behaviours using GTK. Deliverables: • A CMake/CPack-based build system producing a signed SynfigStudio.app bundle. • A Python script for automated dependency collection and path rewriting. • Code signing support for all binaries, including Python and lxml. • Embedded environment setup within SynfigStudio, eliminating the launcher script. • A bundled Python runtime with lxml, fully signed and functional. • A distributable .dmg installer generated via CPack. • macOS-native UI improvements (e.g., menu bar, shortcuts, dialogs boxes). • Comprehensive documentation covering installation, usage, and build instructions.

c++gtkgtkmm+2
Student: Nitish Itankar
Code
Proposal

Healing Stones - Reconstructing digitized cultural heritage artifacts with artificial intelligence

intermediate
HumanAI•2025Varies175h (Medium)

This project aims to develop an AI-powered system for the virtual reconstruction of fragmented cultural heritage artifacts, with a focus on Mayan stelae. These artifacts are often discovered in broken, randomly oriented, and partially eroded states, making manual reassembly both time-consuming and imprecise. The proposed solution combines geometric analysis, graph-based fragment matching, and machine learning techniques to automate the reconstruction process. By leveraging 3D scans of the fragments and training models on real geometric descriptors, the system will predict correct alignments and reassemble the stele in a digital space. The project will be implemented using Open3D for 3D processing and PyTorch for neural network training. This work not only aids in archaeological restoration efforts but also contributes to the broader field of digital heritage preservation.

pythonmachine learningc+++2
Student: Atif_khan
Code

RNTuple in JSROOT

advanced
CERN-HSF•2025Varies350h (Large)

This project addresses the lack of RNTuple support in JSROOT, a critical gap hindering browser-based visualization and analysis of high-energy physics (HEP) data. My Solution: By developing a JavaScript parser for RNTuple’s binary format, extending JSROOT’s interface to mirror its `TSelector` API for TTrees, and integrating visualization tools (histograms, scatter plots), researchers will gain seamless access to RNTuple data directly in web browsers. Key deliverables include: 1. Validated Parser: Tested against ROOT-generated datasets (via C++ macros) for accuracy. 2. JSROOT Integration: A `TRootupleSelector` interface enabling reuse of existing visualization modules. 3. Interactive Visualizations: Histograms, scatter plots, and UI features (tooltips, zoom) for real-time data exploration. 4. Optimized Performance: Stress-tested with 1M+ entries, cross-browser compatibility (Chrome, Firefox, Safari, Edge). This work will bridge the gap between RNTuple and browser-based HEP analysis, enhancing accessibility for global researchers.

pythonc/c++machine learning+6
Student: Kriti Mahajan
Code
Proposal

Improved Fortran Interface Generation for PETSc

advanced
Fortran-lang•2025Varies350h (Large)

PETSc, the Portable, Extensible Toolkit for Scientific Computation, is for the scalable (parallel) solution of scientific applications modeled by partial differential equations (PDEs). Besides its native API in C it has bindings for Fortran and Python. PETSc also contains TAO, the Toolkit for Advanced Optimization, a software library supporting MPI and GPUs through CUDA, HIP, Kokkos, or OpenCL. While most of the Fortran interfaces can be generated automatically from the C-API, functions with "complex" arguments such as procedure pointers, pointers to arrays, and strings require the manual creation of interface code on both the C and the Fortran side. Moreover, due to the discrepancy of features between C and Fortran, a one-to-one translation of APIs leads to Fortran interfaces that don't leverage the capabilities of modern Fortran. Examples include overloaded functions for different types in Fortran, for which a C-API requires VOID and an explicit type argument and arrays, for which the length is part of the type definition in Fortran but requires a second argument in the C-API. This project aims to improve the automation of generating Fortran interfaces by leveraging modern Fortran features such as BIND(C) and ISO_C_BINDING along with annotation strategies to reduce the need of manual generation of interfaces. The improved system will enhance both usability for end-users and maintainability for developers.

pythonc/c++llvm+3
Student: Tapashree Pradhan
Code
Proposal

Traceroute visualization (continuation of GSoC'24)

intermediate
Internet Health Report•2025$3k–$6.6k175h (Medium)

RIPE Atlas publishes traceroute measurement results. A measurement result can have a large volume of data. One example of a large volume measurement is as mentioned below: "Given around 12000 probes worldwide and the system collects traceroute data from these probes every 15 mins. The measurement has been running for 2+ years. The maximum hops a probe made in this measurement was 32." RIPE Atlas provides a REST API to fetch the measurement result. However, the measurement result object can be a large json response. It increases the memory usage on the server while creating a huge response. If the server succeeds in creating a huge response, the client device may not afford to render an SVG graph given the large traceroute data. The main goal for this project is to enable the visualizer to handle traceroute measurement results of any volume. This can mainly be achieved by - Narrowing down the search according to the inputs (probe ids to include, time frame) provided by the user - Paginate the measurement result API call by probe ids, start time and stop time Experiment rendering the network graph using more efficient graph libraries and test. If by testing, the results are improved then replace the current implementation of v-network-graph. Also, there is a scope for UI enhancements. The main thought process behind thinking UI enhancement for this project was this: "The data which we can provide should simply be there on the graph when the user needs it. This UI enhancement can be achieved by adding another “Detailed mode” to the network graph." During the GSoC timeline, I will be executing testing strategies, fixing the underlying issues of the traceroute visualizer and documenting my work.

pythonjavascriptapache kafka+1
Student: Om Palsanawala
Code
Proposal

Enhancing LLM Training Efficiency with Clad for Automatic Differentiation in C++

advanced
CERN-HSF•2025Varies350h (Large)

Training Large Language Models (LLMs) is computationally expensive, often bottlenecked by the performance limitations of Python-based frameworks. This project addresses this challenge by enhancing LLM training efficiency within a C++ environment through the integration of Clad, a Clang/LLVM compiler plugin for automatic differentiation (AD). We will deveop a custom C++ tensor library specifically designed for optimal interaction with Clad. The core objective is to replace traditional runtime or manual gradient computations with Clad's efficient compile-time differentiation for key LLM operations within a GPT-2 training pipeline. This involves investigating effective strategies to bridge Clad's static analysis with dynamic neural network computations, benchmarking the resulting performance gains in speed and memory usage against a non-Clad baseline, and leveraging OpenMP for further parallelization.

pythonc/c++machine learning+6
Student: Rohan Timmaraju
Code

Functionalities for Krylov methods over exact fields

advanced
SageMath•2025Varies350h (Large)

This project aims to add Krylov subspace methods for matrices over exact fields: representation of the kernel, co-kernel of a matrix of univariate polynomials over an exact field as a module, and associated invariants, as well as computation of the characteristic polynomial if the matrix is square via recent methods. The performance relies heavily on a few core linear algebra operations, so care must be taken to use the most efficient implementations and to exploit any additional characteristics of the specific use cases. Consideration may also be given to more general optimisation of methods for matrices over univariate polynomials. Key goals for the project are to have the above functionalities implemented efficiently, with accompanying documentation and tests to meet the project standards.

pythoncython
Student: Nicholas Bell
Code
Proposal

Gen3 FHIR Server

advanced
Center for Translational Data Science•2025Varies350h (Large)

This project addresses a key challenge in biomedical data management: enabling secure, standards-compliant access to clinical FHIR data while integrating with the Gen3 platform. The goal is to develop an open-source, containerized FHIR proxy that enforces Gen3 access control via Arborist and supports asynchronous API interactions for high-performance data access. The solution includes: 1) A proof-of-concept FastAPI proxy that routes FHIR requests to a HAPI FHIR JPA server, adding Gen3 security tags for each resource. 2) Scripted ingestion of synthetic NCPI FHIR resources to facilitate testing and reproducibility. 3) Comprehensive unit tests and example configurations for local and cloud deployment. 4) Full containerization with Docker and Docker Compose, with plans for Kubernetes deployment via Helm. By providing a secure, FAIR-aligned, and standards-based framework for FHIR data, this project empowers researchers and developers to access and manage biomedical data efficiently while maintaining strict compliance with security and privacy requirements.

pythonawsgolang+4
Student: Andriana Sielli
Code
Proposal

BT-Studio: a tool for programming robots with Behavior Trees

beginner
JdeRobot•2025Varies90h (Small)

The primary objective of this project is to enhance BT Studio's capabilities by upgrading the library of behavior trees and composition tools. Currently, BT Studio BT library is simple, really overcomplicated and buggy which makes reusing behaviors trees from the library difficult. This update aims to simplify and improve this tools and to increase the amount of entries in the library. Also it will improve other features of BT Studio such as the custom universes, making them fully functional and with all the features of the already existing ones inside the Robotics Backend, the docker execution enviroment for robotics applications. All of this changes would enable users to test applications across a wider range of scenarios, thereby enhancing debugging and solution robustness.

pythonrosgazebo+2
Student: Javier Izquierdo
Code
Proposal

Create a Firmware Prototype for PSLab Mini: A Compact Oscilloscope & Multimeter

advanced
FOSSASIA•2025Varies350h (Large)

The PSLab Mini is a compact version of the PSLab board that encompasses similar features but with fewer instruments, with more focus on those individual instruments The main idea behind building the PSLab Mini board is to take the already present PSLab board and use its hardware and firmware, and convert it into a lighter version, which can be achieved by stripping off the files related to other instruments along with their respective drivers. Also, another aim of this project is to refactor the instruments along with their drivers to make the firmware more reliable, lighter and faster. The Key deliverables of this project are: • PSLab Mini schematic and BOM list • PSLab Mini PCB, which is ready for prototyping • A working firmware that is either tested on a prototype or similar ARM-based processor board • Improve the working of the firmware using hardware or software improvements • Optimize the board for low-power applications • Increase the capability of the instruments on board the PSLab Mini • Documentation of the firmware developed during the period

pythonjavascriptandroid+7
Student: Tejas_G
Code

Vala: XML, JSON, and/or YAML Integration

intermediate
GNOME Foundation•2025Varies175h (Medium)

The main objective is to integrate direct syntax support for parsing and emitting JSON, XML, and/or YAML formats in Vala. This will cut back the boilerplate code making it more user-friendly and efficient for developers working with these format languages. To solve this, I first plan to research how other languages implement these integrations. This will allow me to see best practices and common syntax used. At the same time, I will research how Vala currently parses and emits JSON, XML, and YAML formats. Lastly, out of the research, I will know how to properly integrate the format languages into Vala's compiler, which will allow for direct syntax integration. The overall deliverables consist of: 1) Research on how Vala and other programming languages handle JSON, XML, and YAML. 2) Syntax design and mock-ups. 3) Implementation and prototyping. 4) Testing, documentation, and code snippets

cpythonjavascript+4
Student: Alley Chaggar
Code
Proposal

Diffusion Models for Gravitational Lensing Simulation

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

My project focuses on developing diffusion models for gravitational lensing simulations. I will implement and evaluate various diffusion-based architectures, including Diffusion Transformers (DiT) and Latent Diffusion Models (LDM). Conditional modeling techniques such as Classifier-Free Guidance and Conditional Flow Matching will also be explored. The project involves creating a diverse dataset of simulated gravitational lensing images under various astrophysical conditions for downstream tasks. All implementations, findings, and documentation will be open-sourced through a GitHub repository.

pythonmachine learningc+++2
Student: hamees-sayed
Code
Proposal

Accelerating OVS with Gigaflow: A Smart Cache for SmartNICs

advanced
The P4 Language Consortium•2025Varies350h (Large)

Gigaflow is an innovative solution to accelerate network processing in large-scale data centers by leveraging flow locality and pipeline-aware caching, offloading processing to SmartNICs. Currently, it supports only Alveo U250 FPGAs, limiting its versatility. This proposal aims to extend Gigaflow’s backend support by developing new APIs for flow integration, enabling compatibility with Pensando DPUs. Additionally, the current implementation of Sub-Treversal Partitioning (STP) incurs high CPU overhead during startup, minimizing the system's performance benefits. This project will optimize STP to reduce CPU usage and improve startup efficiency. Finally, Gigaflow’s newness requires further optimization in the compilation, LTM, and driver pipeline, alongside additional testing for alternative strategies for priority selection and rule deletion. The proposal will address these challenges. By achieving these goals, the project will streamline Gigaflow caches in the OVS backend, facilitating more efficient and flexible solutions for modern data centers.

llvmc++mlir+3
Student: Advay Singh
Code

Open Hardware Component Library

intermediate
CircuitVerse.org•2025Varies175h (Medium)

This project aims to improve CircuitVerse by adding new components that are useful for learning about real hardware, such as shift registers (SISO, SIMO, MISO, MIMO), comparators, and a buzzer (speaker), Priority MUX, etc. It will also introduce support for connecting CircuitVerse with real devices using the Browser’s Web Serial API, allowing users to interact with physical hardware directly through the simulator. These features will help people better understand how digital circuits work—both in theory and in practice. The goal is to make CircuitVerse more powerful and helpful for learning digital circuits and embedded systems.

postgresqljavascriptbootstrap+8
Student: Nihal Rajpal
Code
Proposal

FRM parser Utility for MariaDB

intermediate
MariaDB•2025Varies175h (Medium)

FRM files are what MariaDB uses to store metadata about tables. These files can be used to generate DDL statements (CREATE TABLE ...). We are lacking a utility to parse these files which could in turn make DBAs lives easier. The task of this project is to have this utility implemented, making use of MariaDB's FRM parsing logic. You may have to carry out some refactoring to extract the parsing code into a reusable library, once for MariaDB Server, once for the FRM parsing tool.

cmysqlmariadb+7
Student: hp77
Code
Proposal

Create and Add to an Example Gallery for toqito

intermediate
NumFOCUS•2025Varies175h (Medium)

This project addresses the need for enhanced usability and learning resources within the toqito quantum information library by creating a user-friendly example gallery, inspired by successful models like scikit-learn's. The core problem is the current lack of diverse, executable examples demonstrating toqito's capabilities in practical scenarios. The proposed solution involves developing the gallery's web infrastructure (potentially using Sphinx-Gallery) integrated into toqito's existing documentation, and populating it with high-quality, self-contained Python examples. Key deliverables include the functional gallery structure and 6 core examples demonstrating crucial toqito functionalities: modeling cryptographic protocols (Bit Commitment, QKD QBER) using ExtendedNonlocalGame, verifying state antidistinguishability thresholds from recent literature using the state_opt module, and illustrating channel properties (is_extremal) using channel_props. This gallery will significantly improve toqito's accessibility for researchers and new users, providing practical code and explanations for core quantum information concepts.

pythonjavascriptr+3
Student: Nafisa Shamim Rafa
Code
Proposal

Integrate HPX algorithms with Nvidia CCCL (Thrust)

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

This project proposes integrating NVIDIA's Thrust parallel algorithms library with HPX to enable GPU acceleration while maintaining consistency with HPX's existing parallel algorithm interfaces. The solution involves creating a specialized Thrust executor that extends HPX's CUDA executor capabilities, implementing automatic memory management for data transfers between host and device, and developing a dispatching mechanism that selects the appropriate backend (CPU or GPU) based on execution policies. Key technical components include a version-aware API layer to handle Thrust compatibility, exception handling that bridges Thrust/CUDA errors with HPX's error system, and template-based algorithm overloads that transparently route calls to Thrust implementations when GPU execution is requested. The implementation will proceed through four phases: establishing core infrastructure (executor, memory management), integrating fundamental algorithms (transform, reduce, sort), adding HPX execution policy support, and concluding with comprehensive testing and optimization. The resulting system will allow developers to write single code paths that automatically leverage GPU acceleration through Thrust when available, all while maintaining HPX's asynchronous execution model through future-based interfaces.

c++cudaopencl+10
Student: Aditya Sapra
Code

AI Chat Integration with all WebTools

beginner
ArduPilot•2025Varies90h (Small)

This project aims to enhance the functionality and user experience of web tools, starting with the Hardware Report Tool and UAV Log Viewer, by integrating an AI-powered assistant. The assistant will provide context-aware responses using Retrieval-Augmented Generation (RAG) and execute actions within the tools through function calling. Deliverables include: 1. AI-powered chat interface integrated into the Hardware Report Tool and UAV Log Viewer. 2. RAG implementation for accurate, context-aware responses. 3. Function calling capabilities, enabling AI to execute tool-specific actions. 4. Automated assistant setup for easy integration with future web tools.

pythonrosc+++8
Student: Anas Chebili
Code
Proposal

GSoC 2025 - Real time In Browser Translation and Text-To-Speech

intermediate
Internet Archive•2025$3k–$6.6k175h (Medium)

I would like to work with the Open Library team to create a plugin within the Internet Archive’s book reader app that would enable users to locally translate books and integrate the translated text to allow text-to-speech functionality for different languages. Using JavaScript and the Bergamot Translation model, this feature will parse the transparent text layer within the IA's book reader, feed the input into the translation model, and output the translated text onto the app. Using a simplified calculation of books available for lending within the Open Library catalog, this project would expand the 3 million works available in English to at least 18 million titles across the 6 different languages supported by the Bergamot project, directly contributing to the Open Library's 2025 goal of offering more with less. The primary deliverables for this project can be broken down into two major parts: implementing a translation plugin that allows users to select the source + target translation languages and intercepting the existing text-to-speech plugin to read the translated output from the Bergamot translation model. A future high-level deliverable for this project would allow volunteers to contribute their own translations for texts, which could allow higher quality translations to be provided to fellow patrons.

pythonjavascriptpthon+6
Student: Sandy Chu
Code

AI-Powered Unified Accessibility Compliance Suite for Drupal - GSoC 2025 Proposal

intermediate
Drupal Association•2025$3k–$6.6k175h (Medium)

This project proposes an AI-powered accessibility auditing and remediation toolkit tailored for Drupal environments. It integrates automated accessibility scanners (e.g., Deque Axe API), and NLP models (such as GPT-4 or BLIP-2) to suggest intelligent alt-text and identify layout/media accessibility issues. A dynamic dashboard will be built to track scan results, remediation progress, and generate compliance documentation in formats like PDF and CSV. The system will be developed using Symfony (backend), HTML+Twig (frontend templating), and MongoDB (for storing audit results and history). Key components include API communication layers, a feedback system for rating AI suggestions, and tight workflow integration with Drupal, enabling accessibility checks before content is published. The architecture emphasizes modularity, ethical AI use, and compatibility with WCAG standards.

mysqljavascripthtml+2
Student: Ned9776
Code

Rework Impress slideshow to use DrawingLayer primitives

intermediate
LibreOffice•2025Varies175h (Medium)

This project focuses on modernizing the LibreOffice Impress slideshow rendering system by replacing the older metafile-based approach with a more streamlined and modern rendering path using DrawingLayer primitives. The goal is to render slide content directly onto the screen without relying on canvas abstractions. This involves integrating the DrawingLayer’s primitive processing into the slideshow engine, handling both static and animated content, and gradually moving relevant rendering logic into the core VCL module. Additional work was done to ensure animation effects, including GIF playback and text-based animations, are correctly supported with primitives. The result will be a cleaner, more maintainable rendering architecture.

pythonandroidjava+2
Student: Shardul Vikram Singh
Code
Proposal

Hamiltonian Library for QuTiP

intermediate
NumFOCUS•2025Varies175h (Medium)

This project aims to develop a comprehensive Hamiltonian Library for QuTiP (Quantum Toolbox in Python). Currently, QuTiP users must frequently recreate common quantum system Hamiltonians from scratch, leading to redundant work and inconsistencies. The library will provide ready-to-use implementations of frequently used quantum systems like Jaynes-Cummings, Rabi, Dicke, and various spin-chain models. Key features include a standardised API, JSON serialisation for cross-platform compatibility, time-dependent parameter support, and LaTeX representation capabilities. The deliverables include a core Hamiltonian base class, at least 10 implemented quantum models, comprehensive documentation, tutorials, and full integration with QuTiP's existing functionality. This project will significantly enhance user experience and reduce redundancy in quantum simulations.

pythonjavascriptr+3
Student: VanshajB
Code
Proposal

Faust LSP

beginner
GRAME•2025Varies90h (Small)

This proposal aims to develop a feature-rich programming environment for writing Faust programs in VS Code by providing powerful Language Server Protocol(LSP) features such as code completion, diagnostics checking, definition lookup, etc. and any other features commonly supported by other mature programming language projects. The goal is to enhance and optimize the current Faust programming experience, making Faust development smoother for developers and allowing Faust programming to be more accessible for beginners to the Faust ecosystem.

cpythonjavascript+3
Student: carn181
Code
Proposal

Accelerated Read/Write and Robust OpenMS Workflows (ARROW)

beginner
OpenMS•2025Varies90h (Small)

This is a biparted project in which we first focus on integrating Apache Arrow into OpenMS’s build system and dependency management framework, as simple as that sounds. The goal here is to ensure a solid foundation by creating custom CMake scripts, updating CI pipelines, and ensuring cross-platform compatibility. In the second phase, we will implement a converter that transforms mzML files into the Arrow-compatible Parquet format. This conversion not only preserves the integrity of the original data and also allows for the leveraging of the richer schema evolution and querying capabilities of Parquet. Together, these efforts form the ARROW project, ultimately paving the way to more efficient computational mass spectrometry workflows.

pythoncythonc+++2
Student: Avni Badiwale
Code
Proposal
Showing 2137 - 2160 of 13453 Projects
8889909192
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal