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

Performance Regression Publisher

advanced
D Language Foundation•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 →
350h (Large)

This project aims to build an automated performance regression detection system for the D compiler (DMD). It introduces a PR-based benchmarking bot that compares changes against the master branch and reports meaningful differences in compile time, memory usage, and binary size. Alongside this, a modular benchmark suite will simulate real-world and synthetic workloads to ensure accurate measurements. A lightweight dashboard will track performance trends over time, helping identify regressions and evaluate optimizations. The system is designed to be practical, maintainable, and tightly integrated with the existing D ecosystem.

linuxmaked+2
Student: Abul Hossain Khan
Code
Proposal

DocC Language Features in SourceKit-LSP

intermediate
Swift•2026Varies175h (Medium)

This project aims to extend SourceKit LSP to add DocC Language features like go-to-definition and diagnostic support for missing or broken symbol links. It also enhances the documentation preview by making it interactive with clickable symbol links and web URLs, along with syntax highlighting for .tutorial and .md files.

llvmc++cmake+5
Student: Padmashree S S
Code
Proposal

Gitcord: Local-First Discord-GitHub Integration Bot

beginner
AOSSIE•2026Varies90h (Small)

I work on Gitcord, a tool that connects a GitHub organization with a Discord server to help track and manage open-source contributions. The system will collect GitHub events such as issues, pull requests, reviews, and merges, store them locally, and calculate contributor scores based on configurable rules. The automation will follow a simple pipeline (Read → Plan → Report → Apply) so that every action can be reviewed before it is applied. To keep the system safe, it will run in dry-run mode by default and generate audit reports for maintainers. The project will also include a Discord bot that allows contributors to interact with the system directly from Discord. Contributors will link their GitHub and Discord accounts using a verification step instead of OAuth. Through bot commands, users will be able to check contribution summaries, view pull request information, request issues, and receive notifications about reviews, assignments, and merged pull requests. Gitcord will follow a local-first approach, storing data in a SQLite database rather than relying on external services. It will maintain records such as contribution history, identity mappings, audit logs, and notification history. The project will also include documentation, YAML-based configuration, Docker support, and automated tests so that organizations can deploy and maintain the system more easily.

pythonjavascriptswift+8
Student: Shubham5080
Code
Proposal

Enhance NOS skill assessment package’s user and developer experience

intermediate
IOOS•2026Varies175h (Medium)

The NOS OFS Skill Assessment package is a Python-based framework used to evaluate operational forecast systems (OFS) through observation retrieval, model processing, skill computation, and visualization. As the system continues to evolve, gaps in automated testing, continuous integration, and user-facing validation create challenges in maintaining reliability and usability. This project focuses on improving developer and user experience without modifying the scientific computation pipeline. The primary objectives are to introduce a GitHub Actions-based CI workflow, expand deterministic unit test coverage across core modules, and enhance the existing tkinter-based GUI with structured parameter grouping, validation logic, and contextual tooltips derived from existing argument definitions. In addition, the project will improve contributor onboarding by restructuring documentation using MkDocs. A lightweight, read-only dashboard will also be explored to organize and present outputs from completed skill assessment runs, providing a concise operational overview.

pythonocean sciencejava+3
Student: Tanmay Rajurkar
Code
Proposal

Foundational Loan Origination POC: External LOS Service and Survey for Apache Fineract

intermediate
Apache Software Foundation•2026Varies175h (Medium)

Apache Fineract lacks a Loan Origination System — the workflow managing a loan from customer application to disbursement. Every institution using Fineract builds this externally, creating a fragmented ecosystem with no shared interface or reusable integrations. This project delivers a Proof-of-Concept LOS as a fully decoupled standalone Spring Boot service that integrates with Fineract exclusively via REST APIs, with zero changes to Fineract's core codebase. It begins with a structured survey of origination models across microfinance, traditional banking, and fintech platforms — producing a community blueprint before any implementation begins. Deliverables include: a loan origination model survey and gap analysis document, a standalone LOS service with state machine lifecycle management, multi-stage approval workflow, rule-based credit scoring engine with pluggable interface, a disbursement bridge to Fineract's POST /loans API, FIGMA user flows annotated to API contracts, and full documentation with Postman collection and architecture diagrams.

pythonjavascriptjava+7
Student: CR1TIC4L
Code

Data Structures and Benchmarking for Pharo [Large - 350h]

advanced
Pharo Consortium•2026Varies350h (Large)

This project introduces a library of 7 data structures to the Pharo ecosystem, replacing O(N) bottlenecks with resilient, mathematically proven structures (including B Trees, K-D Trees, and Persistent Arrays). Following a full design approach, the implementations will be stress-tested using Competitive Programming datasets to guarantee architectural integrity under heavy load. Finally, the project utilizes VM-level tools (TimeProfiler and MemoryProfiler) to empirically benchmark performance, delivering production-ready infrastructure alongside interactive visual inspectors.

smalltalkroassalpolymath+7
Student: Hossam Saber Sayed
Code
Proposal

renAIssance VLM OCR for 17th-Century Spanish with Targeted LLM Correction

beginner
HumanAI•2026Varies90h (Small)

Project Summary: end-to-end OCR for 17th-Century Spanish Text using VLMs and assisted correction by an LLM The project addresses the significant challenge of performing accurate Optical Character Recognition (OCR) on 17th-century Spanish printed and handwritten documents. These historical materials are difficult for standard OCR tools due to archaic vocabulary, orthographic variations, and visual degradation such as ink bleed-through and faded text. Proposed Solution consists of an end-to-end pipeline centered on the Qwen2.5-VL-7B vision-language model (VLM). My approach moves beyond simple off-the-shelf recognition by implementing a multi-stage adaptation strategy: - Language Adaptation: Using LoRA-style masked language modeling (MLM) on the CORDE and CODEA corpora to teach the model 17th-century linguistic patterns and abbreviations. - Supervised Fine-Tuning: Training the adapted model on ground-truth transcriptions from the RenAlssance and RODRIGO datasets. - Targeted LLM Correction: Implementing a confidence-gated correction layer. Unlike generic "wholesale" correction which often introduces hallucinations, this layer uses a smaller, historically-tuned LLM to fix only low-confidence spans identified by the OCR model. Key Deliverables: By the end of the project, I aim to deliver: - A Reproducible OCR Pipeline: A complete system capable of handling both printed and handwritten 17th-century Spanish text. - Targeted Correction Module: A historically-adapted module that improves transcription accuracy by focusing only on uncertain text segments. - Evaluation and Normalization Harness: A documented toolkit for consistent Character Error Rate (CER) and Word Error Rate (WER) assessment. - Ablation Studies: Detailed reports isolating the performance gains from each stage of adaptation (language, visual, and correction) to guide future contributors.

pythonmachine learningc+++2
Student: Tushar Tyagi
Code

Wallet UI Improvements and P2P Networking

advanced
Bitcoin Core•2026Varies350h (Large)

Improve the graphical interface of the Bitcoin Core wallet and optimize peer discovery mechanisms in the P2P layer. (Summer of Bitcoin)

c++pythonc
Student: Summer of Bitcoin Intern
Code
Proposal

MCP Apps: Interactive Genomic Visualisations for AI Clients

intermediate
cBioPortal for Cancer Genomics•2026Varies175h (Medium)

This proposal outlines a plan to extend the cBioPortal MCP server with interactive genomic visualisation applications via MCP Apps that allow AI assistants like Claude and ChatGPT to render rich, interactive UI components directly within conversations. Rather than returning raw text or static data, the MCP server will serve four self-contained visualization apps (OncoPrint, Survival Analysis, Mutation Mapper, and Study Summary) as embeddable iframes, using bidirectional JSON-RPC communication via postMessage. This transforms the way researchers interact with cancer genomics data through AI, making cBioPortal the first genomics platform to offer interactive visual exploration inside AI chat interfaces.

javascriptjavaweb+9
Student: Luke Devlin
Code
Proposal

Supporting SBOM as Input

intermediate
Eclipse Foundation•2026Varies175h (Medium)

This project aims to extend the functionality of the Eclipse Dash License Tool by adding support for Software Bill of Materials (SBOM) files as input, specifically in CycloneDX and SPDX formats. Currently, the tool can accept and process dependencies from Maven files or NPM package files, but lacks the capability to accept SBOM files as input - a feature that is becoming more standardized in modern licensing software. This proposed solution involves the implementation of specific file parsers for CycloneDX and SPDX formats, extracting and normalizing component data, and then integrating this data into the tool's existing workflow. In addition, this project will support the generation of enriched SBOM outputs that include updated licensing information whilst preserving the initial contents of the file structure and metadata. The final deliverables for this project include SBOM input support via new command-line arguments, file parsing, integration with the rest of the tool's existing workflow, enriched SBOM output generation, extensive testing, and explicit documentation.

c/c++javageospatial+15
Student: DominicCristello
Code
Proposal

Local AI with Gemma by Google

beginner
Liquid Galaxy project•2026Varies90h (Small)

This project aims to make Liquid Galaxy easier to use by building a system that can automate content creation and control the screens using simple natural language commands. Currently, users need technical knowledge to create KML files, manage content, and operate the system, which makes it difficult for beginners. To solve this, I will build an AI server that runs on a Single Board Computer and acts as an assistant for Liquid Galaxy. Users will be able to give commands using chat or voice, and the system will handle tasks like generating KML visualizations, sending content to the screens, and controlling the setup. The system will be modular, so different features (like visualization, control, and communication) can be added or improved easily. It will also support both local processing and external services depending on what works best with the available hardware. This server will live on the same LAN as the liquid galaxy rig. The main deliverables include: A working AI agent server running on a Single Board Computer Chat and voice interfaces for user interaction, external services like telegram, discord, etc will also be supported. A media pipeline to generate and send KML, images, and other content to Liquid Galaxy A content builder for creating simple apps, and interactive outputs Real-time data visualization from open data sources (aircraft, satellites, disasters, etc.) Automated storytelling and guided tours based on user input (eg- historical events) News and event-based visualization on the globe A knowledge assistant using Liquid Galaxy documentation An interactive troubleshooting system for diagnosing and fixing issues User friendly instructions via .md files, to help new developers get started Agent personality customization Complete documentation, deployment scripts, and setup guides The final result will be a simple, flexible, and easy to use system that helps users and contributors interact with Liquid Galaxy.

javascriptrosgis+14
Student: Harsh_Mehta
Code
Proposal

AI Chatbot to Guide User Workflow

advanced
Jenkins•2026Varies350h (Large)

While Jenkins is the backbone of modern CI/CD, troubleshooting failed builds and complex configurations remains a time-consuming bottleneck. This project develops a Diagnostic AI Chatbot plugin to drastically reduce this friction, minimizing debugging time and maximizing developer productivity. Powered by an advanced Retrieval-Augmented Generation (RAG) architecture, the agent leverages LangGraph and hybrid search to intelligently filter noisy build logs, cross-referencing them with official documentation and community discussions in order to deliver precise root-cause analysis and actionable fixes. Architecturally, it utilizes a decoupled FastAPI backend, ensuring zero computational overhead on the Jenkins Controller. The system is highly flexible: it is designed with a privacy-first approach optimized for local open-source LLMs, while seamlessly supporting integration with third-party commercial APIs. This allows administrators to effortlessly toggle between absolute data privacy and frontier model performance based on their infrastructure needs.

javascriptjavago+2
Student: Daniele Caldarigi
Code
Proposal

Kornia-SLAM: Robust visual-inertial SLAM

intermediate
Kornia•2026Varies175h (Medium)

This project intends to extend the existing kornia-slam repository to create a visual + inertial measurements based simultaneous localization and mapping pipeline using utilities provided by Kornia-rs. The goal would be to create a VSLAM pipeline compatible with common modalities like monocular, stereo and RGB-D images, with a potential for future GNSS and Lidar integration. This will hopefully provide researchers with a localization and mapping algorithm that can run robustly on low compute hardware.

cudarustdeep learning+2
Student: Astik Srivastava
Code
Proposal

Geometry Verification and Validation GUI in Qt

intermediate
BRL-CAD•2026Varies175h (Medium)

This project focuses on improving the Geometry Verification and Validation (V&V) GUI in Qt for the Arbalest application in BRL-CAD. Currently, the prototype GUI provides basic validation output but has several usability limitations such as truncated full-path display, flat result presentation, and limited export options for validation results. These issues make it difficult for users to clearly interpret geometry validation outcomes. In this project, I plan to improve the usability and clarity of the existing V&V GUI by restructuring how validation results are displayed, fixing the full-path column visibility issue, and adding grouped result visualization for easier navigation. I will also implement a downloadable validation report feature that allows users to export results in structured formats such as TXT or JSON, making validation outputs easier to review and share. The expected deliverables include updating the existing V&V GUI implementation to work with the current Arbalest codebase, improving the results panel layout based on a proposed UI mockup, and adding a report generation module integrated into the GUI workflow. These improvements will make the validation interface more practical and user-friendly while keeping the scope aligned with the current prototype architecture.

pythonc/c++opengl+6
Student: Kanchan Borole
Code
Proposal

GSoC 2026: Programs & Events Dashboard — System-Wide Metrics and Data Downloads - Lakshita Jain

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

The Programs & Events Dashboard tracks editing activity across thousands of Wikimedia programs, but generating a system-wide picture of that impact remains manual and resource-intensive. WMF staff must stitch together per-campaign exports to answer basic questions like "How many total edits have all programs produced this year?" — there is no single place to see the Dashboard's global impact. This project builds that infrastructure in three layers. First, a SystemStat model and SystemStatUpdateWorker (Sidekiq) that computes and caches daily snapshots of global metrics - total edits, pageviews, articles improved, new and retained editors, and per-wiki breakdowns, so that all aggregations are pre-computed and never run on-demand against the full dataset. Second, an asynchronous system-wide CSV export pipeline that allows admins to request a download of all non-private program data, generated in the background and delivered via notification when ready - handling the full data scale without memory exhaustion. Third, a React-based "System Stats" admin dashboard that visualizes global trends, wiki distributions, and editor retention over time, backed by a JSON API endpoint for direct consumption by the WMF Community Data and Evaluation team. Deliverables: SystemStat model + daily background worker; admin-only async CSV export pipeline; "System Stats" React dashboard with trend charts and retention metrics; public JSON API with date-range filtering; full RSpec/Jest test coverage; and end-user documentation for WMF staff.

javascripthtmlphp+7
Student: Lakshita_Jain
Code

Hindi Relational Triple Extraction with Fine Tuned Indic Models and Human in the Loop Feedback

beginner
DBpedia•2026Varies90h (Small)

This project focuses on improving how relational triples are extracted from Hindi Wikipedia text for the DBpedia Hindi chapter. Currently, most structured data comes from infoboxes, while a large amount of useful information in free text remains unused. Existing approaches either rely on prompts, which are inconsistent, or rule-based systems that cannot handle the variety of Hindi sentence structures. There is also no proper system to use human feedback to improve results over time. To address this, I will fine-tune a small language model specifically for Hindi triple extraction, with a focus on correctly identifying predicates. The system will also include a layer that maps extracted relations to DBpedia ontology properties, ensuring compatibility with the knowledge graph. A simple interface will be built to allow users to review, correct, and improve extracted triples, creating better training data over time. The final outcome will be a working pipeline that extracts structured triples from Hindi text, a feedback system for continuous improvement, and a dataset of validated triples. This will help improve the coverage and quality of the Hindi DBpedia knowledge graph.

javascalardf+7
Student: Nitin@123
Code

Optimising the lookup time for ACQUIRE messages sent by kernel

intermediate
The Libreswan Project•2026Varies175h (Medium)

When an IPsec-encrypted packet matches a trap policy in the kernel, the kernel notifies IKE daemon (Pluto) via an ACQUIRE Netlink message. Then Pluto identifies that to which connection does this packet belong to by doing a lookup through all the loaded connections. Currently this is done in O(N) time (scanning through all the connections and the connection with highest priority is choosen). This Project aims to reduce this by using a hashtable to find the connection by using a unqiue id which is passed to the kernel while installing the policy. A complication arises with Opportunistic IPsec. Multiple clones of the same template connection would inherit the same reqid, causing collisions both in the hashtable and in the kernel's SA binding. This is addressed by a global counter that assigns a guaranteed unique reqid to each clone of the template connection. The deliverables would be the following , 1.Unique id placed in the policy before sending it to the kernel. 2.ACQUIRE lookup path using the hashtable 3.Guaranteed unique reqid for opportunistic connection clones via a global counter. 4.Display of the reqid in the status as well. 5. New Tests for functional testing and updating the current testsuites.c

cpythonshell script+10
Student: Vinayak Sandur
Code

XRefer Backend Expansion Updated Proposal Raj Mehta GSOC2026

advanced
FLARE•2026$6k–$13.2k350h (Large)

XRefer is a binary analysis tool built by Mandiant FLARE that uses cross-reference correlation, capa integration, and LLM-powered cluster analysis to help malware analysts navigate complex binaries faster. Today it requires IDA Pro, Binary Ninja, or a configured Ghidra environment to run, locking out students and researchers who lack commercial licenses or heavyweight setups. This project implements a fully functional Radare2 backend for XRefer via the r2pipe Python bindings, paired with a standalone CLI that auto-detects the best available disassembler and falls back to Radare2 when none are found. Radare2 is free, open-source, cross-platform, and pip-installable, making it the right foundation for democratizing XRefer access. The backend maps every method of the BackEnd abstract base class to verified r2pipe commands, handles known r2 edge cases including the aflj NaN-value bug and pdfj integer overflow, and includes targeted refinements to the base abstraction layer. Deliverables are: a complete Radare2 backend module passing integration tests against the Ghidra backend on a three-binary reference corpus; a standalone CLI installable with pip; a test suite with pre-recorded JSON fixtures enabling CI without a live r2 installation; and full documentation covering setup, architecture, and guidance for adding future backends.

pythonida-proGhidra+1
Student: Raj Mehta
Code
Proposal

A Faster Immutable List

advanced
Typelevel•2026Varies350h (Large)

The goal of this project is to create a more efficient immutable list in Scala. In order to do this, we intend to use block-based arrays, to improve cache locality and reduce pointer chasing. This approach will help to address performance issues with traditional linked lists.

linuxnode.jsjvm+2
Student: Jennifer Payne
Code
Proposal

Adding modular heap support to RTEMS

advanced
RTEMS Project•2026Varies350h (Large)

This project aims to update the current memory allocator used by RTEMS to be modular, allowing users to provide their own heap implementation or use one supplied by RTEMS. It will also include implementing the TLSF allocator as the default allocator instead of the current first-fit approach. This change will address the existing fragmentation and unpredictable runtime issues associated with the current allocator. Additionally, the project will explore the implementation of RT-Mimalloc, a modified version of Microsoft’s mimalloc optimized for real-time systems, representing the first open-source realization of this allocator. Finally, the project will add an allocator benchmark to evaluate the new memory allocators as well as any user-provided implementations.

cpythonembedded systems+5
Student: mez3n
Code
Proposal

Cluster of priority features focused around message feed, editing and APIs

intermediate
Zulip•2026Varies175h (Medium)

This project focuses on enhancing the Zulip platform by implementing key user-centric features across the message feed, editing system, APIs, and test coverage. The proposed work includes adding a user blocking feature, always-visible read receipts in direct messages, improved message edit history controls, and bulk conversation management in the inbox. It also introduces backend improvements such as APIs for deleting user messages during deactivation, configurable mention permissions, and detailed audit logging. With prior experience contributing to Zulip, I aim to deliver scalable, well-tested solutions that improve usability while actively collaborating with the community throughout the project lifecycle.

pythonjavascriptdjango+5
Student: Aman (whilstsomebody)
Code
Proposal

Scalable Tracy Integration for HPX: Unified Task Lifecycle and Causal Tracing

advanced
Ste||ar group•2026Varies350h (Large)

HPX already has partial Tracy support and stronger integrations with tools like VTune and APEX, but tracing is still fragmented and largely thread-centric. This makes it difficult to understand how tasks actually behave, especially across suspension, resumption, and asynchronous dependencies. This project focuses on strengthening and extending Tracy integration in HPX by building on the existing hpx::tracing abstraction and expanding task-level instrumentation across key runtime paths. The goal is to make task execution easier to follow by improving lifecycle visibility, especially around suspend/resume behavior, and by adding initial causal signals (for example, future fulfillment and other synchronization events) to help explain why tasks resume. The work will also extend tracing to execution paths that currently lack visibility, such as fork_join_executor and continuation execution, and introduce scalable controls like filtering and sampling to keep tracing usable in fine-grained workloads. As a stretch goal, I will explore optional trace-context propagation across parcel paths to enable cross-locality correlation in distributed runs. The expected deliverables include integrated tracing hooks across core runtime components, improved suspend/resume tracing, better coverage of executor and continuation paths, benchmark-validated low-overhead operation, and clear documentation for both maintainers and users.

c++cudaopencl+10
Student: Vansh Dobhal
Code

Architectural Refactoring of MWoffliner: Improving Maintainability, Modularity, and Performance

advanced
Kiwix•2026Varies350h (Large)

MWoffliner is a tool for scraping MediaWiki content into ZIM files for offline access, but its current architecture has significant maintainability and testability issues. The codebase suffers from singleton patterns preventing parallel execution, monolithic files, circular dependency cycles, code quality issues and tests that require full infrastructure that take a while to run. I'll deliver a comprehensive architectural refactoring that introduces dependency injection, breaks up monolithic files and singletons, implements storage abstraction for fast unit testing, restructures the directory organization, and optimizes the article processing pipeline all along with improved code quality. This refactoring will eliminate circular dependencies, enable tests to run without infrastructure, improve code modularity and architecture along with performance.

pythonandroidjava+11
Student: Vikram Aditya Verma
Code

JBoss Web Server – Add a Diagnostic + Configuration Validation Toolkit (jws-diag)

intermediate
JBoss Community•2026Varies175h (Medium)

JBoss Web Server (JWS) is Red Hat’s enterprise distribution of Apache Tomcat used in production environments where configuration correctness and operational visibility are critical. Many production incidents are caused by configuration errors such as TLS misconfiguration, incorrect connector exposure, proxy misconfiguration, permission issues, and environment drift rather than software defects. This project proposes jws-diag, a read-only Java CLI diagnostic tool designed to help operators and support engineers quickly understand installation state, effective runtime configuration, and potential configuration risks. The tool will provide: • Installation and runtime summary (JWS/Tomcat versions, JVM, OS, container signals) • Effective configuration parsing from server.xml with defaults resolution • Validation rules engine producing INFO/WARN/ERROR findings • Comprehensive test suite with configuration fixtures • Documentation and operational usage guidance • Optional redacted support bundle generation (stretch goal) Key deliverables include: • jws-diag summary command • jws-diag config command • jws-diag validate command with validation rules • Test suite and documentation • Integration into JWS ecosystem tooling The project will initially target: JWS 6 and JWS 7 Tomcat 10.1 and Tomcat 11 The expected outcome is a production-safe diagnostic tool that improves troubleshooting efficiency and configuration reliability for JBoss Web Server deployments.

androidjavaide+12
Student: Onkar Shelke
Code
Showing 625 - 648 of 11996 Projects
2526272829
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal