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.
In order to streamline releases, we are planning to ensure that all critical user journeys (CUJs) on the Oppia web application are covered by acceptance tests. This is important because it will provide assurance that, on the merge of every PR, these critical user journeys still function correctly, which means that no major breakages will result if the develop branch gets deployed to production. Additionally, having a complete set of acceptance tests that are organized by CUJ makes it easier to audit whether or not a particular CUJ has been included, and it also helps developers add tests for new CUJs while still keeping the tests well-organized. This project includes: Writing acceptance tests for the as-yet-uncovered CUJs in a way that keeps the tests organized and maintainable. This might also include small updates to the acceptance test framework, e.g. extracting utility functions to enable code reuse or providing relevant functionality for a group of tests. Tightening all page utility functions to have pre/post checks (in the form of "wait" statements) and proper error messaging, so that it is easier to debug flakes. The pre-check wait ensures that the conditions are good for performing the action, and the post-check wait ensures that the action has fully completed. Deleting e2e tests whose functionality has been fully replaced by the acceptance tests.
The Tor network's anonymity guarantee depends heavily on the connectivity between relays. Partitioning in the network can significantly compromise these guarantees by limiting the possible paths available to users. During GSoC 2023, the eRPC tool was built to detect such partitions by building two-hop circuits between relays and storing the results in a Neo4j graph database, where vertices represent relay fingerprints and edges represent successful or failed circuit builds. This project aims to enhance the existing eRPC tool by developing analysis capabilities to detect, visualize, and understand network partitions. The focus will be on implementing efficient graph algorithms to identify disconnected components and communities within the Tor network. By utilizing Neo4j's Graph Data Science (GDS) library, we can apply community detection and clustering algorithms to find potential partitions in the directed graph that represents the Tor network. By the end of the project, I aim to deliver an enhanced eRPC tool with robust analysis capabilities, interactive visualizations, and comprehensive documentation. This will provide the Tor community with valuable insights into the network's connectivity patterns and help identify areas that need attention to strengthen Tor's anonymity guarantees.
The need for a new Javadoc parser has been raised repeatedly, particularly in response to persistent performance bottlenecks and maintainability concerns with the current implementation. This project introduces an ANTLR-based grammar to replace the legacy parser used in Checkstyle. The current parser has proven inefficient, difficult to extend, and prone to inaccuracies—especially as Javadoc syntax evolves. By adopting a modern grammar-based approach, we aim to significantly improve parsing performance, accuracy, and long-term maintainability. All existing Javadoc checks will be adapted to work with the new AST structure, ensuring full backward compatibility.
This proposal addresses the implementation of a scalable recurring events system for Talawa, focusing on efficient data management and association handling. Current event management in Talawa lacks support for recurring events in postgres branch, a critical feature for organization planning. The previous implementation faced scalability issues, particularly with memory consumption, transaction timeouts, and database bloat and no implementation to handle association like (action items, agenda items, attendance, etc). The proposed solution introduces a "Temporal Sliding Window with Inherited Associations" approach that: Separates recurrence patterns from event instances Uses a materialization window to pre-generate near-term events Implements an association inheritance model to minimize data duplication Employs background processing to maintain system performance
The goal of this project is to expand the Unikraft ecosystem by enabling the execution of popular applications through binary-compatibility mode. Currently, many popular applications are not supported on Unikraft, and this project will address that gap by integrating these applications into the Unikraft catalog. I will work on adding a variety of applications, such as SQLite, Mosquitto, Traefik, and others, to the Unikraft catalog. The project will also involve extending or adding new system calls to ensure proper functionality and writing automated GitHub workflow files. This project will significantly enhance Unikraft's application compatibility, making it more attractive to developers and helping grow the Unikraft community.
This project attempts to integrate DeepForest's object detection models into Large Language Models (LLMs) so that ecological images can be queried using natural language. Building on the pre-built models in DeepForest for tree, bird, and livestock detection, the system would extract structured annotations from images and convert them to an LLM-compatible format. Users can interact with an image through a queryable interface and receive proper responses based on object detection and spatial reasoning. This will involve prompt engineering, fine-tuning and experimentation with different LLMs.
BuffaLogs is a tool designed to detect anomalous login activities. However, it currently lacks real-time analysis of login data and only offers a web interface built with Django, with configuration done by directly editing configuration files. My proposed project aims to enhance BuffaLogs by developing BuffaWatch, a real-time monitoring tool that integrates seamlessly with BuffaLogs and BuffaCLI, a command-line interface tool that serves as an alternative to the web UI and allows for terminal-based configuration management. BuffaWatch will enable real-time capabilities by processing log files and providing a middleware that can be easily installed into a Python web service.
Wikimedia publishes their data dumps at dumps.wikimedia.org. Currently, these dumps are listed in HTML format, requiring manual parsing to track new releases. To automate the retrieval process, integrating the dumps into the Databus metadata knowledge graph. This will enable SPARQL queries to check for new versions of dumps, supporting DBpedia and other projects like DIEF by systematically converting them into RDF.
Antibody-Drug Conjugates (ADCs) represent a promising class of cancer therapeutics designed to selectively target cancer cells while minimizing damage to healthy cells. Unlike conventional chemotherapeutic agents, which often cause off-target effects and severe side effects, ADCs combine the specificity of monoclonal antibodies with the potency of cytotoxic payloads. This project focuses on integrating ADC research tools into DeepChem to facilitate computational exploration for researchers. My contributions include developing tutorials and implementing ADCNet, a deep learning framework tailored for ADCs, to bridge the gap between ongoing ADC research and accessible computational tools.
With the rise in popularity of AI agents, there is an increasing need for agentic benchmarks. There are 5 foundational types of AI agents that many AI agents can be classified as (Simple Reflex, Model-Based Reflex, Goal-Based, Utility-Based, and Learning Agents). Modern agentic workflows are built upon these foundational types or involve hybrids or multi-agent systems of these types. However, there is no existing benchmark that evaluates how LLMs perform generally as each agent type. Existing AI agent benchmarks are very task-specific, meaning that those wanting to choose the right LLM for agentic tasks which have not yet been benchmarked need to rely on heuristics from similar task-specific data that is available. This novel benchmark aims to evaluate agent performance on various tasks specific to each agent type in order to gauge the generalized performance of LLMs as each specific agent type. Such a benchmark will not only be useful for developers for selecting the right LLM for their agent type but also for researchers to better understand the current agentic capabilities and limitations of existing LLMs. The benchmark will also help us learn which LLMs are more versatile or specialized in agentic settings.
The Mifos X Web App is an important tool that helps provide financial services to people around the world. This project aims to make the app easier to use and more modern. We’ll finish switching it over to use a TypeScript client generated from OpenAPI, update it to the latest version of Angular, and improve the design so it’s more user-friendly. We’ll also work on better translations, accessibility for all users, and add clearer data visualizations using Apache Superset. These changes will make the app faster, more efficient, and easier for everyone to use.
This proposal aims to accelerate FreeBSD’s boot process by using the TSLOG framework to identify and target specific delays. Initial profiling revealed significant slowdowns caused by unnecessary sleep intervals in disk detection, timeouts in AT keyboard controller resets, and prolonged waiting in IPv6 configuration and the boot menu. The project will set up controlled test environments, apply targeted code modifications (including ZFS adjustments and adopting approaches from Linux), and iteratively validate improvements through repeated profiling. By systematically optimizing each boot phase while ensuring system stability, the project intends to deliver measurable reductions in boot time, ultimately benefiting the FreeBSD community through faster system reboots and a replicable methodology for future performance enhancements.
As a final-year Software Engineering student at Kyiv Polytechnic Institute, I propose transforming Rucio WebUI into a more powerful, intuitive, and sustainable platform. Drawing from my previous contributions and technical expertise, I've developed a comprehensive strategy that addresses current limitations while setting the foundation for future growth. My plan focuses on migrating to modern technologies (Next.js 15, React 19, TailwindCSS 4.x), implementing server-side rendering for improved performance, enhancing the authentication system with NextAuth.js and RBAC, and fixing critical bugs like DID slash-handling issues and non-functional replicas loading. I'll also optimize performance through advanced streaming mechanisms for large data volumes, improve architecture with a transition to NX monorepo, enhance entity management functionalities, and implement comprehensive UI/UX refinements. With substantial experience in the Rucio WebUI codebase from my previous internship and 30+ contributions to the project, I've demonstrated my commitment and technical ability to execute this comprehensive modernization plan. My current work with Next.js and NX at a startup provides me with cutting-edge expertise that I can directly apply to enhance the project's development and implementation.
DebateAI is an innovative platform designed to enhance critical thinking and communication skills through structured, AI-assisted debates. By simulating formal debate environments where users can engage with either AI or human opponents, the platform fosters meaningful discourse and self-expression. It leverages real-time communication technologies and intelligent response generation to create an engaging, educational, and socially impactful experience. The project aims to make debate practice more accessible, interactive, and scalable for learners, educators, and enthusiasts worldwide.
Healthcare data is critical for decision-making, but the FHIR (Fast Healthcare Interoperability Resources) format, while powerful, can be challenging to navigate for many users. Our project addresses this accessibility gap by creating an intuitive tabular viewer that transforms complex nested FHIR resources into easy-to-understand tables. We're developing a Python-based solution that will automatically extract and organize FHIR data into user-friendly tables, making it immediately more accessible to researchers, clinicians, and community organizations. By simplifying how people interact with health data, we remove technical barriers that often prevent valuable insights from reaching those who need them most. Our deliverables include: A Python library that converts FHIR resources to tabular format An interactive web interface for exploring and filtering the data Documentation and examples to support adoption by various user groups Integration with existing FHIR servers for seamless data access This tool will democratize access to health information by making complex data structures approachable for everyone from data scientists to community health workers. When healthcare data becomes truly accessible, it empowers better decisions and ultimately improves health outcomes in our communities.
As multimodal agents become increasingly integrated into real-world applications, ensuring their safe and reliable tool-use behavior is paramount. We introduce ATIA, a novel evaluation suite designed to systematically assess the vulnerability of tool-calling agents to adversarial inputs. ATIA focuses on crafting malicious multimodal inputs—combinations of images, text, and other modalities—that covertly manipulate an agent's decision-making process regarding external tool invocations. By simulating a variety of attack vectors, including visual prompt injections, image–text conflicts, and spurious cross-modal cues, ATIA quantifies critical metrics such as tool call correctness, unsafe tool invocation rate, and adversarial success rate. This benchmark not only exposes potential weaknesses in current multimodal agent architectures but also provides actionable insights for developing robust, safe, and aligned systems. ATIA aims to serve as a reproducible and extensible framework, driving forward research in adversarial robustness and security for next-generation AI agents.
This project aims to implement a Quantum Generative Adversarial Network (QGAN) using the Pennylane framework to explore the advantages of quantum machine learning in High Energy Physics. By leveraging entangling quantum circuits and variational optimization, the QGAN will be trained to model complex data distributions. The project will include a direct comparison between classical GANs and QGANs on identical tasks, evaluating performance through training speed, sample quality, and robustness to mode collapse. Deliverables include a fully functional QGAN model, benchmarking reports, noise sensitivity analysis, and an open-source code repository with documentation.
SQLancer is a tool to automatically test Database Management Systems (DBMSs) in order to find bugs in their implementation. That is, it finds bugs in the code of the DBMS implementation, rather than in queries written by the user. SQLancer has found hundreds of bugs in mature and widely-known DBMSs. DQE is a method for systematically detecting logical errors in UPDATE and DELETE queries. Integrating Published Testing Approaches into SQLancer makes up for the limitation of existing tools (such as PQS, NoREC, TLP) that only target SELECT queries, and significantly improves SQLancer's vulnerability detection capabilities.
This proposal aims to develop the Gemma LLM Garage, a full-stack interface to manage datasets and fine-tune Gemma models. Its main goal is to abstract the technical complexity from the end user, empowering anyone with a computer to fine-tune their models. So far, I have implemented basic features such as fine-tuning with LoRA, a mechanism for uploading datasets, simple data augmentation options, a live loss graph, and a simple inference platform to test the fine-tuned model. The main deliverables are implementing data cleaning strategies, improving the data augmentation options, implementing a testing workbench for the fine-tuned models, and supporting alternative fine-tuning methods (e.g. QLoRA). The project prototype is currently deployed through Google Cloud and can be accessed here: https://gemma-garage.web.app/ A quick video demo is available here: https://drive.google.com/file/d/1Knt9a16NfJTUX5rddte_SHcMDKCzA8NS/view
Blender is an industry leading open-source 3D modelling and animation software. MDAnalysis is an open-source Python library for analyzing molecuar dynamics (MD) trajectories across multiple formats. MDAnalysis has a basic interface with Blender through a popular extension called Molecular Nodes which allows importing MDAnalysis universes and provides advanced rendering capabilities through a GUI. The ability to script and support advanced visualizations of MDAnalysis results is currently lacking. This project attempts to define, prototype and implement various APIs along with an integrated GUI within Blender that will together provide advanced visualization capabilities for MDAnalysis.
This project focuses on enumeartion of k shotest simple paths. This problem has practical applications in various networks, such as road and transporation networks. Thus, solving this problem practically as fast as possible is essential. There are several algorithms to achieve the current best order of time complexity in research field, but in practice one of them is faster than others depending on an input graph or the amount of memory used. The goal of this project is to implement a unified function of these algorithms. It will help Sage users to choose a suitable algorithm in each scenario. This project also aims to extend the cycle enumeartion method in directed graphs currently implemented in Sage to undirected or weighted graphs.
In this project, we look forward to developing Edge-Focused Deep Research AI Agents that operate fully on edge devices using open-source Large Language Models (LLMs) and Small Language Models (SLMs). Building on last year’s openSUSE GSoC project in edge analytics and Retrieval-Augmented Generation (RAG) pipelines, we will create a privacy-first AI research assistant. The agent will leverage Ollama to run LLMs locally, ensuring no sensitive data or queries are sent to the cloud. It will iteratively search and analyze information, combine local knowledge base queries with optional web search, and produce comprehensive markdown reports with citations. Deployment will utilize the SUSE stack (openSUSE Leap as base layer operating system, SUSE Rancher, K3s, Longhorn, and SLE BCI containers) to orchestrate the solution on resource-constrained edge environments. This project aims to deliver a fully open-source research agent that empowers domains like document Q&A, local knowledge bases, and on-site research, all while maintaining data privacy and leveraging openSUSE Leap as base layer operating system for containerization.
This project aims to develop a robust, secure, and extensible Drupal module that integrates with Appwrite, an open-source backend-as-a-service (BaaS). The module will enable seamless support for Appwrite’s authentication, file storage, and database APIs within Drupal’s architecture. By bridging these platforms, the module will empower developers to build dynamic, serverless applications while leveraging Drupal’s powerful CMS capabilities. The project will prioritize modularity, configurability, and maintainability, ensuring that it aligns with both Appwrite’s evolving API surface and Drupal’s best practices. Project Goals: Develop a Drupal module that connects with Appwrite’s OAuth-based authentication system (supporting providers like Google, GitHub, Apple, etc.). Enable media file management by integrating with Appwrite's object storage APIs, reducing the dependency on traditional cloud storage solutions. Integrate Appwrite’s document database to store and retrieve structured Drupal content efficiently. Create an intuitive configuration interface within Drupal for managing all Appwrite-related settings.
The project aims to bring the Prometheus Agent's DaemonSet mode in Prometheus Operator to full production readiness. This involves addressing missing functionalities, improving configuration validation, enhancing reliability, and providing comprehensive documentation. The ultimate goal is to offer a scalable, efficient, and fully supported way to run Prometheus Agent across Kubernetes nodes. This is achieved by integrating remaining features like using CEL for CRD validation to provide immediate feedback along with adding runtime checks as a fallback for older Kubernetes versions. Furthermore, Investigating and potentially implementing EndpointSlice for scalability and extending integration tests to multi-node Kind clusters. Finally, adding detailed documentation and example manifests.