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

Decoupled implementation of social norms in CORMAS

intermediate
Pharo Consortium•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)

In agent-based modeling, the goal is to understand how individual agent behavior agent behavior is influenced by social norms (rules like obligations, prohibitions, and permissions). Using platforms like CORMAS built in Pharo, modelers have to hardcode norms directly into agent behavior, making the system rigid and hard to manage. Using method proxies - a reflective programming technique in Pharo that intercepts method calls at runtime - we propose to implement norms as a separate, modular layer on top of CORMAS with different handlers for obligations, prohibitions, and permissions. This work aims to deliver 1) a CORMAS plugin (cormas-norms) with its tests and documentation, 2) a better UI to manage norms live during simulation, and 3) a real-world use case demo of the plugin.

smalltalkroassalpolymath+7
Student: Tokimahery
Code
Proposal

Add WebSocket/GRPC Support to Flutter DevTools Network panel

intermediate
Dart•2026Varies175h (Medium)

While working with real-time systems, I observed that Flutter DevTools provides detailed visibility for HTTP requests but lacks support for persistent protocols like WebSockets. Once a connection is established, developers have little to no insight into message flow, latency, or connection lifecycle, making debugging significantly harder. This project aims to address that gap by extending the Dart SDK (dart:io, dart:developer, and the VM Service) to capture WebSocket frame-level and connection-level data. This data will then be integrated into the DevTools Network panel, following the existing HTTP profiling model to ensure consistency and minimal overhead. The implementation will include WebSocket instrumentation in dart:io, exposure of profiling data via the VM Service, and UI integration in DevTools to display messages, sizes, latency, and lifecycle events. If time permits, the same architecture will be extended to support gRPC traffic. By the end of the project, developers will be able to inspect WebSocket communication in DevTools with the same clarity and usability as HTTP, significantly improving debugging for real-time applications.

flutterdartprogramming-language
Student: Yash Hosalli
Code
Proposal

Enhancing CrocoLakeTools with IOOS Data Sync from ERDDAP

intermediate
IOOS•2026Varies175h (Medium)

CrocoLakeTools currently downloads ocean datasets from static sources, either a fixed URL or a fixed file list. This works for stable snapshots like GLODAP, but not for live ERDDAP servers like the IOOS Glider DAC, which hosts hundreds of delayed-mode glider deployment datasets that grow and change over time. This project builds an incremental sync layer targeting the IOOS Glider DAC. The implementation follows a three-layer architecture discussed with the mentor: a CLI script for user interaction, a dataset-specific downloader (DownloaderIOOSGliders) that handles ERDDAP query logic and URL construction using erddapy, and the base Downloader class that provides shared tools used by all downloaders in the package. The sync tool queries the server, compares server-side timestamps against local files, and downloads only what is new or updated. Files are stored exactly as served by ERDDAP with no schema conversion. Deliverables: (1) download_parallel() added to the base Downloader class, (2) DownloaderIOOS base class wrapping erddapy, (3) DownloaderIOOSGliders with incremental sync logic, (4) download_ioos_gliders.py CLI script, (5) unit and integration tests, (6) animal telemetry subclass as a stretch goal.

pythonocean sciencejava+3
Student: mahi-anol
Code
Proposal

Foundation Models for Exoplanet Characterization

intermediate
Machine Learning for Science (ML4SCI)•2026Varies175h (Medium)

This project aims to build a multimodal foundation model for exoplanet characterization by addressing the challenge of heterogeneous astronomical data and instrument-specific biases. It combines transformer-based models for images (protoplanetary disks) and sequential data (transit light curves), trained using knowledge distillation, masked autoencoding, and contrastive learning on both real and simulated datasets. The deliverables include pretrained multimodal models, a curated data pipeline, evaluation on real-world tasks, and a well-documented open-source codebase with reproducible workflows.

pythonmachine learningc+++2
Student: Tanmay Singhal
Code
Proposal

Development and integration of Lemke’s algorithm package

intermediate
Gambit: The package for computation in game theory•2026Varies175h (Medium)

Lemke's algorithm is a method for solving Linear Complementarity Problems (LCPs). Computing equilibria for two-player games can be reduced to solving such problems. The Gambit library already has a C++ implementation of Lemke's algorithm, but the goal of this project is to improve and integrate Bernhard von Stengel's Lemke package written in Python. The current package works primarily as a standalone CLI tool, with algorithm logic, file I/O, and console output all tightly coupled. This project will transform it into a dual-purpose package – usable both from the command line and as an importable Python library that Gambit can directly call.

pythonc++wxwidgets+1
Student: Natalie Mesablishvili
Code
Proposal

Add Support for Prepared Statements in LuaSQL

advanced
LabLua•2026Varies350h (Large)

LuaSQL currently does not support prepared statements, which are widely used in modern database applications for performance, security, and efficient query execution. Without this feature, applications must repeatedly send full SQL queries to the database, which prevents query reuse and makes parameter binding difficult. This project will design and implement a minimal and portable prepared statement API for LuaSQL. The API will introduce a new Statement object with methods such as prepare, bind, execute, and close. The design will follow LuaSQL’s existing conventions and ensure that the interface can be implemented consistently across different database drivers. The implementation will focus on the Oracle OCI8 driver as the first complete backend. It will support parameter binding, statement reuse, cursor integration, and proper resource management. Special attention will be given to handling cursor lifecycles and ensuring consistent behaviour across different DBMS APIs. At the end of the project, LuaSQL will include a working prepared statement API, a full OCI8 driver implementation, comprehensive tests, and updated documentation so that other drivers can implement the same interface in the future.

luacéuelasticsearch+5
Student: Damin Risho J V
Code
Proposal

OWASP Agent - Module C: The Librarian (OpenCRE)

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

The OWASP Agent - Module C: The Librarian (OpenCRE) project makes it possible to use continuously changing OWASP guidance inside OpenCRE, while keeping the OpenCRE graph trustworthy. OpenCRE already links stable standards well, but mapping “living” OWASP content at scale is still manual and can introduce mistakes. Module C becomes the decision boundary: it determines when a new section should automatically map to a CRE node, when an existing mapping should be updated, and when the case is uncertain and must go to human review. The Librarian follows an explicit-link-first workflow and uses a semantic fallback that retrieves the top 20 candidate CRE nodes with pgvector, reranks them with a sentence-transformers cross-encoder (ms-marco-MiniLM-L-6-v2), and applies safeguards such as negation handling, update detection, and contradiction checks. Only results scoring above 0.8 are written automatically; the rest are routed to a review queue. Deliverables include a production-ready Module C pipeline integrated with OpenCRE, a golden dataset and reproducible evaluation harness, CI regression gates to prevent quality drift, and operational documentation for calibration and maintenance. If time permits, I will also prototype hybrid retrieval (vector + BM25) for identifier-heavy cases and a lightweight human review dashboard (Module D). By the end of GSoC, OpenCRE will have a measurable, safe mapping layer that enables Project OIE to ingest OWASP knowledge without sacrificing trust.

pythonjavascriptjava+10
Student: PRATEEKSINGHWY
Code
Proposal

Native MPLS Support for FreeBSD

beginner
The FreeBSD Project•2026Varies90h (Small)

This proposal lays out plans to bring native MPLS support into the FreeBSD kernel. MPLS—Multi-Protocol Label Switching—is a fast packet-forwarding method you’ll find everywhere in big service provider and data center networks. Instead of making routers do complex IP lookups at every hop, MPLS uses simple label swapping. The magic happens with a tiny 32-bit shim header that holds a 20-bit label, a few bits for traffic class, a stack indicator, and an 8-bit TTL. This header sits snugly between Layer 2 and Layer 3 headers, letting routers in the core do blazing-fast forwarding while pushing tough routing decisions to the network edge. FreeBSD is famous for its solid IPv4 and IPv6 networking stack, but it’s been missing native Layer 2.5 switching. That gap has made it hard for FreeBSD to get traction in provider core networks. Meanwhile, OpenBSD and NetBSD have shipped MPLS support for ages, and Linux has had MPLS built in since kernel 4.3. FreeBSD’s overdue update doesn’t just catch up—it leapfrogs the other BSDs. This project stands out in two big ways: it adds ECMP multipath support using the modern nhgrp (Nexthop Group) subsystem, and it swaps out the old, hard-to-extend rtsock interface for a much more flexible Netlink-based control plane.

c/c++llvmassembly+5
Student: Subhash Murmu
Code
Proposal

Building a Structured Framework to Validate and Optimize Low-Level Assembly Routines in VLC

advanced
VideoLAN•2026Varies350h (Large)

VLC contains hand-written SSE2/SSSE3 assembly for performance-critical paths but has no automated correctness testing for them. This project integrates the checkasm framework into VLC's Meson build and CI pipeline, adds test coverage for all existing assembly routines, and implements new SIMD kernels for audio/video format conversions — with initial RISC-V vector groundwork.

copenglc+++10
Student: Mazen_1
Code
Proposal

Extensions to the Scenic Driving Domain

intermediate
UC OSPO•2026Varies175h (Medium)

Scenic is a probabilistic programming language for generating and verifying environments of autonomous cyber-physical systems. Its driving domain- the primary interface for autonomous vehicle (AV) testing- is a Python library that parses OpenDRIVE road-network files and exposes lanes, roads, intersections, traffic signals, and agents as first-class Scenic objects. While the driving domain is powerful, it has several concrete limitations that hinder real-world usage: assertion failures and geometry artifacts on certain OpenDRIVE maps; a coarse-grained centerline-following model that accumulates error on curved roads; incomplete extraction of semantic road metadata; and absent lane-signal linkage that makes it impossible to write autopilot behaviors that respect traffic laws. This proposal addresses all of these gaps across two major tracks and five subtasks, matching the project outline provided by the mentors: - Track 1 (~4 weeks): Robustness - fix known bugs, expand the test suite. - Track 2 (~5 weeks): Features - Frenet-frame geometry, lane-following distance, semantic tags, signal-lane linkage, and modular scenario components. Each subtask explained in the proposal will produce independently reviewable pull requests, letting mentors integrate work incrementally. The result is a driving domain that is meaningfully more robust, more expressive, and better validated than today.

pythonc/c++visualization+5
Student: Ashwin Prabou
Code
Proposal

Uyuni: Migrate API Documentation to OpenAPI/Swagger

intermediate
openSUSE Project•2026Varies175h (Medium)

This project aims to modernize Uyuni API documentation system by replacing the existing Javadoc-based macro DSL with a standardized OpenAPI/Swagger approach. The current system lacks interactivity, standard tooling support, and automated validation, leading to outdated and hard-to-maintain documentation. To solve this, I will generate an OpenAPI specification from annotated Java interfaces using a custom Swagger reader, making it the single source of truth. This specification will power interactive Swagger UI within Uyuni, ensure contract validation through automated testing, and enable generation of existing documentation formats such as AsciiDoc, DocBook, and HTML.The key deliverables include migrating 60+ API handlers to the new structure, implementing validation and contract testing, integrating Swagger UI into the web interface, and developing parsers to maintain compatibility with existing documentation pipelines.

pythonlinuxjavascript+11
Student: master-hj
Code

Improved UI for Subscription Management

intermediate
GNU Mailman•2026Varies175h (Medium)

The current Postorius subscriber management page has limited member visibility, no filtering options, and requires full page navigation to edit preferences. This proposal adds a Display Name column with sortable headers, filter dropdowns for delivery status/mode/moderation action with bookmarkable URL params, an expandable inline row for quick preference editing without page navigation, and private list visibility for subscribers with lock icon indicators.

pythondjangoemail+4
Student: Amitxtech
Code
Proposal

Direct Integration of PathVisio with WikiPathways GitHub

advanced
National Resource for Network Biology (NRNB)•2026Varies350h (Large)

This project aims to develop a Direct GitHub Integration Plugin for PathVisio to transform the pathway curation workflow from outdated systems to the WikiPathways GitHub repository. This proposal delivers a Java-based plugin which uses GitHub REST APIs to carry forward Git Operations. The PathVisio-GitHub Integration plugin will provide a clean and user friendly UI for biologists unfamiliar with Git Operations. The main goal of this proposal is to build an automation of Git Operations directly from PathVisio to WikiPathways GitHub repository for WikiPathways contributors. The plugin features authorization of users via GitHub using OAuth Device Authorization Grant and provides automatic forking of repositories and branching in the background using GitHub REST APIs. An encoding of GPML pathway files into Base64 format takes place before the plugin stages commits and opens Pull Requests directly from the PathVisio dashboard without freezing the main application thread. This is ensured by Java SwingWorker running in the background. Furthermore, the project integrates GitHub Actions to automatically validate file formats and metadata completeness upon final submission. Ultimately, this plugin helps to simplify complex Git operations of contributing to biological pathways, enabling the global biological research community to effortlessly work on PathVisio.

pythonjavascriptjava+11
Student: Snehashree Prusty
Code

USB Device Redirection for qemu-rdp

intermediate
QEMU•2026Varies175h (Medium)

Implement MS-RDPEUSB protocol (client & server) in IronRDP with libusb backend and qemu-rdp integration. The goal of this project is to add USB device redirection support to IronRDP, the Rust implementation of the Remote Desktop Protocol. This enables client-attached USB devices (webcams, scanners, security keys, etc.) to be transparently accessed by applications running on the remote server. MS-RDPEUSB is a Dynamic Virtual Channel (DVC) extension that provides low-level USB packet redirection. Unlike high-level device redirection (like file system or audio), USB redirection transfers raw USB packets, allowing any USB device to work remotely without device-specific driver support on the client.

cassemblykvm+4
Student: uchouT
Code
Proposal

AI Reflection in the Sugar Journal

intermediate
Sugar Labs•2026Varies175h (Medium)

Sugar's Journal records everything a child creates, but reflection one of its three core design pillars amounts to an empty text box that most children never touch. There is no prompt, no conversation, no mechanism to surface what a child learned from what they made. This project adds that mechanism by embedding a conversational reflection panel directly in the Journal, powered by the existing Sugar-AI backend. When a child opens a Journal entry, A reflection buddy asks a single artifact grounded question rooted in constructionist pedagogy. The conversation is adaptive, capped, and never forced. A gentle non-blocking nudge on activity exit reminds children that Reflection Buddy is ready without interrupting their workflow. What a child says they want to try next is saved and surfaced at the start of their next session, closing the loop from Reflect back to Imagine. Offline deployments are covered by Reflection Sparks, a curated bank of static prompts. Deliverables: 1. 2 FastAPI endpoints integrated into Sugar-AI (/reflect/chat and /reflect/summary) 2. A GTK3 reflection panel embedded in the Journal view 3. Metadata persistence via D-Bus 4. A feed-forward banner 5. An offline fallback 6. Full test coverage, working across all 40+ Sugar activities without activity-specific configuration.

pythonjavascriptgtk++10
Student: vyagh
Code
Proposal

Teach the Clang Static Analyzer to understand lifetime annotations

intermediate
LLVM Compiler Infrastructure•2026Varies175h (Medium)

The Clang Static Analyzer (CSA) can find a wide range of temporal memory errors such as use-after-free and dangling references. Some of its checkers, like cplusplus.InnerPointer, rely on hardcoded knowledge about the behavior of specific APIs. The Clang community has introduced lifetime annotations: [[clang::lifetimebound]] and [[clang::lifetime_capture_by(X)]] that let developers express lifetime relationships directly on their declarations and -Wlifetime-safety makes use of them. However, in partially annotated code, a single missing annotation is enough to prevent -Wlifetime-safety from finding the bug. The CSA can help in these situations by inlining the unannotated function. In my proposed project, I intend to implement a new standalone checker that reads lifetime annotations and tracks the resulting dependencies along different execution paths, using them as a fallback when the analyzer cannot inline a function body. The expected result is that the CSA detects lifetime bugs in both annotated and partially annotated code that it currently cannot catch, complementing the coverage provided by -Wlifetime-safety.

cllvmc+++3
Student: Benedek Kaibas
Code

StablePay: Enabling a Multi-Stablecoin Payment Experience

intermediate
AOSSIE•2026Varies175h (Medium)

Currently, the StablePay ecosystem only processes payments for Djed Osiris. As the Djed protocol expands to include new variants like Djed Shu, Tefnut (ETH-backed), and Isis (ERC-20-backed), the payment infrastructure must evolve. The goal of this project is to refactor the StablePay widget, merchant dashboard, and demo sites to seamlessly support any Djed variant without hardcoded assumptions. Additionally, this project will introduce support for the Gluon protocol, which entails deriving the essential mathematical formulas required for pre-calculating neutrons and protons. To achieve this, I will develop protocol adapters that interact with abstracted Djed interfaces, allowing different stablecoins to be plugged in via configuration. I will upgrade the merchant dashboard to enable multi-stablecoin management, allowing merchants to set preferred price feeds and monitor per-stablecoin revenue. Additionally, I will build deployment tooling to auto-generate config bundles from on-chain metadata and improve the end-user UX to handle coin selection, oracle status, and fallback logic gracefully. Ultimately, this project will transform StablePay into a highly scalable, agnostic payment gateway. Deliverables will be secured with comprehensive integration testing (using Foundry/Hardhat) and frontend end-to-end testing, alongside detailed documentation for merchants to easily onboard new networks and protocol versions.

pythonjavascriptswift+8
Student: Amrit Kumar Yadav
Code
Proposal

Integrating the Faust Programming Language into Bespoke Synth

intermediate
GRAME•2026Varies175h (Medium)

The goal of this project is to provide an interface in Bespoke Synth for editing and running Faust programs in real time. This will provide Faust developers with access to a modular synthesizer that can be used as an IDE, and it will provide Bespoke Synth users with an accessible way to extend and modify the DSP of Bespoke Synth without having to recompile. This project will be implemented using C++, and will use the Faust embedded compiler.

cpythonjavascript+3
Student: Blake North
Code
Proposal

API Dash as an MCP Server: Agentic Testing and GenUI Visualizations

intermediate
API Dash•2026Varies175h (Medium)

This project transforms API Dash into a next-generation, AI-native API client. I am merging three core objectives: 1. Agentic API Testing, 2. MCP Support 3. Generative UI Visualizations into a unified Dual-Transport Model Context Protocol (MCP) Architecture: 1. Agentic Sandbox & Generative UI (GenUI): Eliminating brittle WebViews, the internal UI will utilize Google's genui SDK and the Open Responses specification. This powers two features: an autonomous, self-healing Agentic Testing Dashboard, and a "Generative UI Previewer" that visualizes rich AI responses for end-users building Flutter/Web apps. 2. Headless MCP Engine: This exposes API Dash as a standard stdio MCP Server for external Agent interfaces (like VS Code, Cursor, or Claude Desktop).

flutterapiai+5
Student: Abdelrahman ElBorgy
Code

Matplotlib Overlay Layer API for Smooth Interactive Tools

beginner
NumFOCUS•2026Varies90h (Small)

I propose to implement the Overlay Layer API for Matplotlib’s interactive backends. Currently, tools like the Cursor widget force a full figure redraw on every mouse move, making even a simple crosshair feel laggy. This project introduces a canvas-owned Overlay Manager that stores lightweight, layered overlay primitives (lines, rectangles, etc.) with in-place update handles. Overlays will be drawn independently of the main figure using the fastest available path: native GUI painting (starting with QtAgg), a blit-based fallback when possible, or a lightweight full-redraw fallback otherwise. As the minimum deliverable, I will build a fast, smooth built-in Crosshair tool (integrated with ToolManager) that works correctly with shared Axes and becomes a standard interactive feature alongside Pan/Zoom.

pythonjavascriptr+3
Student: Vikash Kumar_23
Code
Proposal

Automating Print-Ready PDF Generation for OWASP Cornucopia using Scribus

intermediate
OWASP Foundation•2026Varies175h (Medium)

This proposal focuses on automating the generation of print-ready PDFs for OWASP Cornucopia by replacing the current InDesign-dependent workflow with a fully open-source, Scribus-based pipeline. It introduces a Python converter that reuses the existing YAML parsing logic to populate Scribus .sla templates, followed by automated PDF/X-1a:2001 export using Scribus in headless mode. The solution integrates seamlessly into the existing CI/CD pipeline, enabling every release to automatically produce print-ready outputs alongside current artifacts. By removing manual steps and proprietary dependencies, this approach makes the process more reliable, reproducible, and accessible, while also laying the foundation for future enhancements like customization and vendor-specific outputs.

pythonjavascriptjava+10
Student: Mradul Tiwari
Code

Finishing implementation of incomplete engines

intermediate
ScummVM•2026Varies175h (Medium)

The goal of this project is to push four nearly-finished ScummVM engines over the finish line, ensuring they are ready for official releases. Currently, these engines face issues ranging from incomplete low-level graphics and legacy code structures to unresolved gameplay bugs. How I plan to solve it: The project tackles the engines systematically. For the chamber engine, I will finalize the EGA planar graphics support and resolve memory-management issues like buffer overreads. For the avalanche engine, I will refactor the donated source code into modern C++ OOP standards, implement missing UI features, and fix gameplay logic bugs. Finally, for the DM and lilliput engines, I will conduct complete, meticulous end-to-end playthroughs to identify and fix any remaining logic, memory, or portability bugs. Deliverables: Chamber: Fully functional EGA 16-color graphics support without segmentation faults. Avalanche: A modernized, OOP-refactored codebase with a working "Shoot 'Em Up" minigame, repaired Robin Hood event trigger, missing Outro screens, and synced UI. DM & Lilliput: Stable, fully playable versions of Dungeon Master, The Adventures of Robin Hood, and Rome: Pathway to Power, fully prepared for stable public release.

openglc++assembly+5
Student: Ion Andrei Cristian
Code
Proposal

Persistent & Scheduled Firmware Upgrades

intermediate
OpenWISP•2026Varies175h (Medium)

OpenWISP's firmware upgrader fails permanently when devices are offline during mass upgrades, requiring manual re-triggering. There is no way to schedule upgrades for future maintenance windows. Solution: Two features for openwisp-firmware-upgrader. 1. Persistent upgrades (#379): Offline devices go to "pending" status instead of "failed" and retry automatically via Celery Beat with exponential backoff until the device comes online or an admin cancels. 2. Scheduled upgrades (#380): Optional datetime picker on the mass upgrade page. Celery Beat executes due upgrades with runtime re-validation and conflict detection. Both features compose: a scheduled upgrade that hits offline devices enters the persistence loop. Deliverables: - Model fields (persistent, retry_count, next_retry_at, scheduled_at) with additive migrations - Modified failure handler with pending status branch - Celery Beat tasks for periodic retries and scheduled execution - Admin UI: persistent checkbox, datetime picker, pending/scheduled status display - REST API with full admin parity - Notifications via generic_notification - Selenium browser tests, documentation, usage videos

pythonjavascriptdjango+5
Student: Eeshu
Code
Proposal

Adversarial Validation Module for ACF SDK

intermediate
C2SI•2026Varies175h (Medium)

Build the Policy Audit Point (PAP) for ACF-SDK that fires real attack payloads through the enforcement chain, records what gets caught and what slips through, and produces a coverage matrix. Includes 50+ attack patterns mapped to OWASP LLM Top 10, pytest integration, OpenTelemetry trace emission, and regression testing for policy changes. Structured as a research pre-registration targeting ACM AISec or IEEE S&P DLSP Workshop

pythonjavago+2
Student: Vibhor Gautam
Code
Proposal
Showing 673 - 696 of 11996 Projects
2728293031
Proposal
Proposal
Proposal
Proposal
Proposal