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

Integrating TCAM IP into Chipyard via MMIO and RoCC Interfaces

intermediate
Micro Electronics Research Lab - UITU•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)

This project focuses on integrating a Ternary Content Addressable Memory (TCAM) module into the Chipyard SoC framework to enable high-speed parallel matching operations crucial for domains like networking and pattern recognition—functionality not natively supported in Chipyard. The integration employs a dual approach: first, incorporating the Verilog-based TCAM IP (generated via OPENTCAM) as a memory-mapped I/O (MMIO) peripheral by wrapping it in a Chisel BlackBox, connecting it to the subsystem using TileLink, and exposing TCAM operations like write and search through memory-mapped registers accessible from software; and second, integrating the TCAM as a RoCC accelerator by reusing the BlackBox within a custom LazyRoCC module, mapping Rocket’s RoCC interface to TCAM operations via funct fields of custom instructions, and enabling instantiation through a dedicated WithTCAMRoCC configuration in the Rocket tile.

RISCVProcessorHardware+2
Student: Atharva Nerkar
Code
Proposal

achieve ndarray API parity with built-in JavaScript arrays

advanced
stdlib•2025Varies350h (Large)

JavaScript lacks a general purpose and cache efficient multi-dimensional array API for operating on large datasets of high-dimensionality. To address this limitation, stdlib provides ndarray API for creating and manipulating multi-dimensional arrays. This project aims to extend those efforts by achieving full API parity between stdlib ndarrays and built-in JavaScript arrays. This work will include implementing functions such as concat, find, flat, includes, indexOf, reduce, some, none, any, with, sort and others to facilitate high-performance data transformation and manipulation. For performance intensive operations such as searching, sorting and reductions, this project will develop C implementations and corresponding Node.js native add-ons for accelerated performance. These enhancements will allow JavaScript developers to work with multi-dimensional arrays with the same ease as working with built-in arrays and thus expand JavaScript's capabilities for scientific and numerical computing.

cjavascriptnode.js+2
Student: muhammad_haris
Code
Proposal

Improving search functionality for Documenter.jl

advanced
The Julia Language•2025Varies350h (Large)

This project aims to significantly enhance the search experience within documentation generated by Documenter.jl. The current client-side search encounters difficulties accurately indexing and retrieving results for Julia-specific syntax, leading to suboptimal relevance. Furthermore, issues like unnecessarily large search indices and repeated listing of the same location hinder usability. This proposal outlines a plan to address these shortcomings by: 1) Implementing search performance benchmarks (relevance, precision/recall, index size) to measure and guide improvements. 2) Developing and integrating an improved, Julia-aware tokenizer within the search JavaScript. 3) Optimizing the index by investigating and removing redundant data, ensuring unique location entries are stored, and adding warnings for potentially problematic large indices. 4) Creating comprehensive developer documentation for the enhanced search system. The outcome will be a more robust, accurate, and efficient search capability for users navigating Julia package documentation.

cjavascriptc+++12
Student: Mohd Rahban Ghani
Code
Proposal

5G CELL SCANNER

advanced
GNU Radio•2025Varies350h (Large)

This project develops an open-source 5G cell scanner utilizing GNU Radio and SDR hardware to passively detect and decode 5G signals, extracting key broadcast data, including the MIB (Master Information Block) and SIB1 (System Information Block 1). It provides real-time monitoring, multi-band scanning, and improved usability for researchers and network analysts. 1. Python-based DSP pipeline for 5G synchronization and decoding. 2. GNU Radio out-of-tree (OOT) module for real-time Software-Defined Radio (SDR) processing. 3. Visualization and logging tools for 5G network analysis. 4. Comprehensive documentation for ease of use and future development. This tool will expand GNU Radio’s 5G capabilities, supporting open-source wireless research and advanced cellular network analysis.

pythonc++dsp+6
Student: <Aaditya/>
Code
Proposal

Improved Audit Logging

intermediate
OpenMRS•2025Varies175h (Medium)

OpenMRS currently utilizes Hibernate Envers to track database changes, offering robust audit capabilities. However, the system lacks a user-friendly way for administrators to view, filter, and interact with audit logs. This project proposes building a backend module that exposes audit log data in a meaningful way through a legacy UI-based audit log viewer, REST endpoints for external access, and an extension that tracks read operations on selected entities—something Envers does not support out-of-the-box. The solution will include: 1. Audit log retrieval and visualization within the legacy UI 2. Custom tracking of read operations using Hibernate event listeners or an alternative approach 3. Filtering capabilities (by user, date, and entity) 4. RESTful APIs for external access to audit data 5. A well-documented architecture, extensible to other OpenMRS modules By the end of this project, OpenMRS administrators will have a comprehensive and usable interface to audit system activity, improving transparency, traceability, and compliance with healthcare data standards.

javahtml5groovy+11
Student: Njidda Salifu
Code
Proposal

Context-Aware Autocomplete and Refactoring Enhancements for the p5.js Web Editor

beginner
Processing Foundation•2025Varies90h (Small)

Currently, the autocomplete feature in the p5.js Web Editor is facilitated by CodeMirror and a custom-built static hinter (as given in the structured JSON file, p5-hinter.js). The hinter suggests all the available functions, and while it is helpful, the current implementation lacks context-awareness, and that can be confusing, especially for beginners. In this project, I will improve the autocomplete by making it context-aware which means it will only show suggestions that make sense based on where the cursor is in the code. I will also add autocomplete for user-defined functions, variables, and classes, and support features like jump-to-definition and renaming. This will make the editor more beginner-friendly, intuitive, and efficient to use.

pythonjavascriptandroid+6
Student: Kamakshi
Code

Building Comprehensive AI support system for gprMax

advanced
gprMax•2025Varies350h (Large)

This project aims to enhance gprMax's user support capabilities by integrating advanced Language Model (LLM) technologies. The core goal is developing an AI-driven chatbot capable of interpreting natural language user instructions and generating accurate, ready-to-run gprMax input files. The project is scheduled for completion within a 12-week timeframe, divided into clear milestones ensuring systematic progression and iterative refinements. The final deliverables will great improve the user experience of gprMax and laying foundation for future AI integration.

pythoncythoncuda+3
Student: Jichao Fang
Code
Proposal

Grid Aware Websites

advanced
Wagtail•2025Varies350h (Large)

This project focuses on making Wagtail.org more energy-efficient by adapting its content based on the environmental impact of the user's location. When electricity is being generated from more carbon-intensive sources, the website will automatically adjust its behavior, such as serving lighter images or reducing animations to lower its energy usage. The goal is to create a more sustainable browsing experience while maintaining performance and accessibility. Along the way, insights will be gathered to help guide other developers in building low-carbon websites using Wagtail.

pythonjavascriptdjango
Student: Rohit.Sharma
Code
Proposal

Enhancing OpenAPI Documentation Generation

intermediate
OpenMRS•2025Varies175h (Medium)

This project implements a Maven plugin that generates accurate OpenAPI 3.0 specifications for any OpenMRS module by introspecting REST resources at build-time. The plugin leverages the OpenMRS test context within a forked JVM to discover all resource handlers, automatically detecting every available property including those accessible through custom representations, without requiring any code annotations or modifications. Key deliverables include the functional Maven plugin with comprehensive schema introspection, generated OpenAPI specifications with full representation support and developer documentation, enabling automated API documentation for OpenMRS implementations.

javahtml5groovy+11
Student: Marvin Sukumar
Code
Proposal

MBDyn Python Preprocessor Development

intermediate
MBDyn•2025Varies175h (Medium)

The MBDyn Python Preprocessor simplifies the creation of input files for MBDyn simulations by bridging Python programming with MBDyn's input format. This project enhances the simulation workflow through two key improvements. The first transforms the YAML-based Rotorcraft Parametric Modeling tool into Python classes within the preprocessor, creating an object-oriented framework for rotorcraft modeling. The second integrates the preprocessor with Blendyn (a Blender add-on), enabling users to create, edit, simulate and visualize MBDyn models entirely within Blender. These enhancements make MBDyn modeling more intuitive and accessible while providing a seamless workflow for both pre- and post-processing tasks.

pythonc++c/c++
Student: Shimul Baidya
Code
Proposal

Prototype Cargo Plumbing Commands

intermediate
The Rust Foundation•2025Varies175h (Medium)

This project prototypes a new set of Cargo plumbing commands, aligned with Rust’s 2025H1 project goals. Plumbing commands are lower-level, less opinionated commands to interact with the Cargo API. By focusing on lower-level functionality, this project aims to better support Cargo users’ specific processes and use cases. Moreover, the introduction of these new Cargo plumbing commands aims to fix current issues of existing commands and improve their integration.

pythonrust
Student: Vito Secona
Code
Proposal

pwndbg: musl allocator support

intermediate
Python Software Foundation•2025Varies175h (Medium)

pwndbg currently has support for debugging the jemalloc and glibc allocators. There are many programs out there that use different allocators, so extending support is important. I will implement support for musl's allocator: mallocng. This will require gaining a precise understanding of the used data-structures and algorithms. It will involve carefully reading the source (https://git.musl-libc.org/cgit/musl/tree/src/malloc/mallocng). In the end pwndbg will have additional commands for visualizing the data-structures used by mallocng, analogous to the heap, bins, arena, mp, vis etc. commands used for glibc malloc.

pythonmercurialjavascript+3
Student: k4lizen
Code
Proposal

Implementing a Domain for Formal Power Series in SymPy

advanced
SymPy•2025Varies350h (Large)

This project implements a domain system for formal power series in SymPy, enhancing the ring_series module with PowerSeriesRing (Domain), PowerSeriesPolyRing, and PowerSeriesElement classes. It enables efficient series expansions, domain integration, and arithmetic over diverse coefficient domains (e.g., QQ, RR). Key deliverables include a robust API, Taylor expansions (e.g., sin, exp), and documentation. Extended goals involve optimizing ring_series and fixing bugs for better performance.

pythonc++numpy+1
Student: Jatin Bhardwaj
Code
Proposal

Beehive: Health Metrics Framework for Behavioral Health in Alaska.

intermediate
Alaska•2025Varies175h (Medium)

Beehive aims to be a scalable web application that enables users to capture, upload, and manage images seamlessly while ensuring automation, security, and efficiency. The project will feature a robust UI, a secure backend with role-based access, and cloud deployment with CI/CD integration for smooth updates. Final Deliverables: - Fully functional web application - Secure authentication and role-based access - Automated CI/CD & cloud deployment - Testing & security validation

pythonmysqljava+2
Student: IshaanxGupta
Code
Proposal

Enhanced Kotlin Code Quality Reporting with Gradle Problem API: Integration with Detekt and Ktlint

intermediate
Kotlin Foundation•2025Varies175h (Medium)

As developers, we always favor tools that enhance and streamline the programming process, including plugins that provide error reporting and insights to improve the code quality. Kotlin developers using Gradle rely on tools like Detekt and Ktlint to enforce code quality. While Detekt and Ktlint offer reporting in various formats like (HTML, SARIF), their current integration with IDEs can be fragmented, requiring developers to switch contexts and manually review findings, which disrupts the coding workflow and slows down their development process. This project aims to implement a unified and actionable code quality reporting system through the integration of the recently introduced Gradle new Problems API. This API provides structured and rich information about the problems happening during a build. The information provided can be used by different interfaces such as Gradle’s console output, build scans, or IDEs to communicate any issues. With this API integration and structured format of the generated report, developers can experience faster issue identification, streamline debugging, and have improved code maintainability. This project will provide value to the Kotlin development community by upgrading the quality of their error reporting.

gradlekotlinjvm+3
Student: Vanessa Johnson
Code

AI-Powered Behavioral Analysis for Mental Health Crisis Detection and Geospatial Trend Analysis

intermediate
HumanAI•2025Varies175h (Medium)

This project aims to build an AI-driven behavioural monitoring system to detect mental health, suicide, and substance use crises in real time using social media data. It will analyse engagement patterns and crisis-related language using NLP (TextBlob, BERT, LDA) and geotag posts for mapping regional distress trends. Deliverables include a sentiment and risk classification pipeline, geospatial heatmaps, and an interactive dashboard to help public health teams proactively identify and respond to emerging crises.

pythonmachine learningc+++2
Student: Vishnu Sankhyan
Code
Proposal

AI-Based API Response to Dynamic UI and Tool Generator

beginner
API Dash•2025Varies90h (Small)

This project introduces an AI-powered agent that automates the transformation of API responses into structured UI schemas and functional UI components across various frontend frameworks. Using Multiple LLM-Based Agents, the system eliminates the need for manual UI creation by intelligently analysing API responses and generating corresponding UI structures. Additionally, it enables dynamic modification of UI components based on user prompts, allowing for customisation in design, layout, and behavior. By seamlessly integrating these capabilities into a unified workflow, the project streamlines frontend development, reducing manual effort and accelerating the UI generation process with a single-click solution. The project also aims to create a simple one-click API Request to Tool Generation pipeline that can enable external AI agents to interact with APIs without any manual coding Deliverables: • A Modular AI Agent Creation & calling mechanism for apidash's future AI-based tasks • One-Click solution to generate UI components from an API Response • One-Click solution to automatically generate API Tools to be used in various Agentic Frameworks like Langchain, Autogen and so on.

flutterapiai+5
Student: Manas Hejmadi
Code
Proposal

Expected Returns: Factor Formation

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

Financial factor investing relies on rigorous quantitative research to explain asset returns and generate alpha. While many academic models and institutional frameworks exist, open-source tools that replicate these methods — especially in R — are few and far between. This project aims to close that gap by contributing to the ExpectedReturns package, developing clean, modular functions that implement and generalize key factor construction techniques inspired by Antti Ilmanen’s Investing Amid Low Expected Returns. The focus will be on engineering reusable code for factors like value, momentum, profitability, and investment using raw or semi-structured financial data. These will be built using lightweight, testable components supported by packages like FactorAnalytics, PerformanceAnalytics, and tinytest, while following conventions used by Chen, Zimmermann, and Kelly. Also included will be vignettes and documentation that show how to reproduce these concepts in practice — making the tools both transparent and portable. This will be a two-month project. Deliverables will include: – Core functions for factor construction and data prep – Lightweight unit tests and clean vignettes – Documentation of inputs, outputs, and assumptions – A reproducible build setup that works across systems The goal is to make these concepts accessible — not just for researchers, but for anyone trying to understand and apply factor models in real-world contexts. If successful, this project will leave behind a set of tools that are as useful to the open-source community as they are to academic replication.

cc++r+4
Student: Al Pakrosnis
Code
Proposal

TMVA SOFIE - Enhancing Keras Parser and JAX/FLAX Integration

advanced
CERN-HSF•2025$6k–$13.2k350h (Large)

The SOFIE (System for Optimized Fast Inference Code Emit) project is an initiative within the TMVA (Toolkit for Multivariate Data Analysis) framework in ROOT, which aims to enhance the efficiency and speed of inference on Machine Learning Models. SOFIE converts ML models trained in different frameworks such as ONNX, PyTorch, and Tensorflow, converting them into an Intermediate Representation (IR). This IR allows SOFIE to generate optimized C++ functions for fast and effective inference of neural networks and subsequently convert them into C++ header files, which can be used in plug-and-go style for inference. For GSoC 2025, this project aims to enhance the Keras parser to support models trained in the latest TensorFlow v2.18.0, which introduces NumPy 2.0 compatibility. As well as Integrate JAX/FLAX support, enabling SOFIE to generate C++ inference functions for models developed using JAX/FLAX

pythonc/c++machine learning+6
Student: Prasanna Kasar
Code

Modern time series estimation

intermediate
R project for statistical computing•2025Varies175h (Medium)

This project will implement the recent techniques from Gallagher et al. (2024) and Gallagher et al. (2025) for improved time series simulation studies covering the whole parameter space of time series models (and not just cherry-pick one or two parameter settings) and also bring modern estimates of the acf/pacf and consistency in AIC selection of ar models (which is not currently available). Specifically, the project will: - create functions for acf and pacf estimation based on a dual shrinkage approach - create functions for ar estimation based on the dual shrinkage pacf - interface the new ar estimation function with standard methods such as AIC for consistent estimation - create new graphics for displaying these estimates that make clear to the user the effect of the dual shrinkage approach (as an option) - create functions to generate ARMA parameters that satisfy a correlation constraint (high/med/low or a fixed correlation strength) - create functions to generate random ARMA parameter values that cover the whole parameter space regardless of the model order - create a wrapper for the above two functions to generate simulation datasets for researchers in one line of code All this functionality will require appropriate documentation, testing and a vignette for users.

cc++r+4
Student: Andrea Storey
Code
Proposal

gemini-batcher: A Python package and learning resources for efficient API calls with Gemini LLMs

beginner
Google DeepMind•2025Varies90h (Small)

The aim of this project is to develop a comprehensive learning resource for developers working with the Gemini Python SDK. This would consist of a range of documentation, interactive code samples and an easy to use pre-written package that demonstrate cover a range of topics which can be used to efficiently manage long content, one of the most common challenges when building with large language models. It will provide an overview of techniques such as batching, chunking and handling various media types (such as text, audio and video) in addition to highlighting best practices for techniques such as caching and error handling.

pythonjavascripttypescript+2
Student: Phillip Daniel
Code
Proposal

Robot Data Collection improvement

beginner
dora-rs•2025Varies90h (Small)

This project aims to enhance robot data collection using affordable kits and the Dora framework. It involves building a modular MuJoCo simulation for robotic arms, implementing a Dora data collection node in the LeRobot format, and generating diverse manipulation datasets. The collected data will be documented, open-sourced on HuggingFace, and supported by beginner-friendly tutorials and demos to showcase real-world applications. Deliverables include simulations, a data collection tool, a sample dataset, documentation, tutorials, and a public dataset release.

pythonrosc+++2
Student: Shashwat Patil
Code
Proposal

Pocketpy : Develop math operators for cTensor library

intermediate
Python Software Foundation•2025Varies175h (Medium)

pocketpy provides a tensor library, cTensor, for users who want to integrate neural networks into their applications. cTensor implements automatic differentiation and dynamic compute graphs. It allows users to train and deploy neural networks on client-side devices like mobile phones and microcontrollers (e.g. ESP32-C3)

pythonmercurialjavascript+3
Student: Advait Gaur
Code
Proposal

ClangIR upstreaming

advanced
LLVM Compiler Infrastructure•2025Varies350h (Large)

ClangIR is a new, MLIR-based intermediate representation of C and C++ code. It has been developed in an LLVM incubator project, but work is now underway to migrate the code from the incubator to the main LLVM repository. The goal for this project is to upstream the VectorType, ComplexType and Exception handling

cllvmc+++3
Student: Amr Hesham Gaber
Code
Proposal
Showing 1513 - 1536 of 13453 Projects
6263646566
Proposal
Proposal
Proposal