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

Community detection guide with igraph

intermediate
NumFOCUS•2025Varies

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)

Community detection is one of the most commonly used network analysis techniques. It is the process of grouping nodes of a network together based on their connections, with the scope of finding clusters which are more connected internally than externally. By uncovering these communities one can gain insight into how groups interact and how the network is organized. Community detection finds use in various scientific disciplines, including biology, neuroscience, sociology, and physics. This project aims to develop a hands-on guide to community detection with python-igraph, tailored to empirical researchers who may only have limited network science experience. The guide will be delivered in the form of an interactive, executable document, and will include detailed code examples, case studies, and visual demonstrations of the main concepts of community detection. We will cover key ideas such as modularity, hierarchical clustering, consensus clustering, and overlapping communities. Additionally, we will provide brief descriptions of community detection methods and their tradeoffs, along with examples of visualization techniques.

pythonjavascriptr+3
Student: Bea Márton
Code
Proposal

Martian Climate Dashboard

intermediate
Liquid Galaxy project•2025Varies175h (Medium)

The project aims to provide real-time and historical climate data visualization from Mars on Liquid Galaxy through an engaging and interactive experience. A Flutter-based mobile app will retrieve and process atmospheric data from the Mars Climate Database (MCD), presenting it with compelling visualizations on Liquid Galaxy.

javascriptrosgis+14
Student: Mohit_Sharma
Code
Proposal

CPA-Daemon: Behavior Driven Tests

intermediate
Software and Computational Systems Lab at LMU Munich•2025Varies175h (Medium)

CPA-Daemon is a microservice (currently gRPC service) for continuous verification of C programs with CPAchecker. Clients could craft gRPC requests (with details for instructing a CPAchecker program run) sending to CPA-Daemon and receive the program-verification response. Current CPA-Daemon integration tests require large inputs that are difficult to read within code: c input programs, CPAchecker specifications, CPAchecker configurations[3]. So our goal in this project is "A running integration-test suite for CPA-Daemon based on Cucumber". With Cucumber clear "Given / When / Then" semantics in writing test, we aim to reach the same or more branch coverage than the existing integration tests. Adopt Cucumber should help us easily add more test in the future.

pythonjavascriptjava+2
Student: Wenyi Shi
Code

Structured DNS Error Support in Chromium's DNS Stack

intermediate
Chromium•2025Varies175h (Medium)

When DNS queries fail due to policy-based restrictions (e.g., BLOCKED, CENSORED, FILTERED), DNS resolvers can attach Extended DNS Error (EDE) codes along with structured JSON metadata in the response. This proposal aims to extend Chromium's DNS stack to parse and log Structured DNS Error (SDE) and Public DNS Error (PDE) content embedded in these EDE responses. The project involves extracting JSON metadata from the extra_text field for specific EDE and exposing them through the NetLog system. These improvements will provide more transparent diagnostics and support future UX enhancements. Deliverables: Full support for parsing SDE extra text and PDE, integration with Chromium's DNS resolution pipeline, NetLog exposure of parsed fields, and unit tests to ensure robust and secure behavior.

pythonjavascriptjava+2
Student: Chenhao(Calvin) Diao
Code
Proposal

Enhancing SQLancer with External Reducer Support and Hierarchical Delta Debugging

intermediate
SQLancer•2025Varies175h (Medium)

SQLancer’s current test case reduction framework faces three key limitations: (1) tight coupling between internal reducers (Delta Debugging and AST-based), limiting extensibility; (2) structural unawareness in Delta Debugging, which treats SQL inputs linearly despite their hierarchical relationships; (3) narrow applicability due to engine-specific Reproducer dependencies (only SQLite3 supported). This project addresses these issues by introducing a modular Reducer<G> interface to decouple reduction strategies (supporting tools like C-Reduce/Perses), implementing Hierarchical Delta Debugging (HDD) to group SQL statements by logical dependencies (improving efficiency from O(n²) to O(n log n)), and automating external reducer integration through dynamic script generation. Deliverables include the modular interface, HDD-preprocessed reducers, C-Reduce/Perses adapters, and comprehensive tests/documentation.

javasql
Student: Jinhui Xu
Code
Proposal

End-to-End Historical OCR Pipeline with 80%+ Accuracy

intermediate
HumanAI•2025Varies175h (Medium)

The objective of this project is to develop a robust, end-to-end OCR pipeline capable of achieving at least 80% accuracy in recognizing characters from early modern Spanish documents. The focus will be on leveraging recent advances in Handwritten Document Recognition (HDR), an emerging subfield of document analysis that integrates document layout and text recognition into a single model. By exploring both HDR-based and traditional approaches, the project aims to create a practical solution for historical document transcription as part of the RenAIssance initiative.

pythonmachine learningc+++2
Student: Yukinori Yamamoto
Code
Proposal

Tooling for running BPF GCC tests on a live kernel

intermediate
GNU Compiler Collection (GCC)•2025Varies175h (Medium)

This project addresses the lack of execution tests for the BPF backend in GCC. While GCC has many compile-time tests, the BPF backend, which generates eBPF code run by the Linux kernel, lacks runtime validation. The goal is to create a test tool that runs eBPF programs on a live kernel in a virtual environment (using QEMU), similar to the kernel's selftest infrastructure. The tool will load and execute BPF objects and report results, allowing us to catch regressions early. Next, this tool will be integrated into GCC's Dejagnu-based testing infrastructure, and a dedicated testsuite for the BPF target will be added to the GCC testsuite. This project will help ensure that compiler changes do not inadvertently generate eBPF code that the kernel verifier rejects.

cc++openmp+3
Student: PiyushRaj927
Code
Proposal

Enhancing Debian Packaging for FOSSology

intermediate
FOSSology•2025Varies175h (Medium)

This project aims to improve the Debian packaging process for FOSSology, an open-source license compliance tool. Currently, FOSSology relies on CPack for packaging, which has limitations in flexibility and Debian policy compliance. This proposal suggests transitioning to Debian's native packaging tools (dpkg, debhelper, and lintian), automating the build process, and integrating continuous integration (CI) for better package management. Deliverables include structured Debian packages, automated build scripts, CI pipelines, and detailed documentation to facilitate future maintenance. This work will make FOSSology more accessible, easier to install, and compliant with Debian standards, benefiting system administrators and developers.

linuxpostgresqlc/c+++7
Student: Ahmed-Gamal
Code
Proposal

Improving E2E QA tests

intermediate
OpenELIS Global•2025Varies175h (Medium)

The current End-to-End (E2E) test coverage for the new React frontend stands at approximately 30%, leaving critical functionalities untested. This project aims to enhance E2E test coverage to at least 80%, ensuring comprehensive validation of the entire application workflow. By identifying gaps, developing additional test cases, optimizing execution, and integrating tests into the CI/CD pipeline, this initiative will significantly improve system reliability, user experience, and overall software stability.

postgresqljavascriptjava+2
Student: Bahati308
Code
Proposal

Cargo: Build script delegation

advanced
The Rust Foundation•2025Varies350h (Large)

This project aims to overcome the limitations of the current Build Script system by allowing multiple, well-organised build scripts, that are optional and run only when required. This approach will require less auditing, will enhance the build transparency and reduce the compile-time overhead. Build scripts in Rust facilitate compiling and linking 3rd party code, such as existing C/C++ libraries, before building a package. They are immensely important for interoperability since it prevents replacing/rewriting the already existing tools that are well-optimized for their tasks. However, the current build system has certain limitations. Only one build script is allowed per package, and it must be run before building the package, often causing unnecessary computation (e.g., during unit tests). Single Large script needs extra auditing, increase compile-time, and reduce transparency for third-party build tools, especially while passing parameters. They also cannot run unit tests within themselves. This project aims to overcome the above limitations by allowing multiple, well-organized build scripts that can be run directly from the Cargo.toml. These scripts are optional and run only when required, avoiding unnecessary expensive logic. With this, only the shared build scripts will need auditing. This approach enhances build transparency, reduces compile-time overhead, and even enables unit testing of build scripts if they are treated as a dedicated package.

pythonrust
Student: Naman Garg ( namanlp )
Code
Proposal

Unification of the Eventyay System through Enext

advanced
FOSSASIA•2025Varies350h (Large)

The goal of this project (Enext) is to unify and modernize the eventyay-tickets architecture, with a next-generation modular system that integrates ticketing, talk management, and video services under a single, maintainable Django framework. The project focuses on refactoring components, introducing containerized workflows, and improving developer efficiency with consistent configurations and plugin capabilities. Key objectives include: - Unified Event Models and Architecture Refactor - Integration of Tickets, Talks, and Video Components - Plugin Standardization (Badge, Exhibitors, OutputPDF, etc.) - Enhanced CORS, Middleware, and Static File Handling - Docker and Gunicorn Deployment Setup - Performance, Logging, and Celery Worker Integration - Testing, Documentation, and Developer Experience Improvements

pythonjavascriptandroid+7
Student: Srivatsav Auswin
Code
Proposal

Machine-Readable Repository Information Query Tool

intermediate
Git•2025Varies175h (Medium)

This project introduces a new Git sub-command (currently intended to be called git repo-info) that will centralize data currently retrieved by git rev-parse in a JSON format.

cshell scriptgit+2
Student: Lucas Oshiro
Code
Proposal

Development of Advanced User Statistics Visualizations

advanced
MetaBrainz Foundation Inc•2025Varies350h (Large)

The project aims to design and implement advanced interactive visualizations for ListenBrainz using Nivo for data visualization and integrating with the existing Flask API. Apache Spark will handle efficient data processing and aggregation. These visualizations will offer granular insights into genre trends, artist diversity, and temporal listening patterns, enhancing user experience and engagement. The project will result in the development and integration of the following four interactive charts into ListenBrainz: 1. Generate Artist Listening Activity Statistics: A function to calculate the number of listens for each artist over a specified time range, mapping the data into an interactive visualization that shows the evolution of artists a user listens to over time. 2. Generate Listens by Era Statistics: A function to calculate the number of listens grouped by the year of release of each track, producing a chart that displays listens by era, enabling users to explore the distribution of their music preferences across different periods. 3. Genre-Based Listening Patterns: A dynamic visualization that tracks a user’s engagement with different genres over time, highlighting how their music preferences evolve. It will also analyze trends in genres listened to at different times of day, revealing how mood or activity influences music choices. 4. Top Listeners: A leaderboard-style visualization that tracks and highlights the top listeners sitewide. This chart will showcase the most active users and display who listens the most within their social circles, encouraging community engagement and fostering a sense of connection among users. These interactive charts will enhance the ListenBrainz user experience by providing deeper insights into listening habits and fostering a stronger sense of community.

pythonjavascriptperl+8
Student: holycow23
Code

Rewrite Rust lints to operate on frontend's HIR

intermediate
GNU Compiler Collection (GCC)•2025Varies175h (Medium)

GCC Rust (gccrs) is an alternative Rust compiler frontend based on GCC, aiming for full integration into the GNU toolchain. This project focuses on improving the HIR (High-Level Intermediate Representation) visitor pattern and migrating lint checks from the middle-end to HIR. These improvements will enhance gccrs's overall code quality.

cc++openmp+3
Student: Ryutaro Okada
Code
Proposal

Implementation of a Near to Far Field Transformation (NFFT) Calculation and Output of Relevant Info

intermediate
gprMax•2025Varies175h (Medium)

This project aims to implement a Near-to-Far Field Transformation (NFFT) feature in gprMax. This will enable users to compute the far-field radiation patterns and radar crosssections(RCS) from the near-field data. It will expand gprMax’s capabilities for antenna design, scattering analysis, etc. I propose to implement the Near-to-Far Field Transformation (NFFT) module and its integration at several key points in the existing workflow: - Adding the NFFT command - Module for Field Sampling during FDTD - Post-Processing & Far-Field Calculation - Integration with the API - Validation and Testing - Documentation and Review

pythoncythoncuda+3
Student: Karan Khajanchi
Code
Proposal

AMD ROCm HIP Port Proposal

advanced
gprMax•2025Varies350h (Large)

This project focuses on porting the PyCUDA-based FDTD method solver of gprMax to HIP API. The final target is to run gprMax on AMD ROCm GPUs. HIP Python and HIPIFY+Pybind are considered to be used to do the porting work. The final deliverables consist of the ported kernels and the adaption to the original gprMax code, the setup script, benchmarks, and documents.

pythoncythoncuda+3
Student: Anjie
Code
Proposal

Onboarding Revamp in Listenbrainz-Android

beginner
MetaBrainz Foundation Inc•2025Varies90h (Small)

A smooth and intuitive onboarding experience is essential for any app, ensuring that users understand its features while maintaining trust and engagement. This project focuses on enhancing the ListenBrainz Android onboarding flow by making it more informative, user-friendly, and privacy-conscious. Key improvements include a dedicated Listen Submission screen to give users full control over which apps contribute listens, clear permission rationales, and fallback mechanisms for denied permissions. Additionally, a revamped sign-in screen will provide better navigation, including a bug report option for easy issue submission. These improvements are crucial for user transparency and trust. By introducing a Listen Submission screen, users can choose how and when their listening data is collected, ensuring privacy and control. Clear permission rationales and fallback handling prevent confusion and provide users with alternative ways to grant necessary permissions. The addition of update prompts and options like disabling battery optimization in settings ensures users stay updated with the latest features and optimizations effortlessly. Seamless updates and proactive issue resolution enhance the overall experience. Integrating an update prompt for Play Store and F-Droid users keeps them informed about new releases, while a "Report Bug" button on the sign-in screen streamlines feedback collection. These refinements will significantly improve user retention, ensuring ListenBrainz remains a top choice for tracking listening habits while prioritizing privacy and usability.

pythonjavascriptperl+8
Student: Hemang Mishra
Code

Extending Crocolake’s available datasets

advanced
IOOS•2025Varies350h (Large)

CrocoLakeTools is a Python package designed to convert oceanographic datasets from various formats (like netCDF and CSV) into CrocoLake’s unified Parquet-based data lake. This allows researchers to work with clean, consistent data without dealing with technical format issues. In this project, I’ll be extending CrocoLakeTools by developing new converters for the Saildrones and Oleander datasets, two widely used but structurally complex sources. The focus will be on building efficient conversion pipelines using tools like xarray and dask, while also improving testing, documentation, and overall usability. These additions will expand the tool’s dataset coverage and help researchers access and process more ocean data.

pythonocean sciencejava+3
Student: David Nady
Code
Proposal

VMM Accelerator support for QEMU

advanced
The FreeBSD Project•2025Varies350h (Large)

This project aims to add VMM acceleration support to QEMU on FreeBSD, bridging the gap between QEMU’s userspace emulation and FreeBSD’s kernel-based VMM hypervisor. Currently, QEMU on FreeBSD lacks hardware acceleration, forcing users to rely on slower TCG emulation or switch to bhyve. I plan to modify QEMU’s memory management to work with VMM’s kernel-allocated guest memory. Additionally, I will adapt VMM to make non-critical devices (HPET, RTC) optional, letting QEMU handle them in user space. This would enable a hybrid interrupt model (kernel vLAPIC + emulated IOAPIC). The deliverables for this project would be a working -accel=vmm backend for QEMU. I will also add some changes to VMM, allowing some of the in-kernel devices to be made optional. Finally, I will add comprehensive documentation and benchmarks for the libvmmapi interface. This will enable near-native performance for QEMU on FreeBSD, expanding virtualization options while maintaining compatibility with existing QEMU tooling.

c/c++llvmassembly+5
Student: Abhinav Chavali
Code
Proposal

PyUVM-Based General Testbench for RISC-V Cores

intermediate
Micro Electronics Research Lab - UITU•2025Varies175h (Medium)

With the increasing adoption of RISC-V as an open-source Instruction Set Architecture (ISA), there is a growing need for effective and reusable verification methodologies. While Traditional verification methodologies struggle with variability of RISC-V cores leading to extensive testbench modifications, our project resolves this by leveraging the RISC-V Formal Interface (RVFI) and PyUVM making UVM-based verification more accessible to a broader audience.

RISCVProcessorHardware+2
Student: Nitin Grandhi
Code
Proposal

Using AI for Unicode Spoof Detection

intermediate
Unicode, Inc.•2025Varies175h (Medium)

Attackers can exploit homoglyphs, or visually similar characters, to perform social engineering attacks or evade spam and plagiarism detectors. Unicode contains over 200 writing systems (scripts). Many of these scripts, such as Latin (in western Europe) and Cyrillic (in eastern Europe), contain characters that are look-alikes. This project aims to develop an AI tool to detect confusable characters and ultimately improve Unicode security mechanisms automatically.

javac++rust+1
Student: Om Doiphode
Code
Proposal

Improving Geo-Coordinate Extraction and Precision in DBpedia's Extraction Framework

intermediate
DBpedia•2025Varies175h (Medium)

Many DBpedia entries, especially for cities in the Southern Hemisphere like South Africa, incorrectly store geo-coordinates with positive longitude values. Wikipedia's diverse coordinate template formats often fail to parse correctly, resulting in missing geographic data. These inaccuracies can result in incorrect mapping and spatial data interpretation. This project aims to enhance DBpedia's Extraction Framework by: Refactoring GeoCoordinateParser.scala with robust input validation and hemisphere-aware sign correction. Implementing a flexible GeoCoordinateParserConfig system with regex patterns and parameter mapping. Adding unit tests and integration tests for validating geo-coordinate correctness. Extending the GeoCoordinatesMapping.scala file to parse and emit directional info. Refactoring and cleaning up legacy extraction logic to support consistent coordinate output. Deliverables: Patch to the Extraction Framework implementing these improvements. Test suite to validate parsing and extraction of directional metadata. Documentation for contributors on how to test and extend the geo-coordinate logic.

javascalardf+7
Student: haniya konain
Code

Receipts Processor and Reporting App powered by Multi-modal LLMs

intermediate
rocket.chat•2025Varies175h (Medium)

This project automates receipt processing and expense reporting using OCR capabilities of multi-modal LLMs to address the time-consuming nature of manual expense tracking. Users upload receipts into designated chat channels—each representing a specific event, time period, or trip—where the system validates the image, extracts structured data such as amount, date, and items, and categorizes expenses automatically. The processed data is stored persistently, allowing users to generate detailed spending reports in various formats (daily, weekly, monthly, yearly, or custom date ranges), filter by specific channels, or view overall spending. Additional functionalities include natural language query support, optional slash command integration to perform actions like showing receipt data. All designed to streamline financial tracking by minimizing manual input and enabling efficient, structured querying of expense data.

javascriptwebrtcmeteor.js+18
Student: William Liu
Code

Ergonomic API for Vector Mesh Topology

advanced
Graphite•2025Varies350h (Large)

The project aims to design and implement an ergonomic and efficient API for accessing, manipulating, and performing operations on vector data such that implementing complex vector-based algorithms or developing tools to perform vector manipulations is efficient and ergonomic. The second aspect of the project is to enhance performance and stability by transitioning from Bezier-rs to Kurbo algorithms and data structures to perform vector operations.

machine learningrustvulkan+2
Student: indierusty
Code
Proposal
Showing 1729 - 1752 of 11996 Projects
7172737475
Proposal
Proposal
Proposal
Proposal
Proposal