Contribo
ProgramsOrganizationsProjectsProposal StudioResourcesOrbit AIDashboard
Login
Login
Contribov1.0

Your premium companion for discovering, matching, and tracking paid open-source mentorship programs and verified starter issues.

Product

  • Programs Directory
  • Orbit AI
  • User Dashboard

Resources

  • Guides & Resources
  • Proposal Studio

Community

  • GitHub Repository
  • Code of Conduct

Legal

  • Privacy Policy
  • Terms & Conditions
  • Cookie Policy
  • Accessibility Statement

Made with love bySubhranshu Sekhar Dash

© 2026 Contribo. Built for the global open-source community.

PlatformProjects

Explore Projects

Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.

Confused which project to choose or don't know which one you are most suitable to work on?

Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.

Match with Orbit AI
Filters Clear
5976 Projects Found
Sort by

Online Validation Tools

intermediate
Software Product Data Exchange (SPDX)•2017Varies

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)

<p>Software Package Data Exchange (SPDX) is “a set of standards for communicating the components, licenses, and copyrights associated with software”. You can find the latest (as well as the previous) standards at:</p> <p><a href="https://spdx.org/specifications" target="_blank">https://spdx.org/specifications</a></p> <p>One idea is to accompany software with special files that hold certain meta information: authorship, copyrights, licenses, etc. These files currently come in two major formats: TAG and RDF. There are parsing tools available for these formats in Python and Go:</p> <p><a href="https://github.com/spdx/tools-python" target="_blank">https://github.com/spdx/tools-python</a></p> <p><a href="https://github.com/spdx/tools-go" target="_blank">https://github.com/spdx/tools-go</a></p> <p>These tools do not support the latest SPDX-2.1 standard (instead, they can handle SPDX-1.2) which makes it logical to add support for the latest standard.</p> <p>However, personally I am not happy with the specification which is why I would rather develop an online validation tool with the <a href="https://github.com/nexB/license-expression" target="_blank">license-expression</a> [pyLE] library which heavily relies on the <a href="https://github.com/bastikr/boolean.py" target="_blank">boolean.py</a> library [BP].</p>

cpythonjava+2
Student: Aleksandr Lisianoi
Code
Proposal

Upgrading Eventyay-Video with Real-Time Multilingual Audio and Auto-Deployment

advanced
FOSSASIA•2024$6k–$13.2k350h (Large)

The Eventyay-Video platform is a robust tool for hosting virtual events. This GSoC project aims to enhance its functionality, improve deployment efficiency, and introduce features for a more interactive and accessible user experience. The upgrades will make the platform more adaptable, especially for events needing multilingual support and enhanced streaming capabilities. Key responsibilities for this project include: 1. Implementing a Live Interpretation System: Introduce real-time multilingual audio support, allowing participants to select and listen to different language streams during presentations and discussions. 2. Setting Up Auto-Deployment with Docker: Automate the deployment process using Docker to streamline workflows, allowing developers and contributors to efficiently deploy, test, and maintain the platform. 3. Updating Dependencies: Ensure the platform is secure and up-to-date by updating all outdated dependencies to their latest versions, addressing compatibility issues, and maintaining smooth operation with the latest software standards. 4. Improving the User Interface: Enhance the UI to make the platform more intuitive, offering a seamless experience for participants, organizers, and moderators. 5. Improving YouTube Integration and Adding More Controls: Upgrade the platform's YouTube integration, allowing for better control over embedded videos, including advanced playback controls and interaction features. By the end of the project, Eventyay-Video will be significantly more powerful and versatile, providing a highly functional platform for virtual events with real-time interpretation, streamlined deployment, and enhanced streaming features.

pythonjavascriptandroid+7
Student: Untari
Code

Molly.jl: Machine Learning Potentials for Molecular Dynamics

advanced
The Julia Language•2026Varies350h (Large)

Classical force fields in molecular dynamics are fast but cannot capture bond breaking, charge transfer, or complex many-body chemistry. Machine learning potentials (MLPs) close this gap — offering near-quantum accuracy at a fraction of ab initio cost. Molly.jl currently supports MLPs only through a Python bridge (ASECalculator), which requires a Python runtime and bypasses Julia's differentiable programming stack entirely. This project delivers native Julia support for four widely-used MLP families: ANI (neural network potential for organic molecules), ACE (linear body-ordered basis expansion), NequIP, and Allegro (E(3)-equivariant graph neural networks). ANI is implemented from scratch in pure Julia using Lux.jl, with pre-trained ANI-1x/ANI-2x weights loaded from HDF5. ACE is integrated via the mature ACEpotentials.jl package. NequIP and Allegro are wrapped from TorchScript-exported models via PythonCall, following the existing ASECalculator pattern. All four potentials plug into Molly.jl's general_inters dispatch loop with zero changes to core simulation code. Pure-Julia models (ANI, ACE) are fully differentiable via Enzyme reverse-mode AD and GPU-accelerated via KernelAbstractions. The result: researchers can run differentiable, ML-accelerated molecular dynamics entirely within Julia — no Python, no overhead, composable with the full SciML ecosystem.

cjavascriptc+++12
Student: Siva Sathyaseelan
Code

Real-Time Policy Evaluation in Meshery UI using OPA WebAssembly

beginner
CNCF•2025Varies90h (Small)

Abstract: This proposal outlines a plan to enhance Meshery's relationship evaluation capabilities by implementing client-side policy evaluation using WebAssembly. By integrating OPA's WebAssembly compilation capabilities into Meshery's UI, I aim to enable real-time evaluation of complex Rego policies, providing users with immediate feedback on configuration changes and policy compliance. This enhancement will significantly improve the user experience when designing their designs and will make the policy evaluation distributed hence reducing load on a meshery server Problem Statement Meshery currently doesn't support evaluating policies in real-time on the client side. The existing approach ( relying on the rest api interface exposed by meshery-server) introduce s latency when policy evaluation occurs server-side, limiting the responsiveness of the UI when users make configuration changes. Additionally, as policies become more complex and numerous, the ability to quickly validate configurations against these policies becomes increasingly important for a smooth user experience. Proposed Solution: Use opas capibilty to compile rego policies directly into wasm plans and then integrate the evaluation process in ui using OPA's JavaScript SDK, which provides a simpler way to load and evaluate Rego policies compiled to WebAssembly. This approach is more lightweight and performant . Deliverables : - Real time evaluation of policies in ui - Keeping the support for both targets of evaluation backend or realtime on frontend - Making the evaluation responsive and performant by implementing webworkers , caching

gorustkubernetes+3
Student: Aabid Ali
Code
Proposal

Supervisor Domains Priv. ISA Extension Emulation Mentorship Project

Intermediate
•Varies175h (Medium)

Security-sensitive workloads on embedded and server platforms require isolation primitives to support many use cases that require enforcement of confidentiality and integrity for workload against software and hardware adversaries. Providing these protection properties requires architectural support for page-based physical memory isolation managed at the machine level to be able to create isolated supervisor domains which can then host isolated S/H and (V)U, V(S) mode software. A supervisor domain can extend the trusted computing base (TCB) to host isolated VMs and/or applications. The Supervisor domains task group has defined privileged ISA extensions (Smsdid, Smmtt, Smsdia, Smsedbg etc.), to be used by machine mode to isolate physical memory, and other platform resources flexibly across supervisor domains. As specified in the RISC-V Supervisor Domains specification, per-hart controls for a supervisor domain identifier can be used to program a memory tracking table (MTT) structure that will specify if a supervisor domain is allowed to access physical memory regions (at architectural page-size granularities). The MTT will be programmed by an M-mode root-domain security manager (RDSM). The mentee will primarily focus on developing extensions to Qemu to emulate the RISC-V Supervisor Domain (Smmtt) ISA extensions, and build an priv. software prototype for the M-mode RDSM using OpenSBI to demonstrate the functionality of the emulated ISA.

TBA
Proposal

Implement WASI and wasmedge_process host functions on Windows

advanced
CNCF•2022Varies350h (Large)

WebAssembly has become extremely popular among the developer community lately. It offers near native performance in a browser and is meant to not be a hand written language but to be the compilation target of source languages like C, C++, Rust etc. It provides a way to run code written in multiple languages on the web at near-native speed, with client apps running on the web that previously couldn't have done so. It, being a new language , does not enjoy wide support across platforms. The prospect of having a unified interface for web developers has long been elusive. It has the potential to provide the basis on which many apps can be built and deployed for a huge range of devices from IoT devices to fully fledged servers. But to enable developers to use it we need a WASI runtime ecosystem to support them. WasmEdge is one such project that aims to bring WebAssembly to the edge. To provide a unified interface accross multiple platforms, a interface between WasmEdge and the host operating system has to be built. This interface is specific to the platform on which the runtime is deployed and has to be built individually and specifically for each platform bearing in mind the features available. The native API provided by the OS should be used to implement many of the common operations like file manipulation, IO etc. These 'host functions' are crucial for the project to succeed and have been defined in WASI - the Web Assembly System Interface which is a modular collection of standardised APIs Currently, host specific functions have not been implemented in WasmEdge, for the windows platform. These functions are supposed to be implemented using the Win32 API and have to go rigorous testing before being deployed.

gorustkubernetes+3
Student: Abhinandan Udupa
Code
Proposal

Quality Check ToolBox V1.0

intermediate
Open Science Initiative for Perfusion Imaging•2026Varies175h (Medium)

Problem: There is currently no standalone, open source Python library within the OSIPI ecosystem for post-processing quality control (QC) of Arterial Spin Labeling (ASL) MRI perfusion data. Existing solutions are either MATLAB dependent, closed-source or tightly coupled to specific preprocessing pipelines, making scalable and reproducible QC difficult for clinical and research datasets. Solution: I will build Quality Check ToolBox V1.0 for osipy a pipeline-agnostic, modular Python library that evaluates ASL-derived Cerebral Blood Flow (CBF) maps and generates interpretable PASS/WARN/FAIL triage metrics. Using a configurable registry architecture, it evaluates the Quality Evaluation Index (QEI) alongside orthogonal checks for BIDS compliance, M0 calibration and motion. It features graceful degradation and population-specific YAML configurations (e.g., pediatric, stroke) to successfully distinguish real pathological signals from acquisition artifacts. Deliverables: Core osipy-integrated QC pipeline with a @register_qc_check module registry. Full implementation of the Dolui et al. 2024 QEI metric. Fallback-capable modules for control-label validation, M0 saturation, and motion tracking (FWD/DVARS). Configurable PASS/WARN/FAIL verdict logic that prevents pipeline crashes on missing data. A comprehensive Pytest suite and MkDocs documentation. A standalone HTML visual dashboard for reviewing QC metrics across cohorts.

pythongithub
Student: Agnik Misra
Code
Proposal

Unicode Character Visualizer App and Multilingual Text Rendering Tester

advanced
Unicode, Inc.•2025Varies350h (Large)

This proposal focuses on developing two essential tools using Flutter: the Unicode Character Visualizer App and the Multilingual Text Rendering Tester App. Problem Statement Many developers, designers, and linguists lack accessible tools to browse Unicode characters, view detailed metadata, and compare how multilingual text is rendered across devices and fonts. Text rendering inconsistencies often arise across platforms, impacting accessibility and readability. Solution Unicode Character Visualizer App: Provide a comprehensive and interactive platform to search and visualize Unicode characters. Display essential metadata such as codepoints, descriptions, and language support. Offer font rendering previews for accurate character representation. Multilingual Text Rendering Tester App: Allow users to input multilingual text and visualize rendering differences across various fonts and devices. Benchmark rendering performance and identify inconsistencies. Deliverables Fully functional Unicode Character Visualizer App with search, character details, and font rendering features. Multilingual Text Rendering Tester App with input comparison, font analysis, and reporting functionalities. Comprehensive documentation, including user guides and API integration manuals. Well-tested codebase with unit, widget, and integration tests. This project will contribute to Unicode, Inc. by providing essential tools for ensuring Unicode character accuracy, supporting linguistic diversity, and improving cross-platform text rendering. I am excited about the opportunity to collaborate and contribute to the Unicode ecosystem.

javac++rust+1
Student: Popoola Precious
Code

Enhancements to FOSSASIA Open Event Android App

advanced
FOSSASIA•2017Varies350h (Large)

<p>Aim of the project is to improve and enhance <strong>Open Event Android</strong> project by adding more features, improving performance and fixing bugs.</p> <ul> <li>Add support for new API (<strong>JSONAPI</strong>) of Open Event API Server</li> <li>Add <strong>User Authentication</strong> in the App along with adding an option in the generator to add authentication in the App.</li> <li>Add <strong>User profile</strong> feature using which user can update name and avatar</li> <li>Improve <strong>Map</strong> by adding markers for all the microlocations</li> <li>Improve <strong>searching/filtering performance</strong> all over the App</li> <li>Add feature to <strong>cache thumbnails and images</strong> to load it when device is offline</li> <li>Add <strong>TextDrawable</strong> to show as placeholder for speaker image while image is downloading</li> <li>Enhance UI by adding <strong>Sticky Headers</strong> for grouping through out the App</li> <li>Improve UI by adding <strong>number of sessions label</strong> for track</li> <li>Improve code base to <strong>support older devices(pre-lollipop)</strong> with API level &lt; 21</li> <li>Refactor code base to <strong>improve performance</strong> and to reuse code using Utility methods</li> <li>Fix other <strong>critical bugs</strong> and issues</li> </ul>

pythonjavascriptandroid+7
Student: Shailesh351
Code
Proposal

Evaluate WebdriverIO replacements for our browser automation framework

intermediate
Wikimedia Foundation•2020Varies175h (Medium)

<p>Currently all the frontend automation tests for MediaWiki are written in Javascript using <a href="https://webdriver.io" target="_blank">WebDriverIO</a> which uses Selenium under the hood. While WebDriverIO offers many advantages like cross-browser support, large and continuously growing community, etc, some major hurdles while using WebDriverIO such as:</p> <ul> <li>non-trivial set-up</li> <li>flaky tests</li> <li>poor documentation</li> <li>painful debugging and syntax which is painful to grasp. Additionally WebDriverIO does not synchronise with the Selenium updates so <a href="https://webdriver.io/blog/2018/12/19/webdriverio-v5-released.html" target="_blank">upgrading it to a newer version is a painstaking task</a>, not to mention all the familiar bugs and quirks that come with Selenium.</li> </ul> <p>This project aims to evaluate <a href="https://cypress.io" target="_blank">Cypress</a> and <a href="https://pptr.dev" target="_blank">Puppeteer</a> as alternative test-automation frameworks based upon various factors such as:</p> <ul> <li>stability of tests</li> <li>ease of installation, developer experience</li> <li>community support</li> <li>speed of test runs</li> <li>configuration options</li> </ul> <p>and if positive, estimate the work needed to migrate all <a href="https://www.mediawiki.org/wiki/Selenium/Reference/Example_Code" target="_blank">repositories that currently use WebdriverIO</a> to the chosen framework.</p>

javascripthtmlphp+7
Student: Soham Parekh
Code

CellQuery-ST: Cell-Aware Query Grounding for Single-Cell and Neighborhood Retrieval from Histology

advanced
UC OSPO•2026Varies350h (Large)

CellQuery-ST addresses a key gap in computational pathology: while current models can predict gene expression or answer coarse slide-level questions, they do not support cell-aware querying of histology images. In practice, researchers and clinicians want to ask questions such as: Where are B-cell follicles? Which regions show inflammatory myeloid activity? Which neighbourhoods resemble a vascular niche? This project aims to make such biologically grounded querying possible on new histology slides. To solve this, I will build a cell-aware query grounding framework that uses spatial omics data for supervision during training but supports image-only inference at test time. Each slide will be preprocessed into a spatial index of cells, patches, and neighbourhoods, and natural-language queries will be matched against this index to retrieve or score relevant spatial evidence. The system will combine spatial pathology data with CellNet, an existing paired single-cell and language resource, to connect text queries with cell identities, cell states, and higher-level biological concepts. The main deliverables will be: (1) a benchmark covering four task families—cell type grounding, cell state/programme grounding, spatial niche grounding, and communication hotspot grounding; (2) a reusable slide indexing and retrieval pipeline for histology images; (3) reproducible baseline models and evaluation utilities for seen/unseen query generalisation; and (4) documentation and tutorial notebooks showing how to preprocess a new slide, issue queries, and evaluate results.

pythonc/c++visualization+5
Student: Tong Wu
Code

iOS Implementation of Menu Component

intermediate
MIT App Inventor•2025Varies175h (Medium)

This proposal aims to implement the Menu, Sidebar, and Floating Action Button (FAB) components in iOS for MIT App Inventor, ensuring feature parity with Android as introduced in PR #2299. The Menu Component will introduce a dropdown-style menu supporting nested items, icons, and keyboard navigation. The Sidebar Component will provide a sliding navigation panel with swipe gestures, tap-to-close functionality, and essential navigation links like Home, Profile, Settings, and Logout. The Floating Action Button (FAB) will be a circular, floating button positioned at the bottom-right, supporting custom actions, animations, and a shadow effect for a modern UI experience. A key aspect of this project is ensuring feature parity with Android, maintaining UI/UX consistency across both platforms. I chose this project because it bridges the gap between iOS and Android, ensuring that MIT App Inventor provides a seamless cross-platform experience. It also enhances user experience by introducing smooth, intuitive navigation and interactions, making iOS-built apps more functional and engaging. Additionally, this project will expand MIT App Inventor’s capabilities by adding essential missing features, making the platform more versatile and user-friendly. The estimated timeline for this project is 175 hours, covering implementation, testing, and final integration. Upon completion, this update will significantly enhance MIT App Inventor’s iOS version, making it a fully-featured, cross-platform development tool that aligns with modern app-building standards.

javagwtgoogle app engine+7
Student: Kasy
Code
Proposal

Dockerized R/Shiny Application for Biomedical Data Analysis Using PFB-Formatted AVRO Files

intermediate
Data for the Common Good•2025Varies175h (Medium)

This project delivers a Dockerized RStudio/Shiny application for analyzing biomedical datasets stored as Apache Avro files conforming to the Portable Format for Biomedical Data (PFB) standard. Leveraging Apache Spark via the sparklyr interface, the system efficiently ingests and processes large, deeply nested Avro inputs (40,000+ records) and flattens hierarchical entity structures into analysis-ready tabular data. Users can explore entity and observation nodes, generate descriptive summaries and percentage distributions, and run survival analyses Kaplan–Meier overall survival (OS) and event-free survival (EFS) both on subject IDs uploaded by the user and on the full dataset. A configurable Table-1 workflow supports covariate selection; explicit variable typing (categorical or continuous); inclusion/exclusion of variables and, for categorical variables, specific levels; and p-value computation when grouping is applied. Grouping is enabled by uploading subject-ID lists (CSV, Excel, or plain text), which automatically creates a matched group and a complementary remainder group; if no list is provided, analyses default to the entire cohort. The application supports iterative regrouping, clearing of results, and re-analysis with new inputs. Outputs include Excel summaries and PNG visualizations for direct download. Containerization ensures reproducibility, consistency, and portability across environments, while Spark integration provides distributed, scalable processing. The solution can also be deployed on AWS (e.g., EC2 or ECS) to provide secure, scalable remote access for research teams.

pythonjavascriptkubernetes+2
Student: Tushar Jamdade
Code

Improve Styling System

beginner
Organic Maps•2023Varies90h (Small)

The currently used styling system has a number of major shortcomings: its over-complicated and full of nuances, which often leads to unpredictable behavior; the current style files structure and absence of validation tools makes it easy to do mistakes and hard to debug them / hard to notice undesired side-effects; the current inheritance mechanism doesn’t work well for “sub-styling” (adding new styles by specifying only changes over the base style). A major refactoring of the current system will speed up development of the current and planned map styles, increase their robustness and hence save time on maintenance / bug fixing, open up possibilities for perspective style enhancements. Requirements for a new better system: - predictable and easily debuggable, makes it hard to break things - style files are nice, clean and compact - promotes stylistic standards, e.g. standard font and icon sizes for various zoom levels - supports easy and efficient sub-styling - simple enough to be used by enthusiastic users, so that they could create custom styles - powerful/flexible enough to describe the styles without much repetition - future-proof, i.e. it should be easy to add support of dynamic styling, svg icons or other perspective styling features planned by the Organic Maps team As a result, Organic Maps will run on a new styling system, which includes - a new styling language syntax specification, including its documentation - current main and vehicle style files migrated into a new format - a compiler of new format style files into the binary Google protobuf format used by the rendering engine

androidjavac+++2
Student: pastk
Code
Proposal

Make it easier for contributors to choose pictures for upload on the Commons Android app

intermediate
Wikimedia Foundation•2022Varies175h (Medium)

1. At the bottom of the picker, there will be two buttons "Upload" to start the Upload Wizard with the selected pictures (replacing the already implemented ✔️ button currently available at the top-right) and "Mark as not for upload" to mark these pictures with a 🚫 overlay icon (and grey them out). For instance, family pictures are not meant to be uploaded to Commons. This state will be remembered even after restarting the app. Tapping "Not for upload" when all selected pictures are already marked as "Not for upload" has the opposite effect, a bit like pressing "Italic" twice in a text editor makes the selected text in Italic then normal. 2. Switch to hide/unhide pictures that are either marked as "Not for upload" or have been uploaded already. Hiding them allows the contributor to more easily spot pictures they might want to upload. 3. Currently, when selecting 3 pictures, they are numbered "1", "2", "3". Instead, please make all numbers always show the number of selected pictures, for instance, if 3 pictures are selected, they should all have the number "3", and be uploaded in the same order as their thumbnails are shown. 4. Add a fast scrollbar (ideally a Bubble scroll showing the date at which the pictures shown were taken). 5. UI when in full-screen mode -fullscreen starts when you long-press any picture in the custom picker 5.1. Show a small overlay indicating whether the picture is selected or not, showing the number of selected pictures. 5.2. Gestures: Left/right swipe to go from one picture to another. Swipe up to select the picture and show the next picture, skipping pictures that have either already been uploaded or ignored. Swipe down to immediately mark that picture as "Not for upload" and show the next picture.

javascripthtmlphp+7
Student: Ayan Sarkar
Code

Handwritten Text Recognition for early modern Spanish documents with Vision Language Model creation

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

This project builds an end-to-end Handwritten Text Recognition (HTR) pipeline for early modern Spanish manuscripts by placing a Vision-Language Model (VLM) at the center of every processing stage, not just as a late-stage corrector. The pipeline uses Qwen2.5-VL with LoRA-based multi-task fine-tuning across four stages: document analysis, literal reading, line-level OCR via a fine-tuned TrOCR model, and reconciliation/correction, where the VLM reconciles multiple reading sources using visual and contextual evidence. As a pre-GSoC contribution, I have built and validated this pipeline, achieving a median CER of 0.107 (~89.3% character accuracy) on the Rodrigo dataset with perfect transcription on well-preserved pages. The proposed GSoC work will transform this into a production-ready, multi-model application by abstracting the VLM backend to support multiple open-source models (Qwen2.5-VL 3B/7B/72B, InternVL), adding batch processing for multi-page manuscripts with PDF support, building a locally-run desktop application with a Gradio interface, packaging the pipeline as a pip-installable CLI tool, conducting comprehensive benchmarks and ablation studies across all model backends, releasing fine-tuned model weights on HuggingFace Hub, and providing a training pipeline for researchers to fine-tune on their own manuscript collections. The fully local execution model ensures data privacy for sensitive archival material, while the multi-model architecture allows users to select models based on their hardware constraints and accuracy requirements.

pythonmachine learningc+++2
Student: Aniket Junghare
Code

Integration of AlphaMissense Pathogenicity Predictions into Genome Nexus and cBioPortal

intermediate
cBioPortal for Cancer Genomics•2024Varies175h (Medium)

This project involves the integration of AlphaMissense, an innovative tool for predicting the pathogenicity of missense mutations, into two established platforms: Genome Nexus and cBioPortal. My Objectives and Deliverables are: - Integrate AlphaMissense pathogenicity predictions into Genome Nexus API responses, enriching genetic variant analysis with detailed pathogenicity scores. - Display AlphaMissense predictions within the Genome Nexus variant pages and add dedicated data columns in the cBioPortal mutation tables, complete with functionalities for sorting, filtering, and downloading. -Add AlphaMissense pathogenicity prediction and score into Genome Nexus annotation pipeline as two new columns in the annotation result file The project will be executed in phases, starting with initialization and planning, followed by backend and frontend development to integrate and visualize AlphaMissense data. Subsequent phases will focus on testing, deployment, and documentation, concluding with a final review and official launch. Post-launch, the project will enter a maintenance and support phase to address any arising issues and incorporate user feedback. Backend development will utilize Java and Spring Boot for integrating the AlphaMissense plugin into the Genome Nexus API. Frontend components will be developed using React and TypeScript, ensuring a dynamic and user-friendly interface for displaying genetic predictions.Comprehensive testing phases, including unit, integration, and User Acceptance Testing, will ensure the reliability and accuracy of the integration. This integration represents a significant leap forward in personalized medicine. By making pathogenicity predictions more accessible and interpretable, this project aims to support advancements in genetic research and clinical decision-making, ultimately contributing to improved patient outcomes.

javascriptjavaweb+9
Student: Ivy Zou
Code

Solve unsupported Postgres sql about alter statement for ShardingSphere Parser

advanced
Apache Software Foundation•2022Varies350h (Large)

Apache ShardingSphere is positioned as a Database Plus, and aims at building a standard layer and ecosystem above heterogeneous databases. It focuses on how to reuse existing databases and their respective upper layer, rather than creating a new database. The goal is to minimize or eliminate the challenges caused by underlying database fragmentation. ShardingSphere parser engine is the core of ShardingSphere, It helps users parse a SQL to get the AST (Abstract Syntax Tree) and visit this tree to get SQLStatement (Java Object). At present, this parser engine can handle SQLs for MySQL, PostgreSQL, SQLServer, openGauss and Oracle. However, there are still many statements that are not supported yet. Therefore this project proposes to Solve unsupported Postgres sql about alter statements for ShardingSphere parser and also proofread and optimize the grammar wherever needed. This project would require to proofread through DDLStatement.g4 to analyze existing grammars and optimize them (essential), write grammar for unsupported alter statements referring to the official PostgreSQL documentation (essential), implement visit methods for the statements (essential), add new corresponding SQL cases and expected parsed results (essential), Run SQLParserParameterizedTest and UnsupportedSQLParserParameterizedTest to make sure there are no exceptions (essential). Successful Implementation of the project will add proper support for PostgreSQL Alter Statements ensuring there are no exceptions for the following statements, ALTER OPERATOR, ALTER POLICY, ALTER PUBLICATION, ALTER ROUTINE, ALTER RULE, ALTER SCHEMA, ALTER SEQUENCE, ALTER SERVER, ALTER STATISTICS, ALTER SUBSCRIPTION, ALTER TABLE, ALTER TEXT SEARCH,ALTER TRIGGER, ALTER TYPE, ALTER VIEW. This project will significantly improve the ShardingSphere parser engine.

pythonjavascriptjava+7
Student: Everly Precia Suresh
Code

Extending Torchvision with C++ Performance Optimisations for Production-Grade Computer Vision in R

advanced
R project for statistical computing•2026Varies350h (Large)

The torchvision package in the mlverse ecosystem provides essential tools for computer vision workflows in R, including datasets, transformations, and model utilities. While the ecosystem has matured significantly, a key limitation remains in the performance of certain core operations, particularly in detection pipelines. Functions such as Non-Maximum Suppression, bounding box transformations, and proposal filtering are currently implemented at the R level, which introduces inefficiencies when working with larger inputs or real-time use cases. This project aims to address that gap by moving performance-critical components into a native C++ backend using torchvisionlib. The approach will focus on identifying the parts of the pipeline that are actual bottlenecks, implementing them in C++ with careful attention to memory usage and batching, and integrating them back into torchvision without changing the user-facing API. Rather than rewriting everything, the work will prioritise targeted optimisations that have a measurable impact on end-to-end performance. In addition to backend improvements, the project will include the implementation of at least one modern computer vision model family, such as YOLO, using the optimised components. If time permits, support for an additional model (e.g., RT-DETR) will also be explored. These models will be integrated into the existing ecosystem with consistent APIs and working examples. The main deliverables of this project are: a set of optimised C++ implementations for core detection operations, their seamless integration into torchvision, at least one fully functional model pipeline built on top of this backend, and supporting documentation and benchmarks demonstrating performance improvements. The goal is to make torchvision not just feature-complete, but efficient enough for practical, large-scale use.

cc++r+4
Student: Srishti Dutta
Code

ListView Component Update Performance Redesign, Cross-Platform Parity, a Beginner-Friendly UX system

beginner
MIT App Inventor•2026Varies90h (Small)

This project focuses on redesigning the ListView component in MIT App Inventor to address key architectural, performance, and cross-platform consistency issues. Currently, the component suffers from inefficient full adapter rebuilds, lack of a structured data model, and inconsistencies between Android and iOS implementations. These issues lead to performance overhead, unreliable behavior, and poor developer experience, especially for beginners. To solve this, the project introduces a structured, phased approach: Core Refactor (Reliability): Introduce a dedicated ListDataModel to manage items, selection state, and filtering. This eliminates full adapter reconstruction and enables efficient incremental updates. Cross-Platform Consistency (Continuity): Establish a behavioral contract and parity tracking system to systematically align Android and iOS implementations, fixing missing features, type mismatches, and runtime inconsistencies. API Expansion (Extensibility): Add block-level operations such as AddElement, RemoveElement, UpdateElement, ScrollToElement, and SelectionElements, along with full multi-select support. User Experience Improvements: Enhance the Designer with a UIBinder-based list editor, keyboard navigation, and introduce a swipeable (carousel-style) layout for modern UI interaction. Deliverables Modular ListDataModel architecture with incremental update support Eliminated full adapter rebuilds and improved performance Android–iOS feature parity with validated behavior New block-level APIs and multi-select functionality Redesigned Designer editor with improved usability Swipeable ListView layout implementation Comprehensive testing, documentation, and backward compatibility assurance This project aims to make ListView more scalable, consistent, and beginner-friendly, while establishing a maintainable foundation for future enhancements.

javagwtgoogle app engine+7
Student: Mekala Jaya Nanda Prabhas
Code

Marble Indoor Maps

beginner
KDE•2017Varies90h (Small)

<p><a href="https://play.google.com/store/apps/details?id=org.kde.marble.maps" target="_blank">Marble Maps</a> brings the highly detailed OpenStreetMap to your Android devices. It features a crisp, beautiful map with an intuitive user interface. This project is about extending it to support indoor maps (e.g. selecting and showing different levels of a building). The following are the goals to achieve from this project:</p> <ul> <li>Marble extracts <a href="https://wiki.openstreetmap.org/wiki/Simple_Indoor_Tagging" target="_blank">indoor related OSM tags</a>.</li> <li>Floor and connection elements (e.g. room, wall, door, staircase) are shown in the map. Similar to <a href="http://openlevelup.net/?lat=42.80043008955188&amp;lon=-1.6367550194263458&amp;zoom=19&amp;tiles=0&amp;level=0&amp;transcend=1&amp;unrendered=0&amp;buildings=0&amp;photos=0&amp;notes=0" target="_blank">OpenLevelUp</a>.</li> <li>User interface to select floor levels and filtering of the map view based on the active floor level.</li> <li>Automatic adjustment of the floor level user interface (hide it when there are no indoor map elements in the view,<br> select minimum/maximum floor level automatically).</li> <li>Further adjustments to the UI to make the whole experience for the end user a delightful one.</li> <li>Extend libmarblewidget with additional classes and objects to be able to support all the above mentioned points.</li> <li>Improve indoor rendering.</li> </ul>

c++qtcmake+2
Student: Mohammed Nafees
Code
Proposal

Pre- and post-sampling features to leverage flux sampling at both the strain and the community level

advanced
GeomScale•2024Varies350h (Large)

The first genome-scale models of metabolism appeared in 1999 and 2000. In the following years fundamental Microbial Systems concepts were developed such as in silico methods and algorithms to analyze their properties. Genome-scale Metabolic models (GEMs) built on genome-scale metabolic network reconstructions (GENREs) are capable of deciphering the complex interactions occurring in bacteria, through predictions of the possible mechanism underlying these interactions. dingo is a Python package that supports a variety of methods to sample from the flux space of metabolic models, based on state-of-the-art random walks and rounding methods. Aim of this project is to enhance dingo by incorporating a preprocessing class to reduce and simplify metabolic networks, by removing certain reactions and metabolites. To identify correlated reactions, i.e. the flux of one depends on the others, I will develop a post-processing function to calculate correlation metrics and compare pairwise reaction fluxes. Additionally, another function will create graphs from the correlation matrix aiming to predict metabolic pathways. In the second half of the project, I will implement approaches for building microbial communities models. Two main approaches are to be implemented: Bag of Genomes and Bag of Genes. I will develop : a new class (“dingo.Community()”) that will read and store a community model of two microbes based on the user’s approach of choice. Its output will be then used as input to the dingo.PolytopeSampler to proceed with sampling steps. Sampling in the community flux space with the different sampling methods already supported by dingo and benchmarking of the community modeling approaches against real data will be delivered. Refactoring current dingo functions to adjust the new functionality will be done too.

pythonc++r+2
Student: Sotiris Touliopoulos
Code

LED BADGE MAGIC

advanced
FOSSASIA•2025Varies350h (Large)

Project Title: Flutter Badge Magic App Mentors: Aditya, MarioB, cweitat Problem: The current Badge Magic app offers limited customization (fixed fonts/colors), lacks interactive features, and restricts users to basic animations and Bluetooth configurations. Additionally, platform-specific deployment and unresolved bugs hinder accessibility and user creativity. Solution: Revamp the Flutter-based app to deliver: Advanced Customization: Support multiple fonts (Google Fonts integration), hex-code color pickers, and 8 editable animation storage slots. Interactive Games: Integrate Snake and Tetris with swipe/tap controls optimized for LED displays. Scalability: Auto-adapt content for diverse LED badge sizes (e.g., 11x44 to 16x45 matrices). Firmware Upgrades: Enable "Bluetooth always-on" mode and power management for stable, energy-efficient connections. Multi-Platform Reach: Automate CI/CD pipelines (GitHub Actions) for Windows, Linux, macOS, and web builds. Deliverables: Feature Enhancements: Font/color picker, editable animation storage (8 slots). Mini-games (Snake, Tetris) with collision detection. Firmware updates for advanced badge configurations. Cross-Platform Support: CI/CD workflows for 5+ platforms/app stores. Testing: 10+ unit/integration tests (90% coverage). Documentation: User guides, API references, and Quick tutorials. Bug Fixes: Resolve existing issues for a polished user experience. Impact: Empower users to create vibrant, interactive LED displays effortlessly while ensuring seamless performance across devices and platforms.

pythonjavascriptandroid+7
Student: Vivek_singh3472
Code
Proposal

A Novel Implementation of Conversion Rate Metric Model in CHAOSS Software

beginner
CHAOSS•2022Varies90h (Small)

The CHAOSS community develops metrics, practices, and software for measuring open source software community health and sustainability. Augur and Grimoirelab are two powerful open source community health analytics projects supporting the CHAOSS mission. In particular, each has implementation of select metrics based on an expanding set of implementation-agnostic metric definitions associated with various focus areas. The CHAOSS Metrics Model Working group defines metric models, which integrate multiple CHAOSS metrics in a way that makes it easy for end users such as community managers to get a more comprehensive measure of an open source community. Currently, Conversion Rate can be defined as a metric or metric model. It measures the rates at which new contributors to an open source project move through the "contributor funnel" toward sustained contribution and/or community maintainership. There is no implementation of the Conversion Rate metric or metric model in CHAOSS software yet. This project aims to build a novel implementation of Conversion Rate as a metric model that is based on a minimum number of atomic metrics and has maximum reuse of existing implemented metrics as well as common metric model calculation code supporting all types of conversion rates. A simple config file based UI for entering parameters and filters by the users is all it takes to run the metric model. New metrics will be implemented first in Jupyter Notebook as reference code and can later migrate into Grimoirelab backend (for sharing with future new metric models or reports) along with data collection and enrichment extensions. The Metric Model calculation code and methods, and a common visualization interface will be also implemented in Jupyter Notebook, followed by a deployment with OpenSearch Dashboards visualization.

pythonmysqljavascript+8
Student: Mabel F
Code
Showing 3793 - 3816 of 5976 Projects
157158159160161
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal