Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
AiiDA workflows currently require manual Python scripting. This project builds a multi-agent AI system that lets scientists interact with AiiDA through natural language. Five specialized agents handle workflow submission, configuration, diagnostics, analysis, and result queries, connected to AiiDA's Python API via MCP tools. A Validator layer prevents hallucinated parameters from reaching the compute layer. RAG-based retrieval grounds agents in AiiDA documentation. Deliverables: working multi-agent system, MCP server with 5 core tools, RAG pipeline, and architecture documentation.
MRI quality control (QC) is an essential but highly manual and repetitive process in neuroimaging research. Currently, reviewers must navigate scattered directories and mentally integrate diverse outputs, such as 3D volumes, SVG montages, and isolated metrics, to make a reliable assessment. This "hidden labor" takes significant time away from actual research, introduces variability across different raters, and results in decisions that are poorly documented and difficult to audit. This project aims to transform QC-Studio from a working prototype into a robust, Nipoppy-integrated application. The core of the solution focuses on replacing hardcoded file paths with a scalable, config-driven architecture utilizing Nipoppy's DatasetLayout API. Additionally, the project will inject essential quantitative context into the review process by building an Image Quality Metric (IQM) distribution panel. Finally, it will establish a structured "Evidence Bundle" to experimentally evaluate whether a lightweight LLM-based assistant can improve review efficiency by summarizing quantitative data and flagging anomalies. Key Deliverables: 1) Config-Driven Architecture: A unified Streamlit application featuring dynamic subject loading, unified pagination, and manifest.tsv integration across multiple processing pipelines without hardcoded paths. 2) Quantitative Evidence Layer: An interactive IQM panel that visualizes subject-level metrics against local datasets and crowdsourced reference distributions (MRIQC Web API), complete with rule-based outlier detection. 3) Experimental AI Guidance Prototype: A foundational integration displaying pre-generated, LLM-authored summary reports within the dashboard, accompanied by an evaluation report assessing factual accuracy and workflow impact.
Analyzing massive codebases like Rocket.Chat via iterative LLM agents causes context bloat, rapidly exceeding free-tier limits. This project builds a graph-native code navigator exposed as a Gemini MCP server. An offline indexer parses the full Rocket.Chat source via ts-morph, extracts a typed dependency graph (11 edge kinds, including Rocket.Chat-specific patterns like callbacks.run/add and Meteor method dispatch that break standard import analysis), and compresses function bodies into signature-only skeletons for ~4× token reduction. At query time, three composable MCP tools—search, graph, implement—let an LLM navigate by following real edges rather than ranking documents. An evaluation framework with ground-truth test cases (collected by Rocket.Chat experts and Claude) and 5 measured metrics closes the loop.
The Debian LSP Language Server currently provides only basic features — field completion, parse-error diagnostics, and simple quick fixes — leaving Debian maintainers without the rich IDE experience available in other ecosystems. This project significantly expands its capabilities across five areas identified from direct codebase exploration: clickable links and URL navigation in packaging files, richer hover documentation sourced from Debian Policy, improved completion quality with context-aware and deduplicated suggestions, consistent editor integration (with a focus on Helix), and formatting and structural editing support including folding ranges and auto-formatting. Each area will be delivered as an independent, tested pull request. The work integrates with debian-analyzer and the deb822-lossless crate to support multiple Debian control-file formats (debian/control, debian/copyright, debian/changelog, debian/watch ...) and lays the groundwork for real-time validation and go-to-definition across multi-file packaging trees.
Kubeflow Trainer V2 currently supports only TorchTune as its LLM fine-tuning backend. TorchTune stopped adding new features in July 2025, leaving Kubeflow with ~4 supported models and no support for DPO, GRPO, or other post-training methods. This project builds a pluggable multi-backend framework for Kubeflow Trainer. The first new backend is TRL (HuggingFace's fine-tuning library), adding support for SFT, DPO, GRPO, Unsloth acceleration, and multi-node DeepSpeed. The architecture includes: an LLMBackend ABC + registry in the Python SDK for config-driven backend dispatch, a LLMFrameworkHandler interface in the Go control plane (Torch plugin) for zero-touch extensibility, and entry_points-based registration so the community can add backends like LlamaFactory without upstream changes. Deliverables: TRL backend (Python SDK + Go handler), pluggable registry, runtime configs, integration tests, and documentation. All existing TorchTune workflows remain unchanged.
BMv2 currently provides only textual logs for tracing packets through a P4 pipeline, which must be parsed with brittle regex hacks and cannot be easily consumed by automated tools. This project aims to replace that with a structured, programmatic trace API — recording per-packet events such as applied tables, matched entries, and executed actions — and exposing them in a machine-readable format such as protobuf (with JSON serialization support), enabling use cases ranging from human debugging to automated test coverage measurement, test generation, and root cause analysis.
I would like to work with the Open Library team to create a plugin within the Internet Archive’s book reader app that would enable users to locally translate books and integrate the translated text to allow text-to-speech functionality for different languages. Using JavaScript and the Bergamot Translation model, this feature will parse the transparent text layer within the IA's book reader, feed the input into the translation model, and output the translated text onto the app. Using a simplified calculation of books available for lending within the Open Library catalog, this project would expand the 3 million works available in English to at least 18 million titles across the 6 different languages supported by the Bergamot project, directly contributing to the Open Library's 2025 goal of offering more with less. The primary deliverables for this project can be broken down into two major parts: implementing a translation plugin that allows users to select the source + target translation languages and intercepting the existing text-to-speech plugin to read the translated output from the Bergamot translation model. A future high-level deliverable for this project would allow volunteers to contribute their own translations for texts, which could allow higher quality translations to be provided to fellow patrons.
This project proposes an AI-powered accessibility auditing and remediation toolkit tailored for Drupal environments. It integrates automated accessibility scanners (e.g., Deque Axe API), and NLP models (such as GPT-4 or BLIP-2) to suggest intelligent alt-text and identify layout/media accessibility issues. A dynamic dashboard will be built to track scan results, remediation progress, and generate compliance documentation in formats like PDF and CSV. The system will be developed using Symfony (backend), HTML+Twig (frontend templating), and MongoDB (for storing audit results and history). Key components include API communication layers, a feedback system for rating AI suggestions, and tight workflow integration with Drupal, enabling accessibility checks before content is published. The architecture emphasizes modularity, ethical AI use, and compatibility with WCAG standards.
The Ceph project has a huge codebase, and it faces the risk of containing suboptimal code that could jeopardize storage reliability or induce performance bottlenecks or cause resource inefficiencies. Identifying and rectifying such code issues is important to maintain the integrity and efficiency of the Ceph storage system. clang-tidy, a powerful static analysis tool, offers a systematic approach to uncover critical issues within the codebase and generate comprehensive reports highlighting potential vulnerabilities. Deliverables: 1. Finding critical issues in the entire Ceph project using clang-tidy and fixing them 2. Create Jenkins pipeline for analyzing pull requests.
Dav1d has SIMD assembly code written for x86 and ARM, achieving a significant performance boost compared to the C implementations. This idea can also be applied to RISC-V. The code for DSP functions will be translated to RVV assembly for better utilization of the processor's capabilities. Intended end-results of the project: many functions from different parts of the library getting optimized, with relevant performance benchmarks performed on the Kendryte K230 board as suggested by my mentor.
pidfds are a feature of the Linux kernel that provide a process with a stable handle on another process. They were introduced to solve the problem of PID recycling. A user can send a signal to the process (pidfd_send_signal syscall), wait for the process (poll() on pidfd) using a pidfd. However, with the current implementation of CRIU, it can't checkpoint/restore a process with pidfd file descriptor(s) opened. So, the proposed project's purpose is to add new functionality to successfully checkpoint/restore any process that has opened pidfd file descriptor(s).
The project aims to provide a Python SDK API interface for users to push metrics to Katib DB directly. The current implementation of Metrics Collector is pull-based, raising design problems such as determining the frequency at which we scrape the metrics, performance issues like the overhead caused by too many sidecar containers, and restrictions on developing environments that must support sidecar containers. Thus, we decided to implement a new API for Katib Python SDK to offer users a push-based way to store metrics directly into the Kaitb DB and resolve those issues raised by pull-based metrics collection.
This project revolutionizes mobile event management for Talawa by introducing groundbreaking functionalities: volunteer management, venue designation, and agenda control. These features will be implemented directly within the mobile app, empowering event managers to organize and manage events efficiently from anywhere. Additionally, fundraising campaigns will be seamlessly integrated, allowing event managers to solicit donations directly through the app, boosting engagement and securing vital support for their causes. User tagging feature will be integrated, fostering increased engagement and streamlined workflows. This project signifies a significant leap forward in mobile event management capabilities for Talawa.
The project aims to enhance the Serverless Benchmark Suite (SeBS) by implementing multiple invocation mechanisms, complex workflows, and container deployment support offering a comprehensive evaluation of serverless architectures across major cloud platforms. This project will expand SeBS with queue and storage-based invocations, integrate standalone benchmarks across a variety of tasks, and implement real-world complex workflows such as ETL processes, machine learning inference, and training. And, extend SeBS to support container-based deployment along with zipped deployment. These enhancements are designed to provide in-depth analysis and insights into the performance and scalability of serverless platforms.
The project aims to centralize the P4 compiler (p4c) documentation by developing a new, well-structured documentation website using Doxygen for automated content generation. It will utilize GitHub Actions to automate build and update processes and introduce a PR preview system, enabling contributors and maintainers to review documentation changes before merging. These efforts will establish a clear, accessible, and organized website, making it easier for all members of the P4 community to navigate and maintain.
Canasta is a Docker-based MediaWiki distribution that simplifies the process of setting up a full-featured MediaWiki instance on virtually any server. Despite its extensive features, Canasta currently lacks support for running multiple wikis (a wiki family or wiki farm) within a single container. The aim of this project is to implement this missing functionality and enhance the Canasta command-line interface (CLI) to manage individual wikis within a wiki farm effectively.
Group chats are an integral component of instant messaging clients used in everyday communication. However, Moxxy, currently lacks support for group chats. Hence, the objective of this project is to incorporate basic group chat functionality into Moxxy by integrating MUC support (XEP-0045) into the underlying Moxxmpp library. The proposed solution aims to be highly extensible, allowing for easy integration of future feature additions. The deliverables of this project include the addition of XEP-0045 support to Moxxmpp, along with basic MUC features such as joining and leaving rooms, sending messages, and changing nicknames, among others. By implementing these features, users of Moxxy will be able to enjoy group chat functionality, which is essential for effective communication.
Currently, it’s rather bothersome to sync the Flatpak packages installed on multiple systems: One either has to manually keep them in sync or use the CLI to get a list of installed Flatpaks. As such, it would be useful to have an application that can do this for users. The go-to approach would be a D-Bus daemon that automatically (either on changes or periodically) creates a list of installed Flatpaks and pushes it to a service like GitHub Gists. If a new version is detected (which comes from a different system), the daemon would fetch it and adjust the local installation accordingly. Additionally, there should be a GUI application that can interface with the daemon for setup and configuration. A CLI application for usage independent of the DE and manual syncing would be a plus.
The project involves implementing io_uring based communication backend for network based key-value store. The current implementation in the KTLI (Kinetic transport layer interface) uses traditional sockets and POSIX APIs to communicate with the backend. io_uring offers a new kernel interface that can improve performance through zero copy network transmission capabilities and avoid the overhead of system calls.
Ampath form builder provides an interactive interface that allows OpenMRS to build schemas effortlessly. Users can create schemas using their interactive form builder or by writing JSON in the Schema editor. The current form builder is an angular JS-based module. This form builder makes creating/editing forms more effortless. But the user interface of the form builder has various unexpected bugs and user experience issues. As a solution to this problem, the Form Builder UI can be redone using React JS. By the end of this project, a React JS based Ampath Form Builder will be delivered with an improved User interface.
Wikidata is one of the largest hosts of open data. Missing or new information needs to be added by community members. Otherwise, the knowledge base will dry out and be obsolete after a while. My project's goal is to create an ecosystem that will consist of Web service interfaces to push data from different sources, s.t. researchers. The industry can easily integrate it into their systems and efficiently help to extend the Wikidata knowledge base. The impact of this will be data donations will be possible directly via different sources. The process will become easier and less time-consuming for contributors. Hence, the quality and quantity of the open data offered by Wikidata will increase. I will later try to implement a recommendation engine that suggests agreeable facts to Wikidata editors that are likely to be in their area of expertise. Also, gamification features to show appreciation to Wikidata editors, e.g., a badge Web service allowing users to integrate their score/rank into their profiles on social networks. That will be encouraging for the editors. Goals (1) Implement Webservice interfaces for data donations, i.e., sets of approvable facts (which should also contain links to evidence, etc.) (2) Implement a recommendation engine that suggests agreeable facts to Wikidata editors that are likely to be in their area of expertise. (3) Extend the gamification features to show appreciation to Wikidata editors. Example: a badge Web service allowing users to integrate their score/rank into their profiles on social networks (e.g., on Wikidata’s user page, GitHub profile, Linkedin profile) to show their dedication and activate other users. Impact (1) Data donations are possible and at the same time, an efficient approval process is supported. (2) More fact ingestions with the help of the Wikimedia community. (3) Faster integration of new facts into Wikidata.
The project aims at extracting graphs from PolyPhy simulated scalar fields. The project is part of PolyPhy, a python implementation of PolyPhorm which uses the Monte Carlo Physarum Machine (MCPM) algorithm inspired by the foraging behavior of Physarum polycephalum 'slime mold', in order to analyze intergalactic gas and dark matter filaments together known as the cosmic web. The project covers two methodologies, one using a custom graph extraction algorithm based on an agent-based approach. The second method utilizes the TTK-Paraiew Library to perform graph extraction and visualization using the Morse Smale Complex.
<p>BIDS is a standard for neuroimaging datasets that helps with data sharing and reusability; as a result it has been widely adopted by the community. Although developed for MRI originally, it has gained popularity within the EEG and MEG realms. Converting raw data to the BIDS standard is not difficult but requires a lot of time if done by hand. Currently software like mne-bids and Biscuit are available to assist and facilitate this conversion but there is still no automated way to produce a valid BIDS dataset for the EEG and MEG use-cases. Mostly what is missing is metadata. Here a python package is proposed to be able to infer the missing information from files accompanying the EEG and MEG files and/or a single bids-conversion example provided by the user. The idea of having human-readable configuration files is also explored since this would help the sharing of common conversion parameters within similar communities. If this proposal was successfully implemented then batch conversion of BIDS datasets in the EEG and MEG cases would be realized. It is hoped that this package becomes the backend of an hypothetical web application that assists this conversion of MEG-EEG datasets.</p>
<p>The Syft ecosystem allows one to write software that can compute over information you do not own on machines you do not have (total) control over. PySyft mainly allows <strong>direct computation on unseen data</strong> and generates static graphs of computation that can be deployed or scaled later.</p> <p>To do so PySyft creates an AST that maps function calls to their exact path and knows what to do with a node in the tree. AST allows remote execution, and to do so AST provides a local handler for the result of remote execution through pointer alongside generating all the permitted methods and attributes on a Pointer.</p> <p>The current implementation has integration for pandas’ DataFrame and Series, i.e, one can <strong>remotely execute methods and access attributes</strong> on objects on these classes using their pointers. This is to be <strong>further extended for all the classes and global functions in pandas</strong>.</p>