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

Target Conditioned Antibody Sequence Generation Using Protein Language Models

intermediate
DeepChem•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)

Monoclonal antibodies (mAbs) are a potent therapeutic because of their ability to precisely target molecular surfaces at a sub-protein level resolution. They are used in cancer checkpoint blockades, treatments for viral infection, and useful in situations of snakebites as anti-venom. Current methods of antibody discovery involve inoculating various chimeric animal constructs with specific antigens and isolating and purifying antigen-specific molecules. As such there has been a significant interest in designing antibodies in-silico. A growing number of large language models have been employed to capture the sequence distributions of these proteins, with varying degrees of success. However, the vast majority of language models are encoder-only transformers whose target-conditioned sequence generation capabilities are limited, and their code is prototypical rather than production ready. This project aims to integrate and finetune a target-conditioned LLM for eptiope-specific antibody design. Extending DeepChem's codebase to include support for this class of therapeutics would not only help democratize this technology for resource constrained operations, but also bring these groups onto a platform with a lively user base and healthy collaborative environment.

pythonnumpypytorch+1
Student: Dhuvi Karthikeyan
Code
Proposal

AI Fictional Travel Itinerary Generator for LG, based on Groq’s API

intermediate
Liquid Galaxy project•2024Varies175h (Medium)

Imagine a captivating journey through iconic destinations brought to life by a fictional travel itinerary generator. In this concept, the application immerses users in a narrative adventure, creating fictional stories of a traveler exploring specific Points of Interest (POIs). The goal is to inspire users' travel itineraries by presenting vivid stories that unfold paragraph by paragraph, each focusing on a different place within the chosen location. In this version of our application, we generate fictional stories by running one of the fastest open-source Generative text AI models, in this case we’ll use Groq.

javascriptrosgis+14
Student: Nevish_302
Code
Proposal

Integrate a Large Language Model with the xeus-cpp Jupyter kernel

intermediate
CERN-HSF•2024Varies175h (Medium)

Xeus-cpp, a Jupyter kernel for C++, is built upon the native implementation of the Jupyter protocol, xeus. This setup empowers users to interactively write and execute C++ code, providing immediate visibility into the results.With its REPL (read-eval-print-loop) functionality, users can rapidly prototype and iterate without the need to compile and run separate C++ programs. Additionally, this integration facilitates seamless interaction between C++ and Python within the same Jupyter environment. With the ever growing popularity of large language models, this project aims to integrate a large language model with the xeus-cpp Jupyter kernel. This integration will enable users to interactively generate and execute code in C++ leveraging the assistance of the language model.

pythonc/c++machine learning+6
Student: Tharun A
Code

Internet Yellow Pages Automatic Deployment

intermediate
Internet Health Report•2024Varies175h (Medium)

The Internet Yellow Pages is a database containing information about internet resources including domain names, autonomous system numbers (ASNs), and subnets, which it receives from 18 organizations including Cisco, Cloudflare, and Stanford University. The data is stored using Neo4j, a graph database known for its flexibility and scalability. It is important that the Internet Yellow Pages contain accurate data from all these sources and provide users with the data quickly and efficiently. However, IHR currently computes a new database of this form each week, and this deployment is not automated, which increases the time it takes to make the new data publicly available. Thus, the goal of this project is to design and implement an automated pipeline to deploy a new database to a remote server each week and to upload the database dump to a public repository. The solution must be maintainable and rigorously tested, with unit tests for each IYP dataset. This ensures that users receive reliable data with no downtime and that future developers can easily expand upon the pipeline. These goals were accomplished by completing the following four subparts: creating unit tests, creating a pipeline to automatically compute a database dump and push it to IHR’s archive, integrating the tests into this pipeline, and extending the pipeline to also deploy a running instance of the database to a remote server. Caddy is used to hotswap newly computed databases and to provide access to previously generated databases.

pythonjavascriptapache kafka+1
Student: rpoon18
Code
Proposal

Integration of Silicon Compiler Microservices into the TL-Verilog Mode in VS-Code

intermediate
Free and Open Source Silicon Foundation•2024Varies175h (Medium)

This project aims to enable the seamless integration of the Silicon Compiler's hardware design tools and flows within popular development environments like Visual Studio Code (VS Code). Silicon Compiler is an open-source, modular build system that automates the translation process from hardware design source code to silicon. It essentially serves as a "make for silicon," enabling developers to efficiently compile and synthesise hardware designs into silicon implementations. By leveraging the Silicon Compiler's microservices and developing a JavaScript API, users will be able to run various hardware design tasks, such as logic synthesis, place-and-route, static timing analysis, and simulation, directly from within their familiar coding environments. This integration will streamline the design process, improve productivity, and provide a seamless experience for developers working with Verilog or related hardware description languages (HDLs) within the editor. Instead of switching between different tools and environments, they can leverage the integrated functionality directly within VS Code, streamlining their workflow and improving productivity.

pythonjavascriptfpga+11
Student: Raj Aryan Singh
Code

Procedural Fragment Shader Generation Using Classic Machine Learning

advanced
The ENIGMA Team•2024Varies350h (Large)

The world of procedural generation in gaming, exemplified by titles like No Man's Sky and Minecraft, utilizes algorithms to create vast universes and landscapes. From textures to terrain, and even sound, these games generate content on the fly, allowing for endless exploration and variation. In projects like ENIGMA, machine learning is poised to enhance this process by crafting shaders that can be converted into dynamic textures, paving the way for even more immersive experiences. By leveraging techniques like genetic programming, developers aim to optimize the generation process, ensuring consistency and quality across diverse gaming environments.

androidopenglc+++2
Student: Seif Kandil
Code
Proposal

aeon - Developing Deep Learning Framework and Implementations for Time Series Clustering

advanced
NumFOCUS•2024Varies350h (Large)

Time series clustering involves grouping similar time series data together based on specific features or patterns. Deep learning algorithms have become increasingly popular for clustering. However, the aeon's deep clustering module currently lacks several deep learning-based algorithms. In this project the aim is to implement some of the top performing and interesting algorithms from a recent comparison of deep learning for time series clustering and benchmark them. This project includes further developing the aeon deep learning networks module, making the package publicly documented for user to explore and well tested to help the maintenance of the deep learning implemented in the future.

pythonjavascriptr+3
Student: Aadya Chinubhai
Code
Proposal

Expand Testing of the Manual/TA Rubric Grading Interface

intermediate
Submitty•2024Varies175h (Medium)

Submitty, the TA grading interface is elaborate, highly-featured, and customizable. However, the interface is visually overwhelming to new graders, and some of our TA grading features are not adequately tested by automated unit and end-to-end (Cypress) regression testing. The primary goals for this project include the expansion of our automated testing of the TA Grading pages and patching bugs uncovered by this improved testing. And the project is to enhance the TA experience, especially for graders who are new to the interface and grading process.

pythonc++databases+5
Student: Rahul Vishwakarma_
Code
Proposal

Enhance automation in testing and CI/CD on cloud-based integration

intermediate
Data for the Common Good•2024Varies175h (Medium)

The lack of automated testing capabilities in the cloud infrastructure of a data-intensive system significantly increases the time and effort required to ensure application quality. This is particularly cumbersome when the Quality Assurance (QA) team needs to set up its testing environments, connect to the development environment, and then execute test plans. A well-established CI/CD pipeline would support quality assurance and integration efforts, thereby streamlining the process. The objective of this project is to construct a CI/CD pipeline that automates the test suite execution process and improve test coverage comprehensively. This includes automated tasks such as adding authentication, installing dependencies, and configuring integration test scenarios, which are currently performed manually. By enhancing CI/CD and automating testing procedures, it will significantly reduce the team's time investment in the validation phase of the development cycle for the cloud system. This not only ensures the reliability and accuracy of D4CG platform’s data but also enables researchers to utilize this data to advance cancer research and increase opportunities for discovery.

pythonjavascriptkubernetes+2
Student: Wenbo_Qian
Code

LLVM.org Website Redesign

intermediate
LLVM Compiler Infrastructure•2024Varies175h (Medium)

Problem Statement: Redesigning and migrating the llvm.org website to enhance user experience, accessibility, and community engagement. Solution Approach: I will begin by creating a design mockup, refining it based on feedback from the community. Once finalized, I'll implement this design using Hugo, leveraging modern web technologies to create a reusable theme adaptable for other LLVM sub-projects. Central to this effort is the use of YAML data files, separating content management from visualization. This empowers the community to update and add content seamlessly, without the need for HTML coding. I'll ensure a smooth transition by migrating existing content and adding new material. Automated deployment and hosting setups will be established to maintain the website's currency. Additionally, I'll meticulously document design decisions, implementation strategies, and maintenance practices for future reference. Deliverables: 1. Content Audit: Analyze existing content and structure to identify areas for improvement. 2. Design Mockups: Create modern and user-friendly design mockups for the new website. 3. Implementing Chosen Design: Develop the new website using Hugo, a static site generator, and modern web technologies. 4. Utilizing YAML Data Files: Utilize YAML data files to manage content and separate data and visualization. 5. Migrating Content: Migrate existing content to the new website and ensure no data loss, also updating and adding new content. 6. Deployment & hosting: Deploy the new website on a suitable hosting platform and ensure it is accessible to the community. 7. Documentation: Document the design decisions, implementation details, and best practices for maintaining the website. Impact: Enhanced user experience, improved site visibility, and community empowerment through a modern and accessible llvm.org website.

cllvmc+++3
Student: Chaitanya Shahare
Code
Proposal

Linux audio capture local muting

advanced
Chromium•2024Varies350h (Large)

My proposal centers on enhancing the Chrome browser's functionality on Linux systems, particularly focusing on the integration of local audio muting capabilities during audio capture sessions. This addresses a specific problem faced by users who need to share or cast their screen without transmitting local sounds, like notifications or other disturbances, which can detract from the experience or the content being shared. I plan to solve this by extending Chrome's existing audio capture features to include the ability to mute local audio. This will be accomplished by developing a new module for PulseAudio, which will interface with Chrome through its native messaging APIs, ensuring a seamless experience for the user. The deliverables for this project include: A new PulseAudio module capable of muting local audio without affecting system audio capture. Extension of Chrome's audio capture API to control the new PulseAudio module. A user-friendly interface within Chrome's settings to enable and manage local audio muting. Comprehensive documentation detailing the use and integration of the new feature. A full suite of tests to ensure functionality, performance, and security.

pythonjavascriptjava+2
Student: Alexia Bojian
Code
Proposal

Open Cluster Management: Scheduling AI workload in multi-clusters

intermediate
CNCF•2024Varies175h (Medium)

Enhance Open Cluster Management (OCM) to efficiently schedule AI workloads across multiple Kubernetes clusters by optimizing the use of GPU/TPU resources. Key components: 1. GPU/TPU Resource Evaluation Addon: Extend OCM's placement strategy to include GPU/TPU resource availability. This project introduce an AddonPlacementScore that assesses GPU/TPU resources in cluster sets, which informs scheduling decisions to ensure AI workloads are distributed based on specific GPU/TPU resource requirements. 2. OCM Kueue Admission Check Controller: Deliver a proposal for the external Kueue Admission Check controller integrating OCM Placement results with MultiKueue. The controller reads OCM Placement decisions and generates corresponding MultiKueueConfig and MultiKueueCluster resources, streamlining the setup of the MultiKueue environment and enabling users to select clusters based on custom criteria. Deliverables: GPU/TPU Resource Evaluation Addon, OCM Kueue Admission Check Controller, Comprehensive Documentation and User Guides.

gorustkubernetes+3
Student: Zhe Shen
Code
Proposal

CNCF GOSST Collaboration - Enhancing Security Across CNCF Ecosystem

intermediate
CNCF•2024Varies175h (Medium)

The Cloud Native Computing Foundation (CNCF) hosts a diverse ecosystem of cloud-native projects. Ensuring the security of these projects is paramount to maintain trust and reliability within the community. By adopting OpenSSF Scorecards, integrating OSS-Fuzz, and implementing enhanced build/release security practices, CNCF projects can strengthen their security posture, mitigate risks, and build trust among users and contributors. This proposal outlines a comprehensive approach to drive security improvements across the CNCF ecosystem, ultimately contributing to the resilience and reliability of cloud-native technologies. Project Deliverables: Adoption and integration of OpenSSF Scorecards. Remediation of Identified Vulnerabilities which includes things like code fixes, configuration changes, and security enhancements. Improvement of OpenSSF Scorecard Scores by focusing on key security metrics and risk assessments. Integration of OSS-Fuzz, Google's continuous fuzzing service, into the CNCF ecosystem to identify and address security vulnerabilities through automated fuzz testing. Enhanced Build/Release Security.

gorustkubernetes+3
Student: Harshita Sao
Code
Proposal

Traceroute Visualization

intermediate
Internet Health Report•2024Varies175h (Medium)

This project aims to address the need for a more effective way to visualize traceroute data, specifically focusing on latency increases in upstream networks. With a plethora of traceroute data available from RIPE Atlas, the current challenge lies in the absence of an intuitive and detailed visualization tool. This proposal seeks to fill that gap by developing a comprehensive visualization solution that leverages RIPE Atlas data to enhance network analysis and troubleshooting capabilities.

pythonjavascriptapache kafka+1
Student: Anastasios-Theodosios Meletlidis
Code
Proposal

Support Memory Management Module For Apache HugeGraph

advanced
Apache Software Foundation•2024Varies350h (Large)

This project addresses the latency and response time variability issues in the hugegraph-server query engine by introducing memory management framework to it. Currently, the engine utilizes off-heap memory in most OLTP algorithms, but lacks the ability to control memory allocation per individual query, leading to potential out-of-memory (OOM) errors. The project aims to design and implement a unified memory management framework to address this limitation. This framework will include features such as lifecycle management of memory objects, memory capacity restrictions, and an allocator interface for efficient memory allocation and release. By implementing this framework, the project is expected to improve the stability and performance of the hugegraph-server, ultimately enhancing its usability and reliability for users.

pythonjavascriptjava+7
Student: Pengzna
Code

Make Stack Checker Error Handler Configurable

intermediate
RTEMS Project•2024Varies175h (Medium)

RTEMS real-time operating system utilizes a stack checker to detect stack overflows during execution. While this feature is essential for system stability, the current error handler provides limited options for customization. This project aims to enhance the RTEMS stack checker by developing a configurable error handler. There are some features we are proposing that would help in making the stack checker more flexible and configurable, like enabling/disabling certain types of stack checking, giving the user the ability to set up a threshold for maximum allowable stack usage and performing some action based on how much stack is used relative to this threshold. In addition, we can rearrange the code so that we separate the stack checking functionality from the reporting functionality, which we believe will help to improve the code organization and readability

cpythonembedded systems+5
Student: Mohamed H. Hassan
Code
Proposal

Improve nothrow detection in GCC

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

Exception handling in GCC follows the Itanium ABI, particularly the C++ exception handling ABI. This process involves creating, throwing, and finally destroying the exception object. The strategy employed is known as the Zero Cost strategy, which aims to minimise the impact on the main program execution path. It achieves this by pushing all exception handling operations into separate side tables, thus avoiding any potential negative effects on the instruction cache. When an exception is caught, GCC utilises DWARF information to unwind the stack, allowing the program to resume execution at the appropriate point. However, one current limitation is that GCC does not track the specific type of exception that is thrown. This project aims to improve the nothrow detection in GCC which will allow to eliminate the dead exception handling regions and thus optimise the intermediate code generated.

cc++openmp+3
Student: Pranil Dey
Code
Proposal

Checkpointing in DOLFINx using ADIOS2

advanced
NumFOCUS•2024Varies350h (Large)

Large scale simulation of scientific and engineering problems requires high performance and distributed memory systems. Computing resources and time are not unlimited and efficient usage of the computing resources calls for scalable and flexible checkpointing which is the ability to start, pause and resume simulations, thus saving energy consumption and money. FEniCS is a popular open-source computing platform for solving partial differential equations (PDEs) with the finite element method (FEM). For the latest version of FEniCS project known as DOLFINx, ADIOS4DOLFINx is a prototype checkpointing framework that implements several variations of checkpointing using the state of the art *The Adaptable Input Output (I/O) System* called ADIOS2. Now, there is a need for implementing checkpointing functionality as a core feature of the DOLFINx. Since DOLFINx is a C++ library with a Python wrapper, this feature is implemented in C++ with appropriate APIs exposed to the python user using nanobind.

pythonjavascriptr+3
Student: amujahid
Code
Proposal

Google Summer of Code Community Hub 2024

beginner
rocket.chat•2024Varies90h (Small)

The Google Summer of Code Community Hub project for Rocket.Chat is centered around developing a full-stack web application designed to streamline collaboration for open-source communities. Built using a custom component framework, the project emphasizes two key areas of innovation - 1. Syntax Sweetening Framework: By introducing HTML-tag-like notation into component layout files, this approach simplifies server-side customization. The result is a more intuitive development process, allowing for easy layout generation through WYSIWYG (What You See Is What You Get) IDE tools. This makes the platform accessible to developers of varying skill levels. 2. Data Definition and Maintenance: A robust system was implemented to manage component data efficiently, ensuring flexibility and scalability across the platform. This allows the Community Hub to meet the diverse needs of different open-source communities. The overarching goal is to create a highly customizable, scalable platform that enhances collaboration and communication within open-source communities

javascriptwebrtcmeteor.js+18
Student: Anjaneya Gupta
Code
Proposal

Multiple services using keploy (API chaining)

advanced
Keploy•2024Varies350h (Large)

-Integration of Contract Testing into Keploy, -Implement functionality within Keploy for recording tests and mocks for all related microservices simultaneously. This feature would capture both ingress and egress traffic, utilizing process identification (PID) for filtering. The primary goal is to ensure that tests and mocks remain synchronized across all services, thereby maintaining consistency and accuracy in testing environments. -Automated Change Management for API Chains -In Keploy, testing multiple services via API chaining emphasizes enabling contract testing to ensure seamless interactions among services. This ensures that all communications across services meet predefined expectations, enhancing the reliability of interconnected systems. -Contract testing is a method focused on verifying interactions between microservices, applications, or systems, ensuring correct communication through predefined contracts. It facilitates early issue identification and reduces complex end-to-end testing needs.

javagolangnode+4
Student: Ahmed Lotfy
Code
Proposal

Multiboot2 Support in Unikraft

intermediate
Unikraft•2024Varies175h (Medium)

Unikraft is a unikernel capable to boot in various environments and through quite a few boot protocols. From supporting the first version of Multiboot, being able to boot through the Linux Boot Protocol on ARM64 and having its own UEFI stub enabling the Operating System to load without a Bootloader, Unikraft has still a lot to learn with respect to the booting environments it knows. One such booting protocol that would be very useful is Multiboot2. This protocol represents a significant improvement over Multiboot version 1, providing improved flexibility in the realm of bootloaders. A notable improvement is the extended information provided by Multiboot2, which provides detailed and accurate communication between the bootloader and the operating system kernel during the bootstrapping process. In addition, Multiboot2 comes with a standardized tag system, enabling easier data and system configuration parsing between the bootloader and the kernel and allowing greater interoperability and better integration of boot modules. The introduction of optional commandline further enhances the flexibility of the boot process. Together, these enhancements contribute to a more robust and scalable bootstrapping mechanism, making Multiboot2 a better choice than Multiboot version 1. Concretely speaking, it would allow us to boot directly in 64-bit mode, while having access to pointers to the UEFI tables as well as the ACPI tables, unlike Multiboot 1, offering us access to more modern firmware interfaces. The task at hand involves integrating the Multiboot2 definitions as well as its corresponding bootstrapping code into Unikraft. Auxiliary scripts may be implemented to allow the automatic creation of Multiboot2-based Unikraft bootable images.

cpythonxen+3
Student: Maria Pana
Code
Proposal

Revamping Hari-Plotter

beginner
Python Software Foundation•2024Varies90h (Small)

This project focuses on the visualization, and pre-and post-processing of opinion dynamics simulations with the Hari-Plotter code. Especially, for the application to real-world data the post- and preprocessing of data are of paramount importance. Opinion dynamics models are often simple, yet understanding patterns in potentially high-dimensional opinion spaces is a significant task. Therefore, this project aims to bridge the gap between simple toy models and complex real-world issues. Hari-Plotter is based on NetworkX to handle graphs, with several classes to handle simulations and run data. During the Google Summer of Code, I will work on handling multi-dimensional opinions, different agent types encoding various behavioral patterns and clustering opinions, and I will add functionality for averaging data over multiple simulation runs. In addition, I plan to work on adding documentation to make Hari-Plotter more user-friendly and accessible.

pythonmercurialjavascript+3
Student: Ivan Tambovtsev
Code
Proposal

PyElastica: Binding PyElastica with Elastica++

advanced
Python Software Foundation•2024Varies350h (Large)

The goal of the proposal is to implement bindings for C++ based Elastica++ to the python based PyElastica, to achieve speedups. It covers selecting a suitable C++ build system and setting up the compilation architecture, writing binding code using pybind11 or alternative methods, benchmarking against existing Python implementations, expanding unit tests, polishing documentation and typestubs, and updating the CI pipeline for building and testing on multiple Python versions.

pythonmercurialjavascript+3
Student: Ankith
Code
Proposal

Native css support

intermediate
webpack•2024Varies175h (Medium)

Native CSS Support is capable of replacing mini-css-extract-plugin, style-loader and css-loader, with better support for Hot Module Replacement (HMR), In the future, handling CSS could become more convenient without relying on third-party loaders and plugins. Currently, Native CSS still has many issues, which you can check out at https://github.com/webpack/webpack/issues/14893. This includes support for various import methods, CSS minimization, preload/prefetch CSS files, and magicComment support, among others. Many of these functionalities can be implemented based on the JavaScript module's implementation. Additionally, there is a need for further research and modification of the CSS

javascriptnode.jsweb development+6
Student: zhaochenliu
Code
Proposal
Showing 2905 - 2928 of 11996 Projects
120121122123124
Proposal
Proposal
Proposal
Proposal