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

PiType: A Protein Interaction Prediction Cytoscape App

intermediate
National Resource for Network Biology (NRNB)•2017Varies

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)

<p>PiType is an already existing protein-protein interaction classifying tool created by my mentor. It currently exists as both a web app and a standalone software package. PiType is designed to classify proteins within a network into different categories: Mutually Exclusive (ME) vs Simultaneously Possible (SP) and Obligate (O) vs Non-Obligate (NO). To do this, PiType takes a series of proteins within a network, analyses them to determine which of the above categories they fit into, and outputs that information as a table. Because of the current input and output format, it is difficult for biologists to analyze and interpret the data. Cytoscape is open source software that provides numerous modules for studying and visualizing protein networks, and as such is the perfect tool to use for PiType. My project over the summer will thus be to create a Cytoscape plugin app using PiType’s already existent algorithms, to create a visualization tool that provides an intuitive interface for biologists. By taking the base features of PiType, and implementing them as a Cytoscape plugin, my project will widen the number of potential users, and the utility of the app.</p>

pythonjavascriptjava+11
Student: MWrana
Code
Proposal

Operation Theater Module Workflow Enhancements

intermediate
OpenMRS•2017Varies175h (Medium)

<p>This proposal considers performing modifications to the existing Operation Theater module to migrate it to the latest OpenMRS platform. The other main goal is to complete the workflow data capturing part along with scheduling to complete the OT module.</p> <p>It discusses</p> <ul> <li>the dependencies in migrating the module</li> <li>Data that needs to captured in operation theater workflows</li> <li>Running the scheduler automatically when the schedule is manually modified</li> <li>Generating reports related to the Operation theaters.</li> </ul>

javahtml5groovy+11
Student: Chanuka Wijayakoon
Code
Proposal

Statsmodels: Survey methods and adding weights to existing methods

advanced
Python Software Foundation•2017Varies350h (Large)

<p>This project aims to provide support for survey methods in StatsModels. In particular, survey summary statistics, adding probability weighting to existing methods such as mixed effect models and Cox models, and inference for complex surveys are primary goals. Additionally, I plan to extend GEE such that the weights are allowed to be non-constant within groups and also implement Weighted Multilevel models. I will write unit tests for all implemented approaches, testing against R and Stata.</p>

pythonmercurialjavascript+3
Student: Jarvis Miller
Code
Proposal

Updating gopy to support Python3 and PyPy

advanced
CERN-HSF•2017Varies350h (Large)

<p>gopy is an excellent tool which generates (and compiles) a CPython extension module from a go package. And I hope more developers could make full use of gopy to migrate their go code into python code. To make gopy more advanced, It is necessary to provide APIs for various Python compiler versions, such as CPython 2/3 and PyPy. This can be improved with CFFI or ctypes. Moreover, many go’s implementations/features are not yet implemented in gopy. So we need to implement implementations such as slices, interfaces, and maps in the go.</p> <p>My goal is to update gopy by using CFFI to support Python3 and PyPy and write detailed documents.</p> <p>Github: <a href="https://github.com/go-python/gopy" target="_blank">https://github.com/go-python/gopy</a></p>

pythonc/c++machine learning+6
Student: Dong-hee Na
Code
Proposal

Interprocedural Register Allocation in LLVM

beginner
LLVM Compiler Infrastructure•2016Varies90h (Small)

<p>The objective of this project is to implement a simple interprocedural register allocation that attempts to minimize register spill code by propagating register usage information through the program call graph. By examining the register usage information at each call site, the intraprocedural register allocator can avoid assigning registers already used in the called routines and minimizing spill code. Stretch goal for this project would be a link time register allocator. In this register allocation is deferred till linking of the code to optimize the allocation.</p>

cllvmc+++3
Student: Vivek Pandya
Code
Proposal

hyperSpec-HPC: Fast Sparse Spectral Kernels in R and Rust

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

The project will develop a high-performance Rust backend for graph-based spatial smoothing of hyperspectral images, delivered through an R package, hyperspec.rust. The package will bridge R’s dgCMatrix format to Rust’s faer sparse matrix structure, establishing a reusable FFI pattern for R–Rust interoperability. On the Rust side, pixel neighborhood graphs will be constructed using petgraph, with configurable connectivity to minimize data transfer. Spatial smoothing will be implemented by solving the sparse linear system (I+αL)x=b using iterative solvers (CG/BiCGSTAB) from faer. The project will include tests and benchmarking against pure-R implementations on large datasets along with documentation and a vignette to demonstrate smoothing. Additional goals include CRAN release of hyperSpec.rust, publishing the FFI bridge pattern as a Rust crate, and a JOSS paper.

cc++r+4
Student: shinigami-777
Code

E2E testing for the p5.js web editor

intermediate
Processing Foundation•2026$3k–$6.6k175h (Medium)

The p5.js Web Editor has no end-to-end tests. As the team works through a TypeScript migration and backend refactor, regressions in core user flows can go undetected and only surface through manual review. This project builds a complete E2E testing suite using Playwright, integrated into GitHub Actions so every PR into the develop branch is automatically validated against real user behaviour. The three deliverables are a working CI pipeline that runs the E2E suite on every PR, a set of prioritised user flows covering unauthenticated, authenticated, and state-transition scenarios, and contributor documentation so the suite can be extended after GSoC without the original author present.

pythonjavascriptandroid+6
Student: Krishnageeth
Code
Proposal

Support for Logarithmic Number Systems in Large Language Models

intermediate
Alaska•2026Varies175h (Medium)

LLMs rely on floating-point arithmetic for inference, but the Logarithmic Number System (LNS) offers a compelling alternative: multiplication becomes integer addition in the log domain, and 16-bit LNS (xlns16) uses only 2 bytes per element, half the memory bandwidth of float32. This project integrates the open-source xlnscpp C++ LNS library into ggml (the compute backend of llama.cpp) as a proper ggml_backend, enabling LLM inference to run entirely in xlns16 arithmetic as a proof of concept. The implementation introduces GGML_TYPE_LNS16 as a native ggml datatype and implements the 13 operations required for a complete transformer inference pass (matrix multiply, softmax, RMS norm, RoPE, SiLU, residual add, along with some others), all using xlns16 kernels. Activations stay in xlns16 format throughout inference; weights are converted dynamically from their stored quantised formats (Q4_K_M, etc.) per kernel invocation using O(1) lookup tables. The backend is validated at two levels: a unit test confirms sub-0.6% relative error on matrix multiply, and an end-to-end run on SmolLM2-135M-Instruct confirms the full transformer executes without crashing. Deliverables: (1) GGML_TYPE_LNS16 datatype registered in ggml; (2) a complete ggml_backend for xlns16 arithmetic covering all ops needed for LLM inference; (3) integration with llama.cpp; (4) a validation test suite; (5) an accuracy analysis comparing LNS and FP output across model layers

pythonmysqljava+2
Student: Abraham Paul
Code
Proposal

Enhancing the Functionality of spdx-license-diff

intermediate
The Linux Foundation•2025Varies175h (Medium)

The spdx-license-diff browser extension compares selected text on a webpage against the SPDX License List, showing the best matching license and a similarity percentage. The tool is currently broken in modern browsers due to Chrome’s Manifest V3 migration and Firefox compatibility issues. This project will restore compatibility, enhance its matching accuracy based on SPDX guidelines, improve the user interface and ensure accessibility compliance.

cpythonmysql+7
Student: Sujal Bhor
Code
Proposal

A Seamless Interface Between LLMs and Pharo

advanced
Pharo Consortium•2025Varies350h (Large)

This project aims to build ChatPharo, an intelligent, AI-powered assistant that integrates Large Language Models (LLMs) directly into the Pharo development environment. Despite Pharo’s strengths as a live programming platform, it currently lacks a native and user-friendly interface for interacting with LLMs to assist with code explanation, generation, documentation, and debugging. To address this, the project proposes a seamless, modular, and extensible system that connects Pharo with both online (OpenAI, DeepSeek) and offline (TinyLLaMA, Mistral-7B via Ollama) models. A multi-tab chat interface will allow users to manage multiple contextual conversations, while intelligent AI commands (e.g., /explain, /generate tests, /refactor) will directly support day-to-day coding workflows. Memory optimization techniques—including smart caching, chat pruning, and lazy model loading—will ensure smooth performance even in long sessions. A key innovation includes experimenting with pseudo-parallelism in Pharo’s single-threaded architecture by spawning secondary images to offload heavy LLM processing. This enables parallel task handling without compromising the responsiveness of the main Pharo image. By midterm, users will have access to a working chat UI, multi-LLM switching, and foundational coding actions. By the final evaluation, ChatPharo will evolve into a context-aware assistant capable of inline suggestions, AI-driven debugging, and scalable architecture for future extensions. Through full documentation, tutorials, and community engagement, this project will not only enhance developer productivity but also showcase Pharo as a capable, modern AI-enhanced development platform.

smalltalkroassalpolymath+7
Student: SrajalDwivedi17
Code
Proposal

Extend behavioural testing of std::arch intrinsics

beginner
The Rust Foundation•2025Varies90h (Small)

Rust's std::arch module houses vendor-specific intrinsics (low-level functions that typically correspond to single machine instructions) which are intended to be used by other libraries. Currently, there is good coverage of type-based tests and instruction-based tests (checking if the assembly instruction generated is correct) in std::arch, however behavioural tests (checking if the Rust implementation of the intrinsic has the same behaviour as the C implementation) cover only the aarch32 and aarch64 targets. This project intends to restructure the way behavioral testing is performed, so that it is simpler to extend coverage to more targets in future. Additionally this project also intends to extend behavioral testing to x86, Wasm32 and LoongArch targets.

pythonrust
Student: Madhav Madhusoodanan
Code
Proposal

Embedded MeshSync and kubectl (krew) plugin for MeshSync

intermediate
Meshery•2025Varies175h (Medium)

This proposal describes: - enhancement of meshsync to run as a library; - implementation of krew plugin for kubectl based on the meshsync library; - addition of integration tests to meshsync; - integration of meshsync library into meshery server.

javascriptgolangkubernetes+2
Student: Nikita B
Code
Proposal

TinyParrot: A minimal BlackParrot RISC-V Multicore variant

advanced
Free and Open Source Silicon Foundation•2024Varies350h (Large)

TinyParrot is a BlackParrot RISC-V multi-core variant that aims to be small enough to fit onto educational FPGA development boards like the Pynq Z2. In order to get there, the TinyParrot variant needs to optimize and constrain itself in order to meet the physical device constraints (such as LUTs, BRAMs, and flip-flops) provided by development boards like the Pynq Z2 FPGA development board. This project will implement size optimizations that ultimately decrease the amount of resources required by TinyParrot, enabling TinyParrot to fit on the Pynq Z2. At a high level, this will be accomplished by first parameterizing the FMUL/FDIV instructions as part of an MFD parameterization effort. Then, hardware primitives will be re-mapping using the BaseJump STL library in order to standardize and optimize the existing RTL. The ultimate goal of these optimization efforts is to implement TinyParrot on the Pynq Z2.

pythonjavascriptfpga+11
Student: Colin Knizek
Code

Scarpe on WASM

intermediate
Ruby•2023Varies175h (Medium)

The project primary objective would be bypassing the current usage of the webview library in Scarpe, feeding directly the HTML and Javascript code to the browser running Ruby and Scarpe directly through WebAssembly. Having done that, the project would focus on bulding an educational playground for writing GUIs through Ruby directly in browser.

rubycjava+3
Student: Giovanni Borgh
Code
Proposal

Expanding Reinforcement Learning in mlpack: DDPG and TD3 Agents Integration

intermediate
mlpack•2023Varies175h (Medium)

This project's primary objective was to enrich the mlpack reinforcement learning framework by incorporating new agents, specifically DDPG and TD3, complemented by comprehensive testing and documentation.

c++pythonmachine learning+4
Student: Tarek Elsayed
Code
Proposal

New BRL-CAD GUI

intermediate
BRL-CAD•2022Varies175h (Medium)

Arbalest, a modern geometry editor for BRL-CAD is an improvement over the existing editors MGED and Archer which is developed during the '80s and '90s. The project aims to add a feature for selecting and resizing the primitive through mouse support and also extend the object-oriented C++ Geometry API which includes the C++ "coreInterface" & "LIBGED". The expected outcome will be an improved BRL-CAD GUI.

pythonc/c++opengl+6
Student: Himanshu Sekhar Nayak
Code
Proposal

Publish fine-tuned MobileViT in TensorFlow Hub

intermediate
TensorFlow•2022Varies175h (Medium)

Publish fine-tuned MobileViT in TensorFlow Hub TensorFlow Hub is the main TensorFlow model repository with thousands of pre-trained models with documentation, sample code and readily available to use or fine-tune. The idea behind the project is to develop new State-of-the-Art models like MobileViT and publish the pre-trained models on TensorFlow Hub using the ImageNet1k dataset. MobileViT is light-weight and general-purpose vision transformer for mobile devices. MobileViT presents a different perspective for the global processing of information with transformers, i.e., transformers as convolutions. Our results show that MobileViT significantly outperforms CNN- and ViT-based networks across different tasks and datasets. On the ImageNet-1k dataset, MobileViT achieves top-1 accuracy of 78.4% with about 6 million parameters, which is 3.2% and 6.2% more accurate than MobileNetv3 (CNN-based) and DeIT (ViT-based) for a similar number of parameters. On the MS-COCO object detection task, MobileViT is 5.7% more accurate than MobileNetv3 for a similar number of parameters.

pythonc/c++machine learning+8
Student: Sayan Nath
Code
Proposal

Packaging & Testing Metacall for MacOSX, Windows, NixOS users

intermediate
MetaCall•2022Varies175h (Medium)

Tests for the Nix Metacall package will be written, the Nix package will have more precise dependencies , documentation and a CI/CD with Docker shall be setup to tests the packaging process in order to limit the introduction of bugs. Packaging for MacOSX using qemu-OSX in order to virtualize a MacOSX dev environnement, (mind this won't provide support for Apple M1), Metacall will be packaged for the Homebrew package manager. Tests shall be written for GitHub Actions with Docker for different programming language loaders (Python, Rust, C, NodeJS, etc.) And then in a similar manner with Windows, packaging Metacall for the Chocolatey package manager, if more time is left, a strecth goal is to make a package for apt (Debian/Ubuntu), Homebrew (MacOSX) and Chocolatey (Windows).

pythonjavascriptc/c+++6
Student: Lahfa Samy
Code
Proposal

ZOO-Project - Adding Cesium support within MapMint

intermediate
OSGeo (Open Source Geospatial Foundation)•2022Varies175h (Medium)

MapMint is a web-based Geographic Information System (GIS), which is designed to facilitate deployment of Spatial Data Infrastructure (SDI). In an SDI, geographic data, metadata, tools, and the users are connected in an interactive manner in a framework so as to use the spatial information in an efficient and flexible way. MapMint combines various different software in a complete and coherent web mapping platform, thus helping users in building their own maps and web-applications. These web-services are built on top of the ZOO-Project. Visualizing geospatial data in front end is a challenging task. For this, adding Cesium support within MapMint is a great task of building interactive web interface. My deliverables would be, Complete integration of Cesium Library within MapMint.

pythonjavascriptc/c+++4
Student: Bhupendra
Code

Boost:uBlas : Finalizing and improving the subtensor type

intermediate
Boost C++ Libraries•2021Varies175h (Medium)

<p>This project aims to extend the existing <code>tensor</code> extension of uBlas by providing support for <code>subtensor</code>, i.e. views of <code>tensor</code> type, along with the auxiliary types such as <code>span</code>/<code>range</code>. The projects' scope is to improve the existing <code>subtensor</code> implementation while simplifying the overall design and usage.</p>

c++c++11c++14+3
Student: Kannav Krishan Mehta
Code
Proposal

Beagle-Config

intermediate
BeagleBoard.org Foundation•2021Varies175h (Medium)

<p><strong>Beagle-Config</strong> is a tool-set, that aims to provide the functionality to make the most common low-level configuration changes in beagle devices easily and providing a terminal UI to do the same as well as a host-side application for ICS and many one-click enable features for seamless user experience.</p> <ul> <li>Brings down the steep curve and enables anybody to configure their beagle device</li> <li>Makes beagle devices more friendly </li> <li>More configurations can be added at any point in the time</li> <li>Safer than using scripts from a non-trusted source</li> </ul>

cpythonlinux+10
Student: Shreyas Swanand Atre
Code
Proposal

Channels Discovery

intermediate
rocket.chat•2021Varies175h (Medium)

<p>Currently, there are no social aspects to channels in Rocket.Chat servers. Many public channels aren't visible enough for the users to view and join. To join a specific channel, they should either know its link or the exact name to search it in the Directory. Also, every single day Rocket.Chat servers have many people coming into their channels, and they are all lost. They do not realize the actual purpose of a channel. So, there can be a better way of letting the new users know what is going on within the server or even within a channel. This project aims to solve the above issue by introducing a new feature called Discovery!</p>

javascriptwebrtcmeteor.js+18
Student: Adithya Vardhan
Code
Proposal

General Improvements in hydrus

advanced
Hydra Ecosystem•2021Varies350h (Large)

<p>hydrus is a set of Python based tools for easier and efficient creation of Hypermedia driven REST-APIs. hydrus utilises the power of Linked Data to create a powerful REST APIs to serve data. At the moment, hydrus does allow POST operation on hydra:Collection, but new functionalities should be added to effectively update, get or delete particular members from a Collection without actually sending the whole collection in the request payload. The flagship server hydrus can only serve static data and does not provide a way to define custom server-side logic. A new feature for dynamic endpoint could be added so that a developer would be able to define logic/functions for how the incoming data is processed on the server end. A lot of improvements are possible in CRUD operations of hydrus, including setting up constraints and handling errors on the server-side depending upon how the data is stored in a Collection. The project also aims to enhance the functionality of hydrus, optimize existing codes and keep it synced with upgrades and development in hydra-python-core, hydra-python-agent, and Hydra specifications.</p>

pythonjavascriptredis+7
Student: Hasan Faraz Khan
Code
Proposal

Write a tutorial about training a network in TF or PyTorch and then running it in OpenCV

intermediate
OpenCV•2020Varies175h (Medium)

<p>TensorFlow (TF) and PyTorch are some of the most popular deep learning frameworks. TF exports networks in its own format; PyTorch supports export of the trained models into ONNX format, which is also very popular. OpenCV is becoming quite popular tool for Deep Learning Inference. It would be very useful to describe clearly how to train a model in TF or PyTorch so that it can be then run in OpenCV.</p>

pythonmachine learningc+++9
Student: Anastasia Murzova
Code
Proposal
Showing 10369 - 10392 of 13453 Projects
431432433434435
Proposal
Proposal
Proposal