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

ISSR Humanlike AI Systems and Trust Attribution

intermediate
HumanAI•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)

As AI assistants adopt humanlike names, conversational tone, and confidence framing, users form impressions of AI competence from interface design alone — independently of actual system capability. This can produce overtrust, underuse, or miscalibrated reliance. Most existing research measures trust through self-report scales, which cannot capture when or how quickly users actually defer to or override an AI recommendation. This project builds a modular, open-source web-based experimentation platform that makes behavioral trust measures tractable for researchers. Built in Next.js, the system supports randomized condition assignment, configurable manipulation of humanlike interface cues (agent name, tone, confidence framing), and a recommendation-acceptance task that produces clear reliance-versus-override outcomes under controlled AI accuracy. Fine-grained event logs — decisions, timestamps, response latency — are exported as clean JSON and CSV datasets, and a reproducible Python notebook reports reliance rate, override rate, and latency by condition. The platform is designed as reusable research infrastructure: cue logic is configuration-driven, task logic is decoupled from condition management, and the event schema is fully documented so future researchers can extend the system with new cues, tasks, and study conditions. Deliverables include a functional experimental prototype, cue manipulation framework, behavioral logging backend, sample dataset, analysis notebook, and complete documentation in a public GitHub repository.

pythonmachine learningc+++2
Student: Runchu Wu
Code
Proposal

Function prelude detection plugin

intermediate
Rizin•2026Varies175h (Medium)

A common problem in binary analysis is function detection. One method is searching for function preludes. Preludes are a sequence of instructions commonly found at the beginning of a function. These preludes perform tasks like setting up the stack, or initializing registers to values as defined in the architecture’s ABI. It is very common to hard-code these prelude patterns and match instructions against them. These patterns get outdated, are tedious to update, and have to be written for each architecture. Also because these signatures are generic, they are highly prone to false positives especially on x86/x86_64 binaries. This project aims to augment static signature based approach with a dynamic, multi-stage statistical heuristic pipeline. Weighted Prefix Trie will be used for matching and then filtering through 2-signal validation approach (frequency distribution analysis + shannon entropy) for removing noise. Hence the plugin will automatically learn directly from functions identified by initial CFG (Control Flow Graph) analysis in the target binary. This approach also enables the discovery of orphaned or hidden functions that standard CFG analysis often misses in stripped or obfuscated binaries.

cpythonc+++2
Student: Darshan-Patel
Code
Proposal

Improve WHIP(WebRTC-HTTP Ingest Protocol) Support

intermediate
FFmpeg•2026Varies175h (Medium)

FFmpeg already supports WHIP, allowing users to publish WebRTC streams using HTTP signaling. This project aims to extend WHIP support by adding support for more codecs, enabling multiple media streams, providing full ICE support, and other related improvements.

cgitasm+3
Student: Aditya Banavi
Code
Proposal

Modernizing Haiku's Bluetooth Stack: HCI Completion and HID Profile Implementation

beginner
Haiku•2026$1.5k–$3.3k90h (Small)

Haiku's Bluetooth stack currently implements only a basic subset of general Bluetooth functionality. At first during testing with an Android phone, the local device was visible, but the pairing process fails entirely because Haiku does not understand modern Bluetooth events. The pairing process silently failed because the stack drops unsolicited Secure Simple Pairing (SSP) requests. The system was dropping modern discovery packets because the Inquiry subsystem lacked Extended Inquiry Result (EIR) support. Although recently the SSP and EIR issues have had recent patches from GSoC candidates, still there’re several issues in bluetooth pairing and connection that needs handling including: the pairing button doesn't make any action, not showing the pairing number when getting pairing requests from the phone, and lacking persistent remote device information. Hence, many other modern HCI events and commands still need handling. The primary motivation of this project is to modernize Haiku’s Core Bluetooth stack to match 2.X and later to improve the existing code's compatibility with newer devices. By resolving these foundational HCI drops, the stack can finally be used for more than just basic pairing attempts, paving the way for functional Bluetooth HID, audio, or file transfer profiles. This project modernizes the stack by Completing the remaining HCI commands and events, Adding persistent Link Key storage to preserve pairing devices after reboot, Implementing the Service Discovery Protocol (SDP), and Delivering a full Human Interface Device (HID) profile with a working input_server add-on.

c++posixffmpeg+6
Student: Mohammed R. Attia
Code

Add more timeseries database clients to OpenWISP Monitoring

intermediate
OpenWISP•2026Varies175h (Medium)

The project adds InfluxDB 2.0 and Elasticsearch as timeseries database backends to OpenWISP Monitoring by implementing the existing DatabaseClient. The core monitoring logic remains untouched since it already interacts through timeseries_db abstraction, making backend addition a clean isolated task. For InfluxDB 2.0, all chart queries in `queries.py` will be translated from InfluxQL to Flux. For Elasticsearch, queries will use `date_histogram` aggregations. Each backend gets dedicated GitHub Actions CI, deployment support via ansible-openwisp2 and docker-openwisp, and users can switch between all three backends through the `TIMESERIES_DATABASE` setting with full documentation coverage.

pythonjavascriptdjango+5
Student: pushpit kamboj
Code
Proposal

Better Linking Between Libcint and Gbasis

intermediate
QC-Devs•2026Varies175h (Medium)

GBasis currently requires manual libcint compilation, breaking on macOS and Windows. This project automates the build using scikit-build-core and CMake FetchContent, adds cross-platform wheel building via cibuildwheel on GitHub Actions, implements platform-aware library loading, and wraps additional integrals from issue #149.

pythongithubc+++2
Student: Aayush1807
Code
Proposal

OG-CLEWS: Scientific Programming & Model Integration

intermediate
United Nations Office of Information Communication Technology•2026Varies175h (Medium)

Currently, national climate and fiscal policy analyses operate in isolated domains. The CLEWS framework models physical constraints across energy, land, and water systems, whereas OG-Core projects macroeconomic and demographic trajectories. Because their output schemas, unit normalizations, and temporal resolutions are fundamentally incompatible, analysts must manually translate data between the two models to understand how physical policies impact long-term fiscal stability. This project establishes the first automated, bidirectional integration between OSeMOSYS and OG-Core within the MUIOGO platform. Building upon the asynchronous execution architecture and API contracts recently established in the repository, the project will construct a multi-step convergence pipeline. This system will orchestrate the execution of CLEWS, perform the necessary schema translations, run the OG-Core macroeconomic model, and iteratively feed the fiscal outputs back into the physical model until a mathematical fixed point is reached. The development is structured across four strictly ordered deliverables: 1. A stabilized, cross-platform MUIOGO runtime environment supported by comprehensive automated testing. 2. A native OG-Core execution module featuring a dedicated scenario manager and a visual results dashboard. 3. A coupled data pipeline designed to strictly normalize and translate critical bridge variables between the two distinct architectures. 4. A final convergence orchestrator capable of managing the iterative loop, complete with configurable stopping criteria and automated divergence detection.

pythonjavascriptcss
Student: Aditya Kushwaha
Code

Drop-in replacement for vscode-json-languageservice

intermediate
JSON Schema•2026$3k–$6.6k175h (Medium)

vscode-json-languageservice, the library powering JSON editing in VSCode currently supports only JSON Schema draft-07. The architectural coupling between its validator and editor features means draft support cannot be extended by simply swapping the validator. This project aims at building a drop-in replacement that matches the exact API surface of vscode-json-languageservice while replacing the validator with @hyperjump/json-schema, bringing full support for draft-04 through draft-2020-12. By the end of GSoC, all 13 features of the existing library will be implemented and tested, backed by a MatchingSchemaCollector EvaluationPlugin as the core data layer, a working VSCode extension, and a test suite verifying drop-in compatibility with the existing implementation.

pythonjavascripttypescript+2
Student: srivastava-diya
Code
Proposal

Unified Logging and Traceability System for Usability Studies

intermediate
Uramaki LAB•2026Varies175h (Medium)

RUXAILAB currently saves the final state of usability studies but lacks insight into the evaluation process itself. This project introduces a unified, scalable logging and traceability system built into the shared frontend layer, backed by entirely secure Firestore Cloud Functions. It captures methodology-specific events (like evaluator answer revisions and participant task anomalies) to provide researchers with an interactive Log Explorer, quick filters, and anonymized exports. This system enables deep session traceability for IRB submissions and post-study behavioral analysis without increasing database read costs or affecting existing architectures.

pythonjavascripthtml+2
Student: Justin Timothy W
Code
Proposal

Smart Experiment Management & Meta-Analysis for Visdom

beginner
FOSSASIA•2026Varies90h (Small)

Visdom is great for watching training in real time, but once you have dozens of experiments, keeping track of what hyperparameters you used in each one becomes a mess. This project adds an experiment tracking layer to Visdom a SQLite-backed metadata store where every run carries structured hyperparameters, metrics, and tags. I am building a search system so you can query runs with simple syntax like "lr less than 0.01 and accuracy above 90", interactive parallel coordinates plots to visualize the hyperparameter space, and Optuna integration so Visdom can suggest what to try next based on past results. Everything runs locally with zero external dependencies, keeping Visdom's self-hosted philosophy intact. I have already contributed 6 PRs to the Visdom codebase covering backend bug fixes, frontend improvements, test fixes, and Python 3.12+ compatibility, and I have deep familiarity with both the Tornado server and the React frontend.

pythonjavascriptandroid+7
Student: Manik Khajuria
Code
Proposal

Stateless API for Scalable and Composable Inference in sbi

advanced
NumFOCUS•2026Varies350h (Large)

This project redesigns sbi's potential function API to eliminate stateful behavior, inconsistent IID handling, and device management bugs. The new architecture introduces a three-layer design: (1) stateless core protocol using typing.Protocol for composability, (2) explicit observation binding utilities with clear IID semantics, and (3) high-level convenience factories. This enables seamless integration with NumPyro, PyMC, and PyTorch samplers while maintaining backward compatibility through a phased migration strategy. Deliverables include refactored potential classes, comprehensive tests, migration guide, UML diagrams, and tutorial notebooks demonstrating ecosystem integration. The redesign fundamentally improves maintainability, extensibility, and reliability for both novice users and advanced practitioners.

pythonjavascriptr+3
Student: Jocho-Smith
Code
Proposal

Fuzz and Test the go-mfp CPython Binding

intermediate
The Linux Foundation•2026Varies175h (Medium)

The go-mfp cpython package is a unique Go library that embeds CPython as a scripting engine, supporting multiple isolated sub-interpreters with automatic garbage collection of Python objects. As this package is planned to move into a standalone repository and potentially become critical Linux infrastructure, ensuring correctness and security across Python 3.8 through the latest version is essential. This project will build a comprehensive unit test and fuzz test suite — pairing each source file with _test.go and _fuzz_test.go files using Go's native fuzzing framework, tested across Python 3.8–latest on both x86 and ARM64. Deliverables: - Full unit test suite for all public API functions - Fuzz harnesses for sub-interpreter lifecycle, object GC, type conversions, and error handling - CI matrix builds across Python versions and architectures - Documentation for running and extending the test suite

cpythonmysql+7
Student: Abhishrestha Tiwari
Code
Proposal

Uyuni Event-Driven Automation via MQTT and Node-RED

beginner
openSUSE Project•2026Varies90h (Small)

Uyuni is a powerful systems management platform, but today it lacks a native way to automate actions based on events in real time. As a result, administrators often have to write custom scripts to react to things like patch updates or system changes, which adds unnecessary complexity and effort. This project aims to change that by introducing a simple, scalable event-driven architecture that turns Uyuni into an automation-friendly platform. The idea is to make it easy for administrators to connect Uyuni with other tools and build workflows without writing a lot of custom code. The solution has two main parts. First, an MQTT-based event publisher that hooks into Uyuni’s existing event pipeline and emits real-time events such as patch updates, system registrations, and Salt state results. Second, a custom Node-RED integration that allows administrators to visually design automation workflows using a drag-and-drop interface. The publisher is designed to be lightweight and non-intrusive, running as a passive listener so it does not interfere with Uyuni’s current behavior. It sends structured JSON messages, supports topic-based filtering, and includes reliability features like retries, batching, and rate limiting to handle larger deployments. On top of this, the Node-RED layer provides reusable nodes for consuming events, triggering actions, and interacting with Uyuni APIs. Overall, this project makes automation in Uyuni much more accessible, reduces the need for manual scripting, and enables easy integration with external tools like Slack or Jira. It also lays a solid foundation for building more advanced automation features in the future.

pythonlinuxjavascript+11
Student: Geetansh Goyal
Code

Exoplanet Atmosphere Characterization

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

Exoplanet Atmosphere Characterisation plays a vital role in understanding chemical compositions, weather patterns and habitability of the exoplanet. Traditional retrieval models take hours per planet so using machine learning for this is a perfect alternative. I have simulated a physically realistic spectral dataset of atmospheres under regimes like equilibrium transmission, disequilibrium transmission, non-isothermal emission, and photochemical emission with instrument specific noise injection. Then two models: disequilibrium-aware GRU model and Variational Autoencoder for Pressure Temperature Profiles are used to predict various atmospheric parameters. Additionally, to detect biosignatures we can use an unsupervised convolutional Autoencoder trained on normal equilibrium spectra to flag anomalous molecular signatures. Finally, I plan on validating all my models on real JWST observational data proving that these models are worthy of real world applications.

pythonmachine learningc+++2
Student: Anushree Upasham
Code

Strengthening Core Workflows and Notebook Integration in AnalySim

intermediate
INCF•2026Varies175h (Medium)

This project will improve AnalySim’s core reliability by addressing fragile user workflows, improving query and search behavior, and making the JupyterLite integration more robust and maintainable. The work will also be supported by stronger automated testing and CI checks to help ensure long-term stability and reduce future regressions.

pythonjavac+++7
Student: Mohab Elshamy
Code
Proposal

Zulip's REST API Documentation: Complete Endpoint Coverage and OpenAPI Spec Refactoring

intermediate
Zulip•2026Varies175h (Medium)

Zulip's REST API documentation framework is well-built but incomplete, approximately 28 actionable endpoints remain undocumented, and the OpenAPI spec has accumulated structural debt through years of organic growth. This project has two phases. Phase 1 achieves complete endpoint coverage by documenting all remaining high and moderate priority endpoints following the full pipeline: OpenAPI schema, Python and cURL examples, sidebar registration, and changelog entries. Phase 2 refactors the spec's structure, promoting inline parameters to shared components, rationalising the Can*Group schema family, and cleaning up repeated inline response blocks. Deliverables: (1) Zero undocumented actionable endpoints in pending_endpoints. (2) A cleaner, more consistent OpenAPI spec with reduced duplication across parameters, schemas, and response blocks.

pythonjavascriptdjango+5
Student: Agnish Bauri
Code

Production-Grade E2E and Unit Testing Infrastructure for Mifos X Web App

advanced
The Mifos Initiative•2026Varies350h (Large)

The Mifos X Web App currently faces a significant quality gap with approximately 1.46% automated test coverage, making releases reliant on risky manual verification. This project implements a production-grade testing infrastructure using Playwright and Jest, built on a robust "Four-Layer Architecture" that separates test logic from framework-specific selectors. My approach ensures long-term maintainability by creating a reusable testing SDK that supports both the current Angular codebase and the future React migration. Key deliverables include: A suite of 240+ automated tests covering the high-value Clients, Groups, and Users modules. A shard-safe CI/CD pipeline using GitHub Actions and Dockerized Fineract. Advanced reliability patterns including Fibonacci backoff retries and storageState authentication bypass to optimize performance. This project moves the Mifos Initiative toward a "Correctness First" culture, providing a scalable blueprint for financial software quality.

mysqljavascriptandroid+5
Student: Devansh vashisht
Code

Working on new GEGL ops and porting existing filters as GEGL ops

intermediate
GNU Image Manipulation Program•2026Varies175h (Medium)

GIMP is actively migrating its legacy filter system to proper GEGL operations to enable non-destructive editing, and better PSD compatibility. This project contributes to that effort. First, an Inner Glow layer style will be implemented as a native GEGL operation. The implementation will use a distance transform on the layer's alpha channel to generate a per-pixel glow mask, with parameters including spread, size, opacity, intensity, noise, and blend modes empirically validated against Photopea for PSD compatibility. Once complete, it will be mapped to GIMP's PSD importer so that PSD files with inner glow layer styles import correctly. Second, a Bevel layer style will be implemented as a GEGL operation. Bevel is the remaining unimplemented PSD layer style in GIMP, involving multiple bevel styles, separate highlight and shadow blend modes, and depth and blur interactions. The same empirical approach will be used, systematically studying parameter outputs and implementing each feature step by step. Third, the legacy sharpen filter will be ported to a GEGL meta-operation. The existing implementation relies on the legacy GimpDrawable API with manual pixel loops and is limited to 8-bit images. Since the algorithm is a 3×3 convolution, it can be cleanly expressed as a GEGL meta-op, bringing it into the modern pipeline. Deliverables: A PSD-compatible gegl:inner-glow operation mapped to the PSD importer A PSD-compatible gegl:bevel operation mapped to the PSD importer A ported sharpen filter as a GEGL meta-operation

cGEGL
Student: Waris Maqbool
Code
Proposal

Expanding and Refining AWS Service Relationships in Meshery

advanced
Meshery•2026Varies350h (Large)

While Meshery's AWS model catalog contains auto-generated connections for individual services, it currently lacks the critical "cross-model" architectural relationships (like linking an EKS Cluster to EC2 Subnets, or an API Gateway to a Lambda Function) that Site Reliability Engineers need to properly visualize and manage real-world, multi-service cloud deployments on Kanvas. Solution: This project systematically defines these missing inter-model dependencies by combining deep AWS architectural expertise with Meshery's v1alpha3 relationship schema. This involves mapping complex multi-hop infrastructures and accurately structuring evaluation queries, metadata, and mutatorRef/mutatedRef patch paths. Deliverables: 1. A comprehensive audit of cross-model gaps in the current AWS catalog. Implementation of high-priority infrastructural relationships (Networking, IAM Permissions, Firewalls). 2. Definition of complex multi-hop chains (e.g., end-to-end Serverless Event Pipelines, EKS Full Stack dependencies). Visual validation of all new relationships within Kanvas and detailed contributor documentation to guide future model integrations. 3. Definition of complex multi-hop chains (e.g., end-to-end Serverless Event Pipelines, EKS Full Stack dependencies). 4. Visual validation of all new relationships within Kanvas and detailed contributor documentation to guide future model integrations.

javascriptgolangkubernetes+2
Student: Olaleye oyewunmi
Code
Proposal

Feature-complete SVG import and rendering support

advanced
Graphite•2026Varies350h (Large)

Graphite is a powerful graphics editor, but it currently struggles to handle complex SVG files perfectly. Important details like custom text styles or advanced shapes may sometimes get lost when opening or saving files. My goal is to fix this by building a reliable, complete SVG pipeline. Firstly, I plan to add missing core features like gradients, patterns, and a proper Text-on-Path node so that Graphite can edit more SVG artwork natively. Followed by this, for any highly complex SVG features that Graphite still would not be able to edit directly, I will build a fallback system. This system will automatically convert those unsupported parts into static images rather than silently dropping them, ensuring the artwork looks exactly right when opened. Finally, I will improve how Graphite exports files, making sure layer names are saved as clean SVG IDs. Altogether, these changes will make Graphite a tool that artists can fully trust for professional SVG work.

machine learningrustvulkan+2
Student: ∅space
Code
Proposal

Implement Rich Text

advanced
KDE Community•2026Varies350h (Large)

Drawy's current text tool is limited to plain text with no per-character formatting, no undo/redo, no support for non-Latin input methods, and performance issues on large text. The goal of this project is to refactor and extend the text tool into a rich text editor. The implementation will begin by splitting the existing code into three classes (TextItem, TextCursor, TextTool) and replacing the manual rendering logic with QTextLayout, which natively handles BiDi, line breaking, and cursor positioning. On top of this foundation, the project will deliver per-range character formatting, text alignment, word wrapping, spell checking via KDE Sonnet, and a formatting toolbar for the user to control fonts, styles, and alignment. Undo/redo will be integrated. Save/load will be extended to support rich text while remaining backward compatible with existing documents. Finally, the backing data structure will be replaced with a Gap Buffer for O(1) insertions and deletions.

c/c++qtqml+6
Student: Abdelhadi Wael
Code
Proposal

OSCAL Document Signing and Verification in compliance-trestle

intermediate
CNCF•2026Varies175h (Medium)

This project adds signing and verification for OSCAL JSON artifacts in compliance-trestle so generated documents can be verified in CI/CD and downstream workflows. The implementation will introduce deterministic RFC 8785 / JCS-style canonicalization for signing input, a detached JSON attestation workflow, and new trestle sign / trestle verify commands with clear failure handling. The MVP will be key-based, JSON-first, and detached so OSCAL artifacts remain unchanged, while signed metadata will capture provenance such as trestle version, signing time, OSCAL type, and optional git/build information. Deliverables include the signing and verification code, automated tests, documentation, and a tutorial.

gorustkubernetes+3
Student: matteofari
Code
Proposal

Scalable Multi-Robot Integration and Automated Bridging for ROS 2 and Gazebo

intermediate
Open Robotics•2026Varies175h (Medium)

This project aims to improve the integration between ROS 2 and Gazebo by addressing two key challenges: manual bridge configuration and limited support for scalable multi-robot simulation. Currently, users must manually define topic mappings when using ros_gz_bridge, which becomes error-prone and difficult to maintain in dynamic or large-scale environments. In addition, multi-robot simulation requires modifying SDF/URDF files to avoid topic conflicts, making it hard to reuse robot models. To solve these issues, this project proposes a unified communication layer that introduces (1) dynamic bridge discovery to automatically detect and connect compatible ROS 2 and Gazebo topics. (2) a standardized namespacing mechanism for Gazebo plugins to enable seamless multi-robot deployment without modifying robot descriptions. The expected outcome is a robust and scalable framework that reduces configuration overhead, improves interoperability between ROS 2 and Gazebo, and allows developers to launch multiple robots with minimal effort.

pythonc/c++ros+5
Student: C88-YQ
Code

Extended platform and architecture support for Metacall

intermediate
MetaCall•2026Varies175h (Medium)

MetaCall currently supports Linux (GCC), Windows (MSVC), and macOS but many platforms where developers want polyglot runtime support are missing.The core layers have partial support for some platforms but no CI, no environment script integration, and no testing to verify they actually work.Follow TDD approach: set up CI first , then fix environment script + build system, then fix test failures.I will go platform by platform for implementation.All platform logic lives in metacall-environment.sh there will be no hardcoded logic in CI YAML. 8 platform targets with CI pipelines with working environment script section, verified CMake detection and build, automated testing.Fixes to metacall/plthook fork for platforms that need it.

pythonjavascriptc/c+++6
Student: Yug105
Code
Proposal
Showing 313 - 336 of 13453 Projects
1213141516
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal