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

Offloading to a separate process on the same host

intermediate
GNU Compiler Collection (GCC)•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 project focuses on streamlining the debugging and development process for code intended for offloading to devices like GPUs. It proposes a method to execute offloaded code in a separate CPU process on the same host, simplifying debugging and avoiding the need for a GPU setup. The work involves creating a host-ISA offloaded code generation mode and a libgomp plug-in to interface with the libgomp offloading machinery, managing the new process for the offloaded code. This approach can simplify debugging issues related to memory mapping or multi-device offloading, and potentially simulate GPU-like parallelism using CPU threads for a broader range of debugging scenarios.

cc++openmp+3
Student: Georgii Burunsuzian
Code
Proposal

Write a Swift code generator to support the creation of SAM deployment descriptor

intermediate
Swift•2024Varies175h (Medium)

Deploying AWS Lambda functions using AWS SAM (Serverless Application Model) requires manual creation of a deployment descriptor, posing challenges for Swift developers due to learning a new DSL and adopting new tools like SAM CLI and Docker. To simplify this process, the community proposed a Swift-based DSL and a Swift package plugin. However, these solutions rely heavily on accurately mimicking the evolving SAM AWS deployment descriptor. To address this, this project proposes to automatically generate the AWSLambdaDeploymentDescriptor library based on the SAM template definition. That generated code is used by the Swift-based DSL to create SAM YAML templates required to deploy Lambda functions and their dependencies to AWS.

llvmc++cmake+5
Student: Esraa Eid
Code
Proposal

CLI / Deploy / FaaS Unification

intermediate
MetaCall•2024Varies175h (Medium)

MetaCall offers binaries and a CLI that can be downloaded and installed easily through metacall/install. This provides a CLI for executing code and a REPL for interacting with some MetaCall functionalities. Apart from this, there are two separate projects that are part of the full development lifecycle: metacall/deploy, which is a CLI for deploying into the FaaS and metacall/faas, which is a reimplementation of the FaaS for local development. These two tools are right now completely separated from the CLI, although they are necessary for the full development lifecycle. The idea of this project is to unify them into the same project. For example, having metacall deploy ... for executing the deploy CLI or metacall faas for executing the FaaS locally. With these options, all tools will be unified into one, and end users will install all of them once the CLI is installed.

pythonjavascriptc/c+++6
Student: Aakriti Awasthi
Code
Proposal

Fortran – DO CONCURRENT

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

The project aims to enhance the f951 compiler's `DO CONCURRENT` construct by implementing locality clauses, supporting reduction operation and developing parallelization strategy include OpenMP-based parallelization.

cc++openmp+3
Student: Anuj Mohite
Code
Proposal

LLM Assistant for OpenROAD - Model Architecture and Prototype

advanced
UC OSPO•2024Varies350h (Large)

This project aims to build a conversational assistant designed around OpenROAD to answer user queries. The goal is to build a complete pipeline that includes dataset updates, model training, and model deployment. The pipeline's architecture will be able to adapt to evolving datasets, with metrics to regularly keep track of the model’s performance.

pythonc/c++visualization+5
Student: Palaniappan R
Code
Proposal

AI Scholar: A Novel AI RAG-aware Model for Academic Paper Analysis

advanced
R project for statistical computing•2024Varies350h (Large)

Researchers have tremendous difficulty keeping up with the exponential growth of scientific literature--where groundbreaking findings and complex concepts are emerging at a rapid pace--hindering their ability to stay on top of the latest insights in their field. There is a dire need for AI utilizing retrieval-augmented generation (RAG) models that can efficiently process and summarize these vast volumes of scientific papers, helping human researchers focus their efforts on the most promising areas of investigation. The "AI Scholar" project aims to develop an advanced AI system utilizing state-of-the-art natural language processing, information retrieval, and machine learning techniques, including a RAG model, to efficiently process, summarize, and analyze vast volumes of academic papers. This innovative system will enable personalized recommendations, automated literature analysis, idea generation, and guidance for researchers navigating the complex landscape of statistics, data science, and potentially other scientific domains, thereby accelerating the pace of scientific discovery and innovation.

cc++r+4
Student: Christopher Mejo
Code

Cluster of priority features

intermediate
Zulip•2024Varies175h (Medium)

This project will focus on implementing a number of high priority features for Zulip web app focused around left sidebar and stream settings. This includes addition of new features, improving user experience and working across different areas if needed.

pythonjavascriptdjango+5
Student: Pratik Chanda
Code
Proposal

Cloud-native OGC SensorThings API

intermediate
52°North Spatial Information Research GmbH•2024Varies175h (Medium)

OGC SensorThings API is an international standard to eliminate vendor lock-ins in IoT systems and to create an open geospatial ecosystem by defining a standard data model and describe how to retrieve the ingested data. However, the standard by itself does not specify a way to physically store the data. Most of the current server implementations are all based on Postgres databases using the PostGIS extension. Unfortunately, relational databases are not a great choice to store large volumes of data, which is often the case with IoT applications. As a result, retrieving large volumes of data from any of the open source SensorThings API servers is painfully slow. Modern data lakehouse standards and cloud-native geospatial file formats offer a scalable, modular, cost-effective and a much faster way to store and work with large volumes of geospatial data on the web. Specifically, Apache Iceberg is an open table format for organizing data lakes in object stores and ensuring ACID guarantees. GeoParquet is a cloud-native geospatial file encoding, based on a columnar data storage format for tabular data that significantly compresses the data and improves querying efficiency. A cloud native SensorThings API extension using Apache Iceberg could significantly enhance the standard's ability to ingest and aggregate large heterogeneous streams of sensor data. The proposal hence puts forth a design architecture for any SensorThings API server to use Iceberg to store and retrieve sensor data in a more efficient manner reducing memory overhead and network latencies when retrieving such data over the web. Eventually, as GeoParquet gets merged into Iceberg, the implementation will support a much faster alternative to existing SensorThings API implementations for handling sensor data at scale.

javascriptandroidjava+2
Student: Humaid Kidwai
Code
Proposal

Implement The New Parser

intermediate
The ENIGMA Team•2024Varies175h (Medium)

The ENIGMA project has its own language, EDL (ENIGMA Development Language), along with a dedicated parser. Two years ago, a significant effort was made to completely rewrite the EDL parser, resulting in a recursive descent parser that handles most aspects of the language, though some features remain incomplete. This year, the focus is on further developing the parser to address these unfinished features, implementing the pretty printer to translate the generated AST (abstract syntax tree) to C++ code, replacing the old parser calls with the new ones, and implementing visitor classes such as the declaration gathering visitor and the syntax checker.

androidopenglc+++2
Student: Fares Atef
Code
Proposal

Improving FreeBSD user emulation for various architectures.

intermediate
The FreeBSD Project•2024Varies175h (Medium)

The proposal is to improve QEMU's emulation capabilities on FreeBSD to support and fix issues related to architectures such as ARM, RISC-V, and Aarch64. To achieve this, the goal would be to implement syscalls and other functions from the blitz branch that is being maintained by the mentor. The project will involve finding the necessary calls and adding them to the master branch as a series of patches. My main task would be to upstream changes from the blitz branch after verifying and testing the code, as the end goal is to support more architectures for emulation purposes.

c/c++llvmassembly+5
Student: Ajeet
Code
Proposal

Enhance Simplenews module

beginner
Drupal Association•2024Varies90h (Small)

This project aims to enhance Simplenews newsletter module for Drupal 10, enhancing functionalities from existing modules while prioritizing usability, scalability, and compatibility. The project focuses on improving the Simplenews module by addressing specific issues, such as fixing the incorrect subscriber language for anonymous users , resolving bugs for users with blank email addresses, and adding a setting to disable per-user rendering. Key features include efficient subscriber management, streamlined newsletter creation, engagement tracking, and seamless integration with email service providers. Mentored by @azizos, the 8-week project emphasizes meticulous planning, task assignment, and time management, starting with frontend development. With a strong background in Drupal development and project management, the proposer aims to deliver a comprehensive, user-friendly enhancement for Drupal 10.

mysqljavascripthtml+2
Student: Aditi Upadhyay
Code
Proposal

Music Blocks v4 Project Builder Integration

advanced
Sugar Labs•2024Varies350h (Large)

The Music Blocks v4 project is a complete overhaul of the original Music Blocks project, which was derived from the Turtle Blocks project. The existing implementation, which started in 2015 using native Vanilla JavaScript, lacks modern front-end tooling and ecosystem standards, leading to difficulties in maintenance and subpar performance. The v4 project uses improved application architecture, modern tools (such as Vite, ESLint, Prettier, Docker, Jest, Cypress, etc.), better languages (TypeScript and Sass), and libraries (React for UI rendering). This will significantly enhance the overall developer and user experience, maintainability, and performance. The proposal focuses on implementing one of the main features of Music Blocks, the "Masonry Framework" (previously code-builder/project-builder), which is currently missing in the new version (v4). The is a graphical blocks manager module used to create Music Blocks programs, including interactive blocks like Start, Rhythm, Note, Pitch, Instrument, and many more. These blocks can be dragged, dropped, and clicked to perform actions or open context menus. By implementing the Masonry feature end-to-end, users will be able to create different musical patterns seamlessly. This will bring the v4 project on par with the capabilities of the old version (v3) and provide a more accessible, efficient, and user-friendly application for users to create music through an interactive web application.

pythonjavascriptgtk++10
Student: Karan Palan
Code
Proposal

Feasibility of GPU Acceleration in SU2

intermediate
Stichting SU2•2024Varies175h (Medium)

The following project involves the GPU acceleration of Linear Algebra Computations in SU2. The approach is two pronged, making use of both NvBLAS and incorporation of CUDA Kernels to replace CPU Functions. The goal of the NvBLAS implementation is to intercept Level 3 BLAS calls made by the FEM Solver. Meanwhile, CUDA subroutines have been written to offload Matrix Vector Product calculations in the FGMRES linear solver onto the GPU. The advantages and drawbacks of each approach has been provided in the enclosed report.

pythonc++
Student: Areen Raj
Code
Proposal

Integration of AlphaMissense Pathogenicity Predictions into Genome Nexus and cBioPortal

intermediate
cBioPortal for Cancer Genomics•2024Varies175h (Medium)

This project involves the integration of AlphaMissense, an innovative tool for predicting the pathogenicity of missense mutations, into two established platforms: Genome Nexus and cBioPortal. My Objectives and Deliverables are: - Integrate AlphaMissense pathogenicity predictions into Genome Nexus API responses, enriching genetic variant analysis with detailed pathogenicity scores. - Display AlphaMissense predictions within the Genome Nexus variant pages and add dedicated data columns in the cBioPortal mutation tables, complete with functionalities for sorting, filtering, and downloading. -Add AlphaMissense pathogenicity prediction and score into Genome Nexus annotation pipeline as two new columns in the annotation result file The project will be executed in phases, starting with initialization and planning, followed by backend and frontend development to integrate and visualize AlphaMissense data. Subsequent phases will focus on testing, deployment, and documentation, concluding with a final review and official launch. Post-launch, the project will enter a maintenance and support phase to address any arising issues and incorporate user feedback. Backend development will utilize Java and Spring Boot for integrating the AlphaMissense plugin into the Genome Nexus API. Frontend components will be developed using React and TypeScript, ensuring a dynamic and user-friendly interface for displaying genetic predictions.Comprehensive testing phases, including unit, integration, and User Acceptance Testing, will ensure the reliability and accuracy of the integration. This integration represents a significant leap forward in personalized medicine. By making pathogenicity predictions more accessible and interpretable, this project aims to support advancements in genetic research and clinical decision-making, ultimately contributing to improved patient outcomes.

javascriptjavaweb+9
Student: Ivy Zou
Code

pvlib python improvements on shading and spectral research and modeling

intermediate
NumFOCUS•2024Varies175h (Medium)

This proposal aims to add a variety of scientific utilities to the pvlib python project that will focus on new models and research tools regarding shading and spectral effects. These improvements will contribute to expanding the current capabilities in simulating, analyzing, and researching photovoltaic systems. The proposed improvements are comprised of a shading losses model with an example of row to row trackers shading example; a variety of utilities for researching and estimating spectral mismatch losses; a non-uniform irradiance mismatch losses model, and models for Photosynthetically Active Radiation (PAR). These last models would be used in agrivoltaics, the integration of photovoltaic systems in crops. Further details and references can be found in the Proposal PDF file.

pythonjavascriptr+3
Student: Echedey Luis
Code
Proposal

gccrs - Inline Assembly Support

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

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

cc++openmp+3
Student: jjasmine
Code
Proposal

Make Neutralinojs compatible with older Windows versions

intermediate
Neutralinojs•2024Varies175h (Medium)

Neutralinojs is tested on Windows 10 and 11, but it is not well-tested with older Windows versions. The goal of this idea is to update the Neutralinojs framework source, build scripts, and DevOps workflow to officially support older Windows versions. The underlying cause for this issue is not yet identified and remains to be identified and fixed under this project. The project's idea listed too has the same answer. But it is identified that the project can be categorized under Windows API, DevOps, and Configuration areas.

cjavascriptnode.js+2
Student: Bhuvan Ade
Code
Proposal

Any Collection in Data Model Explorer

intermediate
CERN-HSF•2024Varies175h (Medium)

EDM4hep offers a powerful set of objects to describe event data from simulation to analysis. At any step of this chain, one can inspect the event data containing various collections of the objects, e.g. calorimeter clusters, tracker hits, reconstructed particles, etc. At the moment dmX offers only a limited possibility to visualize a tree of MonteCarlo particles. In this project, dmX is extended to visualize other types of collections and relationships between them as a graph to gain more insights about the collisions useful for further development in the Accelerators world.

pythonc/c++machine learning+6
Student: Braulio Rivas
Code
Proposal

Command-Line Preferences Manipulation

intermediate
FreeCAD•2024Varies175h (Medium)

The project aims to create a Command-line utility tool to manage and manipulate FreeCAD preferences from outside the FreeCAD application. This tool is intended to be used for installing and configuring the FreeCAD all through the scripts.

pythonc++qt+2
Student: Harshita Saraswat
Code
Proposal

Visualise community data

intermediate
freifunk•2024Varies175h (Medium)

The Freifunk project collects a snapshot of data from community groups every hour. This has been going on since 2014, and so far the project has amassed a large historical archive of data, available in compressed JSON files. This project will take that historical data, provide some time-series visualisations, and make it available to query through a GraphQL interface.

cluaopenwrt+15
Student: Pierre Marshall
Code
Proposal

"Enhancing CGAL’s Basic Viewer based on GLFW: Extending Functionality and Refining Implementation

advanced
CGAL Project•2024Varies350h (Large)

In the past, I played an active role in the development of a lightweight basic viewer for CGAL, utilizing the GLFW framework. The primary aim of this project is to complete this endeavor and initiate a pull request for CGAL. The process will involve fixing known bugs, refactoring the codebase, and adding missing functionalities such as control improvement and animation system. The next priority will be to enhance the user experience by adding more complex functionalities like a selection system.

githubc++git+4
Student: Theo Grillon
Code
Proposal

Alt text capabilities

intermediate
Wagtail•2024Varies175h (Medium)

I propose to improve the accessibility of Wagtail websites by enabling editors to add alt text to images. Currently, there's no clear way to do this, leading to inconsistent accessibility practices. My solution involves five main parts that are also my deliverables: (1). StreamField Block for Images: I will create a new block specifically for images that includes an alt text field. This ensures editors don't forget to add alt text. (2). Modifying the Image Model: I will add an "image description" field to the existing image model. This provides more flexibility for alt text. (3). Writing tests. (4). Updating documentation. (5). Exploring the use of AI to generate alt text suggestions (as a stretch goal, along with some other stretch goals in the PDF I attached). I plan to achieve the first two goals by building upon the pertinent Pull Requests I have already drafted at the time of writing this. Goals 3 and 4 will follow each of the first two goals closely, and I have commenced research on integrating AI models with inspiration from the Wagtail-AI GitHub repository. For goal 5, I plan on working hand in hand with the A11y team. This project will make Wagtail sites more accessible for visually impaired users and improve overall accessibility compliance.

pythonjavascriptdjango
Student: Chiemezuo
Code
Proposal

Integrating OpenElis with a FHIR-based Open Client Registry

beginner
OpenELIS Global•2024Varies90h (Small)

This integration aims to connect OpenELIS, a laboratory information system, with a FHIR-Based Open Client Registry which will allow users to search for patients within their local OpenELIS system, If the patient isn't found locally, search the client registry then Import patient information from the client registry to OpenELIS. In simpler terms, this lets users find patients within their local system and if not found, search for them in a central database and bring their information back into the local system.

postgresqljavascriptjava+2
Student: mherman22
Code
Proposal

Proposal for Unified IDL

beginner
Apache Software Foundation•2024Varies90h (Small)

Objectives: 1. Develop toolsets to help unify the development experience using dubbo's IDL mode and Non-IDL mode 2. Develop a set of translation tools to translate in-code interface definition to Protobuf IDL, so that the interface defined in-code can be easily migrated to other programming languages. Plan: 1. Community bonding 2. Basic and extended type mapping between portobuf and non-IDL protocol types 3. Add support to protocol specification in protobuf IDL 4. Add support to reverse translation from in-code interface definition to protobuf IDL 5. Wrap the toolsets into a easy-to-use CLI Deliveries: 1. A CLI that unifies the development using dubbo's IDL and Non-IDL mode 2. Protobuf extensions to help acturalize the features mentioned above

pythonjavascriptjava+7
Student: Chales Xu
Code
Proposal
Showing 2497 - 2520 of 11996 Projects
103104105106107
Proposal
Proposal