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
4718 Projects Found
Sort by

Databus Python Client: Manifest-Driven Reproducible Workflow Orchestration

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

The DBpedia Databus Python Client currently supports downloading, deploying, and deleting datasets but lacks reproducibility, workflow orchestration, and format interoperability. This project extends the client with three tightly integrated features: First, a Format and Mapping Conversion Layer (Layers 2 and 3 of the Java client pipeline) that enables on-the-fly conversion between RDF triples, RDF quads, and CSV/TSV formats using rdflib — bringing the Python client to feature parity with the Java Databus Client for the first time. Second, a structured Run Manifest System that records every operation as a fixed-format JSON-LD file using the DataID vocabulary. Manifests support replay, summary, and structured error capture — making any Databus operation fully reproducible from a single file. Third, a declarative Workflow Engine that executes multi-step pipelines defined as YAML files, with dynamic step chaining, per-step error recovery (fail, continue, retry), and automatic manifest generation for every run. Deliverables include a working --convert-format flag with 14 round-trip tests, --manifest flag on all three existing commands with manifest replay and summary commands, a databusclient workflow run command with step chaining and error recovery, five tested real-world example workflows, and full documentation — all fully backward compatible.

javascalardf+7
Student: Dhanashree Petare
Code
Proposal

Pharo Dj App With Phausto, Spec and Bloc

intermediate
Pharo Consortium•2026Varies175h (Medium)

To build a DJ application with two decks in Pharo, I will make use of three libraries: Phausto for audio file playback (at variable speed), equalization, and filtering. Spec for building a browser to visualize audio files in a folder together with their metadata, and to organize these files into playlists. Bloc for the visualization of audio waveforms and the rendering of UI widgets to control playback speed, pitch, levels, the equalizer, and filter cutoff and resonance. As a first step, Phausto will be used to load and simultaneously play two audio files, mixing them via the Phausto API. Once the audio engine is in place, a Spec application will be built to browse audio files and load them into either of the two decks. With the file browser complete, a conventional user interface will be added to control the mix between the two tracks and their equalization. The Phausto standard library will then be used to add a delay effect per deck. With the DJ application running, final polish can be applied in the form of BPM detection and track quantization, which requires implementing peak detection for audio files within Pharo. Deliverables: The Spec application with audio file browsing and audio playback will be delivered before the first evaluation. The audio visualization and UI built with Bloc will be delivered halfway between the first and final evaluations. Extra features (BPM detection and quantization) will be added and tested before the final evaluation.

smalltalkroassalpolymath+7
Student: Lucia Cardin
Code
Proposal

Functional Enhancements to Mobile Wallet for G2P Use Cases

intermediate
The Mifos Initiative•2024Varies175h (Medium)

The project focuses on the enhancement and refinement of a feature-rich and secure Mobile Wallet application tailored for Government to Person (G2P) payments, demonstrating a potent tool for fintechs and financial institutions. Originating as a Google Summer of Code initiative from 2017-2023, the project delivered the initial mobile wallet framework, evolving into a sophisticated reference application with two primary apps: PixieCollect and MifosPay, later consolidating focus on MifosPay. The developmental trajectory of the project saw significant milestones: integration with Mojaloop transaction flows, user experience enhancements, support for Kotlin, and implementation of standing instructions and merchant transactions. Further advancements include integration with Fineract CN, multi-theme support, migration to Kotlin, and a transition towards a multiplatform approach using Kotlin multi-platform. The project aims, in 2024, to finalize G2P functionalities, ensuring production-readiness, improving security, and adopting modern development practices such as Jetpack Compose and leveraging Mifos' Android SDK. It underscores a commitment to evolving into a generic wallet management system through the Mifos X framework, incorporating cutting-edge features like the latest Payment Hub EE version, a new notifications framework, and a redesigned architecture to align with the Open Wallet Foundation's principles. This ambitious endeavor promises to redefine the landscape of mobile wallets, emphasizing security, extensibility, and a seamless user experience for G2P payments and beyond.

mysqljavascriptandroid+5
Student: Pratyush Singh
Code

Goto dependency definition

intermediate
Haskell.org•2026Varies175h (Medium)

Haskell Language Server (HLS) currently supports Goto Definition only for symbols defined within a user’s project, making it difficult to inspect implementations of functions imported from external dependencies. This project extends that functionality to third-party libraries by enabling developers to navigate directly to dependency source code from within their IDE. The solution leverages .hie files generated by GHC and indexed via HieDb. During HLS startup, dependency HIE files will be discovered and indexed, allowing symbol lookups to resolve to external modules. When a user triggers goto definition on a dependency symbol, the corresponding source code will be extracted from the HIE file, written to a deterministic location, and opened in the editor. To ensure correctness, a type-level rule system will be introduced to prevent invalid rule execution on dependency files, replacing the current fragile runtime whitelist approach. The project deliverables include: rebasing and stabilizing the existing prototype (PR #3749), implementing a type-safe rule constraint system, ensuring complete rule coverage across file types, improving user experience through automated HIE file generation and indexing, enforcing read-only handling for dependency files, and exploring solutions for supporting boot libraries via prebuilt HIE artifacts. These improvements aim to deliver a robust, maintainable, and seamless dependency navigation experience in HLS.

haskellghccabal+3
Student: vidit
Code
Proposal

Flexible ASL: A Low-Code, Modular Python Library for Reproducible Arterial Spin Labeling Research

beginner
Open Science Initiative for Perfusion Imaging•2025Varies90h (Small)

Arterial Spin Labeling (ASL) is a non-invasive MRI technique that measures cerebral blood flow and supports studies on Alzheimer’s disease, stroke, and other neurological conditions. Yet existing software remains rigid, difficult to customize, and often restricted to brain-only research. Flexible ASL (PyASL) introduces a redesigned, developer- and user-friendly architecture that makes advanced ASL analysis accessible to a wider scientific community. Key innovations include: (1) Minimum programming knowledge required — run complete pipelines with more intuitive alternatives, such as YAML config, python notebook, command line interface, etc; (2) Mix & match preprocessing steps — combine algorithms from different pipelines without rewriting the code; (3) Easy plug-ins — add new preprocessing modules with minimal setup; (4) Support for integrating machine-learning models, custom statistics, and quality-control tools; (5) Extensibility beyond the brain to other organs, promoting cross-disciplinary imaging research. This system can cut integration time for new models or analysis steps by 60–80%, reduce development overhead, and foster reproducibility and cross-functional collaboration among clinical and technical teams. By bridging clinical imaging and modern AI, Flexible ASL lowers barriers for both novices and experts, helping to accelerate innovation in non-invasive perfusion imaging.

pythongithub
Student: Tongxin (Elo) Li
Code

[SUSOSP] Increasing the Reach of Open Source among High-Schoolers and Teenagers

beginner
UC OSPO•2023Varies90h (Small)

Contributing to an open-source project offers novices the opportunity to join a community of practitioners, build a technical portfolio, gain experience with industry tools and technologies, and have a real-world impact. This project seeks to invite and support broader, more diverse participation in open source by supporting early contributors – especially those who have been historically minoritised within tech. The project will aim to accomplish the following tasks: Creating content that anyone with some Open Source experience can use to help and guide other completely new students to the journey of OpenSource, GitHub, and all the relevant technologies. This step would involve creating content in the form of transcripts, markdown guides, blogs, and some video content, which would serve as instruction manuals or workshop notes. Providing a medium and a platform for all contributors to share their various OpenSource experiences and testimonials. The same can be done in textual or multimedia formats like videos and photographs. Conducting an Open Source Themed Hackathon/Scavenger Hunt: We can organise a simple scavenger hunt for students on GitHub, where they can be provided simple tasks like creating issues and commits! GitHub workflows are an excellent tool for auto-evaluation of the same. Technical documentation will also be provided on how other users can create their own hunts. Social Media Engagement: Social media is where most youngsters are these days. Thus, we should be leveraging the power of the same to get young minds acquainted with the technical and open-source world at a young age so they can consciously choose to explore it further.

pythonc/c++visualization+5
Student: Nandini Saagar
Code

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

Online Validation Tools

intermediate
Software Product Data Exchange (SPDX)•2017Varies175h (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

State-space models for squared amplitude calculation in high-energy physics

advanced
Machine Learning for Science (ML4SCI)•2025Varies350h (Large)

One of the most important physical quantities in particle physics is the cross section, or a probability that a particular process takes place in the interaction of elementary particles. Its measure provides a testable link between theory and experiment. It is obtained theoretically mainly by calculating the squared amplitude. While the calculation of amplitudes for a particular expression is trivial, mapping it to a squared amplitude is computationally expensive. Previous works demonstrated that transformer-based (vanilla and KAN-infused) models can map amplitudes to squared amplitudes substantially faster and with high accuracy. However, transformers suffer from quadratic complexity due to self-attention, making them less efficient when handling extremely long sequences. Additionally, they may struggle with structured, hierarchical dependencies that naturally arise in amplitude computations. Inspired by Classical State Space theory, State Space Sequence Models (SSMs) emerged as a promising class of architectures for sequence modelling. These models can be interpreted as a combination of RNNs and CNNs. These models have near-linear scaling with sequence length, making them effective for long-range dependencies. This project will explore using SSMs for squared amplitude calculations. There are 2 major aims of this project 1. To develop novel hybrid models that combine state-space models (SSMs) with attention mechanisms for squared amplitude calculations. 2. A systematic evaluation of already existing models and SSMs on feynman interaction datasets and their scalability with respect to dataset size, maximum sequence length etc.

pythonmachine learningc+++2
Student: Prasanth Naidu
Code

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

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

intermediate
JBoss Community•2026Varies175h (Medium)

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

androidjavaide+12
Student: Onkar Shelke
Code

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

Evaluate Gemini on an Open-Source Benchmark: OpenUI Eval

advanced
Google DeepMind•2025Varies350h (Large)

This project evaluates large language models on frontend coding and UI generation tasks by extending and integrating ideas from open-source coding benchmarks such as Multi-SWE-bench and WebDev Arena. The evaluation framework assesses coding and UI generation capabilities across various dimensions, with particular emphasis on multimodal features for frontend development. It leverages the models’ ability to generate, render, and iteratively refine solutions using visual feedback from rendered UIs, and supports multiple frontend frameworks (React, Vue, Angular, Svelte, Next.js) alongside single-file HTML tasks. The solution involves building a modular pipeline with typed configuration, provider adapters (Ollama, vLLM, OpenRouter), and a model manager; implementing multimodal evaluation loops that incorporate screenshots and structured judging; supporting iterative evaluation (allowing models to refine solutions over multiple attempts); expanding the task taxonomy with increasingly complex frontend challenges (calculators, dashboards, interactive apps, framework-based projects); and automating the entire evaluation pipeline with reproducible runs and detailed artifact logging. Deliverables include the enhanced evaluation framework with new benchmark tasks, structured outputs and reports (JSON, screenshots, summaries), automation scripts for reproducible runs, and thorough documentation. The framework provides a transparent and extensible way to compare advanced AI coding capabilities in frontend development without relying on a leaderboard, focusing instead on rigorous, reproducible benchmarking.

pythonjavascripttypescript+2
Student: @anxkhn (Anas Khan)
Code
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

Refactor the chatbot in the Speak Activity to use gen-AI

intermediate
Sugar Labs•2025Varies175h (Medium)

This project aims to modernize the Speak Activity by integrating a large language model (LLM) & small language model (SLM) to enhance the chatbot and integrate a modern TTS model to improve the voice features, making it more educational and engaging for early learners. The Speak Activity, traditionally used for promoting reading skills through synthetic speech, will be upgraded to provide a more natural and interactive experience. The primary objective is to implement an LLM-based chatbot offering improved conversational abilities and a more human-like interaction style. For the voice feature a high-quality, natural-sounding Text-to-Speech (TTS) model that accurately handles pronunciation and phonetics will be used. By fine-tuning the LLM to manage invented spelling and grammatical inaccuracies, the chatbot will offer a supportive and child-friendly interaction, guiding learners in an encouraging manner. The project will utilize Python and a fine-tuned model hosted on the cloud and accessed via an API endpoint. This design ensures compatibility and seamless integration with the existing Speak Activity, without adding extra dependencies. To support offline functionality, a lightweight, fine-tuned fallback model will be packaged with the activity. This fallback ensures continued usability even without an internet connection, albeit with slightly less accurate responses compared to the cloud-hosted model. This enhancement will make the Speak Activity a more effective and child-friendly tool, promoting better language learning through engaging and conversational interactions.

pythonjavascriptgtk++10
Student: Mebin J Thattil
Code

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

Implementation of Auto-fix recipes

beginner
checkstyle•2026Varies90h (Small)

Checkstyle plays an important role in maintaining code quality in Java projects, but many of its reported violations are small, repetitive issues that developers tend to overlook. Although these problems are easy to fix, the effort required to manually locate and resolve each one discourages developers from addressing them, resulting in inconsistent code quality and growing technical debt. This project focuses on reducing that manual overhead by extending Checkstyle’s auto-fix capabilities using OpenRewrite. The main objective is to develop auto-fix recipes targeting frequently occurring Checkstyle violations. These recipes will automatically apply safe and consistent transformations to the codebase, allowing developers to resolve issues quickly and at scale. Beyond adding new recipes, the project will improve the internal design of the auto-fix system by transitioning from a position-based approach to a marker-based approach. The current method relies heavily on fixed code positions, which can become unreliable when the code structure changes. A marker-based strategy, on the other hand, enables more stable and context-aware transformations, making the system easier to maintain and extend. All implemented recipes will follow consistent design principles, include proper test coverage, and be validated on real-world open-source projects to ensure their correctness and effectiveness in practical scenarios. Overall, this project aims to streamline the process of fixing style violations, improve developer efficiency, and strengthen Checkstyle’s ecosystem by making automated code corrections more reliable and scalable.

javaantlrxpath+1
Student: Monu Chaudhary
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

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

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

Cognitive Compute Mesh: A Unified Inference Federation & Production RAG Pipeline for MoFA

advanced
MoFA Org•2026Varies350h (Large)

The current MoFA architecture tightly couples agents to a single inference backend (e.g., OpenAI, Ollama), making switching providers, handling failures, or optimizing cost and latency difficult without modifying agent code. This project introduces the Cognitive Compute Mesh (CCM): a distributed inference layer implemented as a new mofa-gateway crate that transparently sits behind the LLMCapability interface. Instead of acting as a central gateway, CCM enables a mesh architecture, where every node (local, cloud, or edge) participates in both computation and routing. The system is built around three core components: - A typed Inference Request Protocol (IRP) that standardizes communication across all providers - An intelligent routing layer that dynamically selects backends based on latency, cost, capability, and health - A production-grade RAG pipeline with hybrid retrieval (dense + BM25), reranking, and caching CCM ensures that agents become backend-agnostic, enabling seamless failover, cost optimization, and hybrid local-cloud execution without code changes. Deliverables: - mofa-gateway crate implementing LLMPlugin - Backend SDK for integrating new inference providers - Support for OpenAI, Anthropic, Ollama, and OminiX-MLX - Distributed routing with circuit breakers and health tracking - Full RAG pipeline with vector storage support - Documentation, benchmarks, and demo showing backend-agnostic agents This project aims to establish a protocol-level abstraction for AI inference, similar to how HTTP abstracted networking enabling “write once, run anywhere” for AI agents.

pythonrust
Student: Aayank13
Code
Proposal
Showing 2713 - 2736 of 4718 Projects
112113114115116
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal
Proposal