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
5976 Projects Found
Sort by

Proposal - Bastien Desert "Enhance fs to examine path components"

intermediate
OpenAFS•2026Varies

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)

Users who want to understand how the AFS cache manager resolves each element of a path (plain directory, mount point, or symlink) must manually run fs examine and fs lsmount on each component separately, or write wrapper scripts. This project implements a new fs pathinfo subcommand in C that walks a given path, iteratively resolves each prefix using the existing pioctl interface (VIOC_AFS_STAT_MT_PT, VIOC_FILE_CELL_INFO, lstat), and reports the type of each component in a human-readable format consistent with existing fs output. Deliverables include: the subcommand implementation integrated into src/venus/fs.c, support for both relative and absolute paths, a -verbose flag, a fs_pathinfo(1) man page in POD format, and a regression test suite covering all major path resolution scenarios.

cpythongit+4
Student: LaLoutre
Code
Proposal

Modernizing the Java PathFinder Build Workflow: Migrating from Ant to Gradle

intermediate
The Java Pathfinder Team•2018Varies175h (Medium)

<p>Developers often perform recurrent tasks during the development process such as testing, managing external libraries, generating API documentation, and managing release artifacts. Build tools help to automate those error-prone and daunt tasks with scripts that abstract those tasks. This proposal aims to modernize the build workflow from the Java PathFinder (JPF) project by migrating from Ant to Gradle. Gradle is a general purpose build system and uses Groovy, a JVM language, to create flexible and highly customizable build workflows. To achieve this goal, my strategy is to have a working Gradle build coexisting with the current Ant script. Ant targets will migrate to Gradle tasks in an incremental and iterative process. By the end of the program, is expected to have the Gradle support fully integrated into the main repository.</p>

androidjavadistributed systems+3
Student: Jeanderson Candido
Code

Improvements in the RTEMS Trace Framework

intermediate
RTEMS Project•2016Varies175h (Medium)

<p>Current Tracing Framework under RTEMS instruments the target ELF files to trace event-data based on a user-configuration. A Capture Engine buffers trace data in SMP-safe manner and records it on the target. RTEMS uses its own format for the traces. In this project we propose to modify the tracing framework to generate traces in the standardized Common Trace Format (CTF). CTF is a bit-packed trace-format used by a range of monitoring and visualisation tools (eg. Babeltrace). In the next phase, I will implement live-tracing functionality over a set of popular transport mechanisms(eg. USB, JTAG). Using LTTng tools we can visualise and analyse these live-traces on the host. I will focus on measuring and minimizing the overhead added due to tracing.</p>

cpythonembedded systems+5
Student: vivekk
Code
Proposal

Improving Ahmia - Hidden Service Search

intermediate
Tor•2017Varies175h (Medium)

<p>Ahmia is a search engine that indexes, searches, and catalogs content published on Tor Hidden Services. Furthermore, it is a medium to share meaningful insights, statistics, and news about the Tor network itself. There are several improvements and upgrades required in Ahmia.</p> <p>Initial tasks include automating blacklisting and tweaking 'Add' page. Then 'Statistics' page should be fixed and graphs need to be plotted to visualize analytical data. Then I will move on to replacing Polipo with Torsocks in ahmia-crawler and upgrading Elasticsearch support from 2.4 to 5.X. Once these major tasks are done, documentation and software dependancies need to be updated. If time permits, I plan to add advance search options like double quotes("") for exact matching of query and boolean operators like AND &amp; OR.</p>

cpythonjavascript+1
Student: Pushkar Pathak
Code
Proposal

Jupyter Notebook Integration

intermediate
GNU Octave•2021Varies175h (Medium)

<p>The <a href="https://jupyter.org/" target="_blank">Jupyter Notebook</a> is an open-source web application that allows you to create and share documents that contain live code, equations, visualizations, and narrative text. To interactively work with Octave code within Jupyter Notebooks, there already exists an <a href="https://github.com/Calysto/octave_kernel" target="_blank">Octave kernel for Jupyter</a>. This project aims to support the opposite direction: running (and filling) Jupyter Notebook within GNU Octave. This would enable Jupyter Notebook users to evaluate long-running Octave Notebooks on a computing server without a permanent browser connection, which is still <a href="https://github.com/jupyter/notebook/issues/1647" target="_blank">a pending issue</a>.</p>

c++hg
Student: Abdallah Elshamy
Code
Proposal

Marknote - Block Editor

advanced
KDE Community•2026Varies350h (Large)

This project aims to introduce a robust and high performance block editor and a proper markdown parser to Marknote. Right now, the editor is hard to maintain, full of many condition checks, and has bugs and limitations, especially when handling formatting and advanced features. My plan is to use md4qt to parse Markdown into a structured format and build a block editor that supports things like lists, tables, code blocks, and drag-and-drop. I will design the system so parsing, rendering, editing, and saving are cleanly separated, which will make the app faster, more stable, and easier to extend in the future. I will implement this step by step, making sure all features like undo/redo and export continue to work, and I will test everything properly to ensure a smooth user experience.

c/c++qtqml+6
Student: PrayagJain
Code
Proposal

Detecting Model Inconsistencies in 4diac Models with OCL

intermediate
Eclipse Foundation•2020Varies175h (Medium)

<p>Eclipse 4diac is an open source environment for programming distributed industrial automation solutions and control systems based on the IEC 61499 standard. One of the components of Eclipse 4diac is the 4diac IDE which is an integrated development environment for modeling distributed control applications compliant to the IEC 61499 standard. The current version of 4diac IDE does not support the validation of the models, which makes it difficult for users to get design-time feedback on inconsistencies regarding the models developed in 4diac. The Object Constraint Language (OCL) could be a solution to find issues in 4diac models since it provides capabilities for specifying generic constraints a model has to fulfill. The aim of this project is to develop OCL constraints and well-formedness rules to the metamodels of 4diac in order to improve the usability of the IDE.</p>

c/c++javageospatial+15
Student: Sándor Bácsi
Code

Benchmark Polytope Import Suite For Volesti

beginner
GeomScale•2026Varies90h (Small)

This project aims to develop a Benchmark Polytope Import Suite for the volesti library, enabling automated conversion of standard Linear Programming instances and metabolic network models into H-Polytopes compatible with volesti. A user-friendly CLI tool will allow researchers to perform conversions easily without directly interacting with the code. Additionally, a curated benchmark collection with regeneration scripts will support reproducible testing and demonstration of the pipeline. The project will follow best software engineering practices, including, unit, integration and end to end tests, as well as comprehensive documentation and tutorials. By providing a robust and easy to use import suite pipeline, this project will expand volesti's accessibility and usability for researchers in volume approximation and sampling of convex bodies.

pythonc++r+2
Student: JimmysPavlou
Code
Proposal

Enhancing ThingsBoard Integration with IoTDB 2.X Table Mode

advanced
Apache Software Foundation•2026Varies350h (Large)

This project implements a new storage backend for ThingsBoard using Apache IoTDB 2.X's table mode. It introduces new DAO implementations (IoTDBTableTimeseriesDao, IoTDBTableLatestDao, IoTDBTableBaseDao) built on ITableSession, using Tablet-based writes and standard SQL queries. The design adopts a single generic table with TAG columns for tenant, entity, and key filtering, supports direct SQL aggregation via date_bin(), and relies on native TTL for data retention. The approach has been validated through a working proof of concept (https://github.com/PDGGK/thingsboard-iotdb-table-poc), tested against IoTDB 2.0.5 with all proposed access patterns. Deliverables include the full DAO implementation, Docker-based integration tests, performance benchmarks, and migration documentation.

pythonjavascriptjava+7
Student: Zihan Dai
Code

ABI/Layout handling for the automatic differentiation feature

advanced
The Rust Foundation•2025Varies350h (Large)

The integration of automatic differentiation (autodiff) into the Rust compiler via Enzyme faces challenges due to ABI adjustments that alter function signatures. These transformations, while beneficial for performance, interfere with autodiff functionality, leading to incorrect differentiation. This project aims to prevent unwanted ABI adjustments for functions marked with #[rustc_autodiff], ensuring autodiff functions maintain their intended behavior without affecting other optimizations. The approach involves modifying Rust’s function ABI handling to recognize and preserve differentiation-related information. Key steps include identifying problematic transformations, encoding autodiff metadata in FnAbi, and preventing ABI changes that break autodiff. By addressing these challenges, the project will improve autodiff support in Rust, making it more reliable and consistent while preserving compiler efficiency.

pythonrust
Student: Sa4dUs
Code
Proposal

Processing Language Server : Processing

beginner
Processing Foundation•2019Varies90h (Small)

<p>Processing Language Server focuses on creating a Language Server Protocol (LSP) implementation for Processing Programming Language. PDE is currently built using Java and using custom components of the Swing Framework, which is ~ deprecated. The long term goal of Processing is to replace this with a JS based IDE to bring in more contributors and to make building UIs simple. While planning on building such IDE, LSP is of significant importance for any language that the IDE relays on. Since Processing is the targeted Programming language, it’s quite important to build a Language Server Protocol for the same. This shall act as a benchmark for all the crucial activities of the IDE such as auto-completion, go-to-definition, hover-insights and so on. LSP will also help in easy and seamless integration of the above functionalities in any editor such as Atom, VScode, etc.</p>

pythonjavascriptandroid+6
Student: Syam Sundar K
Code
Proposal

Robust Implementation and Verification of the RISC-V Svadu Extension for Ariane+OpenPiton

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

This project aims to bring Ariane+OpenPiton closer to RISC-V RVA23 compliance by adding support for the Svadu extension. By enabling hardware-managed Accessed and Dirty bit updates, Svadu eliminates unnecessary software-managed page faults and improves virtual-memory efficiency. I will implement the required changes across the PTW, TLBs, LSU-side update path, and a new hardware unit, Page Table Entry Updating Engine (PUE), while building a robust verification framework based on Spike, Verilator, and handwritten assembly tests. In addition to a complete Svadu implementation, the project will deliver evaluation results, reusable verification infrastructure, and upstream-ready contributions for future RISC-V MMU-related RVA23/RVB23 extensions.

pythonjavascriptfpga+11
Student: Seongwon Jo
Code

Improvements to the Conditional Modeling Syntax

intermediate
ASCEND•2016Varies175h (Medium)

<p>ASCEND provides support for Conditional modeling, where a model can contain both variant and invariant equations. Invariant equations must be respected by the model at all times while the variant equations only are included in the model if certain conditions are met. For example, a model for fluid flow will have different sets of equations depending on the phase of the flow (laminar, turbulent or sonic flow). Unfortunately, the current syntax for conditional modeling has been considered unintuitive by some of its users and there is demand for a better alternative.</p> <p>In this project, my goal is to precisely identify why the current syntax is considered unintuitive and use this information to design and implement a better alternative. The identification would be based on a review of code examples using the current conditional model syntax and the implementations would be made by modifying the existing Bison-based compiler.</p>

cpythonc/c++
Student: hugomg
Code
Proposal

Colibri OpenADR connector

intermediate
Computational Science and Engineering at TU Wien•2016Varies175h (Medium)

<p>This is a brief overview of what I intend to do. I want to implement the standardized smart grid connection ”OpenADR”. What are the advantages to implement this interface into the Colibri project? The grid operators have the possibility to inform the customer about e.g. the current energy price, with this standardized interface. The customer can control his electrical consumers regarding the given information. Colibri with the OpenADR connection helps to automate this process on the customer side. The Colibri control module can reduce or increase the total power consumption depending on to the information from the other smart grid agents. In the end this will result in a more stable grid, because the energy producer and consumer will stand in an interdependency. This also leads to an better usage of the energy resources which is a great benefit for the society. Therefore it is a good idea to add this functionality to the Colibri project.</p>

javascriptjavac+++2
Student: Georg Faustmann
Code
Proposal

Timeframe for Metrics

advanced
CNCF•2023Varies350h (Large)

Currently, the Metrics Controller in the Keptn Lifecycle Toolkit only allows querying a single value per metric. This project will enable users to define timeframes for metrics and get standardized aggregated results for the given timeframe. The addition of time frames for metrics would provide developers with a lot of flexibility when analyzing their application’s performance as they would be able to easily switch between different timeframes to get a better understanding of how their application is performing. This can be achieved by modifying the structure of the Metric CRD by adding certain fields and then modifying the APIs of our Metric providers to support these newly added fields. The metrics controller would be able to query metrics over a timeframe and then return raw values from the providers which can then be passed to the aggregation functions to calculate the desired aggregated value. These values would be updated in the Metric CRD.

gorustkubernetes+3
Student: Rakshit Gondwal
Code
Proposal

SMILES Data Models

intermediate
Apache Software Foundation•2022Varies175h (Medium)

The goal is to design and implement the solution to the Airavata Data Catalog to record the metadata extracted from the Literature, Experimental and Computational data in support of Small Molecule Iconic Isolation Lattices (SMILES) Data. More precisely, this includes the data synchronization with the end-users. Currently, Airavata is extending an open-source project called “open-inventory” with additional features. Airavata uses three individual and unrelated databases to save the Literature data, Experimental data, and Computational data. Having these in usage, the chemical compounds are represented with ambiguous keys and missing data. Therefore, the scientific representation of the compounds with a specific structure; scientific data model (SDM), and related ontology (SDMO) is much better to analyze the behavior of a compound. In particular, a common data model should be used to synchronize the data efficiently.

pythonjavascriptjava+7
Student: Bhavesh Asanabada
Code
Proposal

Improving Test Coverage for PEcAn Packages

intermediate
PEcAn Project•2023Varies175h (Medium)

The short term goal is to improve unit test coverage for PEcAn base packages. The overall PEcAn ecosystem of packages (e.g, models and analysis modules) are heavily dependent upon these packages, thus having a good test coverage for these would improve overall system reliability. The medium term goal is to increase the reliability of PEcAn’s integration tests, and thus my second round of package testing and refactoring will prioritize the packages that are most associated with overall workflow bottlenecks (e.g., PEcAn.data.atmosphere, which is focused on downloading and processing meteorological data). An added long term goal would be to document testing approaches to make adding tests more smooth and consistent across packages for future packages or functions that get on-boarded, thereby making them more maintainable and reliable.

cpostgresqljavascript+8
Student: Meet M Agrawal
Code
Proposal

Yogendra Jhala - Agora Blockchain

intermediate
AOSSIE•2023Varies175h (Medium)

Features that need to be implemented in an Election DAPP to make it more flexible, dynamic and user-friendly. The features include: Improving the backend side of DAPP by implementing more voting algorithms like Range Voting, Ranked Pairs and implementing Gas Optimization Techniques. Improving/adding new features to smart contracts using SOLID Principles during the design of the smart contract. Enhancing support for Open and Invite Election on the client side of DAPP by syncing up the client side completely with the existing/improved backend. Updating UI for Authentication Page, Live Tracking and Tabulation for results and Social media integration after vote cast to improve UI and Sharing feature. Configuring State Management System – Redux. Upgradable smart contract and Diamond smart contract for a future version of dapp.

pythonjavascriptswift+8
Student: Yogendra Jhala
Code
Proposal

HashiCorp Vault plugin for Notary

Intermediate
•Varies175h (Medium)

Description: Notary is a CNCF incubating project that aims to provide signing and verification capabilities to ensure delivery integrity and security. It supports creating and storing signatures for container images, SBOM, vulnerability scanning results, etc. to ensure the artifacts someone produced have not been tampered by others. Notary only has an Azure Key Vault plugin for storing keys in Azure Key Vault, which is used to sign and verify artifacts in the OCI registry. [HashiCorp Vault](https://github.com/hashicorp/vault) is a popular KMS and we see more and more users rely on it in the on-premise environment. Expected Outcome: Develop a Key Management System (KMS) plugin with [HashiCorp Vault](https://github.com/hashicorp/vault) for Notary CLI (Notation), which can be used to store the keys for Notation signing and verification.

TBA
Proposal

Sampling Methods for Convex Optimization

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

<p>Extend VolEsti (a c++ library with an R interface) by implementing randomized algorithms for convex optimization. First, there is a need to implement some more random walks so we can choose which to use with respect to our problem, e.g. ratio of dimensions / constraints. Such a choice is important, because the sampling is the bottleneck of the proposed algorithms, so it must be as efficient as possible. Second, use these sampling methods to solve convex optimization problems and the redundancy problem. I propose a variety of randomized algorithms, such as one that uses cutting planes and one that uses simulated annealing. In the end, I will provide support for linear programming, semidefinite programming and mixed integer linear programming. A good part of the project will be testing to provide empirical data, since some of these algorithms perform better in practice than predicted by theory.</p>

cc++r+4
Student: Panagiotis Repouskos
Code
Proposal

borgbackup: Borg Pack Files for BorgBackup 2.x Proposal

advanced
Python Software Foundation•2026Varies350h (Large)

BorgBackup 2.x stores each deduplicated chunk as a separate borgstore object, resulting in millions of tiny files and severe performance regressions on remote/cloud backends. This project implements client-side pack files that bundle multiple chunks into larger files (~50 MiB default) before transfer, reducing API calls by 100-1000x. Deliverables: pack file binary format with per-pack index, extended ChunkIndex with pack location tracking (borghash HashTableNT), PackWriter/PackReader I/O modules, pack-aware garbage collection in borg compact, pack validation in borg check, ChunkIndex rebuild from packs, and backend-specific benchmarking. All phases produce working, mergeable code targeting local backends first with remote validation following.

pythonmercurialjavascript+3
Student: ebuzerdrmz44
Code

Adding New Features Or General Improvements In Mifos-Mobile-CN Application & Fixing Its Bugs.

intermediate
The Mifos Initiative•2022Varies175h (Medium)

The main aim of my project is to add some new features & solve various major issues or Bugs in the mifos-mobile-cn app and at the same time also extend the features of its app in various ways which can help improve the user experience and ultimately the productivity of the app. I also intend to take up some ideas from the ideas page of Mifos and inculcate them in my project which can provide the best features for the user. Some Features Are -: 1. Major UI changes , 2. Adding Shimmer RecyclerView , 3. Adding fingerprint authentication system in this app, 4. Adding option for Support different languages in the setting fragment and so on. Some Bugs And Issues in This App : 1. Modifying Register Activity, 2. Fixing all Hardcoded string of the whole app, 3. Resolving All The Layout Designing Warnings Of The App and and so on.

mysqljavascriptandroid+5
Student: Prashant830
Code

Meticulous tool polishing and adding new gizmos

advanced
Graphite•2025Varies350h (Large)

Graphite currently offers only a limited set of shape tools with basic gizmo support, limiting the scope of creative and precise editing. This project aims to enhance the Polygon Tool by introducing a variety of predefined shape nodes—such as Trapezoid, Star, Donut, Pie, Crescent, and more—each equipped with custom, interactive gizmos. To manage these features, a centralized Gizmo Manager will be developed to handle both general transform cages and shape-specific gizmo points. These gizmos will integrate with the Select Tool using a state-driven interaction model to enable intuitive, fine-grained shape manipulation. Each shape will expose unique transformation controls (e.g., adjusting edge curvature, radii, angles, and segment lengths), allowing users to craft complex designs efficiently.

machine learningrustvulkan+2
Student: PratyushGovind
Code
Proposal

Visualization of model hyperparameter optimization curves

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

<p>The goal of this project is to provide users of the mlr package with a way to visualize what happens during the tuning process that identifies the best hyperparameters for a learner given the data. Looking at popular packages in the machine learning community such as sklearn or caret, the model evaluation visualization process either requires lots of boilerplate code or is sparsely implemented across packages. This project will rectify the situation for R users of the mlr package by implementing three new features: plotting of a single hyperparameter against a scoring function, plotting multiple hyperparameters and scoring functions, as well as support for ablation analysis. The design of the features will focus on ease of use for the end user and customization. Users can choose to leverage automatically generated plots or use the data in some other manner downstream.</p>

cc++r+4
Student: MasonGallo
Code
Showing 5161 - 5184 of 5976 Projects
214215216217218
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal