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.
Cancer patients navigating clinical trial databases face complex search interfaces with dozens of technical filters, making it difficult to find relevant trials without medical expertise. This project builds a patient-facing clinical trial chatbot with an interactive map that removes this barrier through natural language. The system features a three-panel interface: a chat panel powered by an LLM agent that elicits patient information and matches it against the Cancer Trials Canada database, an interactive map that displays geocoded trial site locations and a summary panel that shows trial details when a pin is clicked Built using Chainlit server mounted inside FastAPI, React application with Mapbox GL for the interactive map. Trials are stored in PostgreSQL with pgvector for semantic and full-text search. An open-source LLM served via Ollama and Pydantic-AI. Multi-layered guardrails prevent off-topic or harmful responses, RAGAS for evaluation and Langfuse for observability and tracing throughout development.
Debianize is a tools that aims to automatically create debian packages from scratch from upstream source trees. As for the current version, it works for some of the packages but it is not reliable. This projects aims at making it production ready such that it can work with most of the projects. Along with that improving its reliability, coverage, integration with the broader ecosystem and other enhancements.
This project implements true end-to-end TLS pooling for pgagroal by decoupling the cryptographic state from the physical TCP socket. By implementing a clean-room TLSv1.2+ state machine using OpenSSL Memory BIOs, I will establish a Persistent Security Context that can be parked and resumed across pooled connections. Additional deliverables include a proxy-aware SCRAM-SHA-256-PLUS authentication pipeline, robust X.509 Client Certificate validation, and the decommissioning of legacy MD5 pathways to establish a modern, enterprise-grade security boundary.
This project aims to add WebAssembly support to the Wild linker. Wild linker is a high-performance Linux linker written in Rust, and supporting the WebAssembly format would expand its applicability to even more Rust development scenarios. While LLVM's wasm-ld (lld) is currently the primary linker used for WebAssembly, Wild achieves link speeds that are often several times faster than lld for ELF linking across many scenarios, including mold, which was previously considered the fastest Linux linker. Since the fundamental linking process remains largely the same when adding WebAssembly support, much of the performance-critical implementation could be reused. Achieving similar performance gains for WebAssembly would therefore significantly reduce build times for Rust projects.
EcoGrid Intelligence: AI-Driven Climate Resilience Analysis for Global Energy Infrastructure on Liquid Galaxy is an AI-driven geospatial analysis system designed to proactively identify global energy infrastructure at risk of operational failure due to severe climate events such as heatwaves, droughts, and wind anomalies. It addresses the problem of critical infrastructure and meteorological data being siloed, which prevents stakeholders from achieving a unified, spatial understanding of risk. The solution dynamically fuses live climate anomalies with global energy infrastructure maps to create an interactive analytical canvas on the Liquid Galaxy platform. The EcoGrid Intelligence system follows a layered architecture: Data Sources and Risk Assessment: Climate Data: Streams live and forecasted climate anomalies, including temperature deviations, precipitation extremes, and wind intensity, from the Open-Meteo API. Infrastructure Data: Geospatial coordinates, generation type (hydro, nuclear, solar), and operational capacity are sourced from the Global Power Plant Database. Risk Model: A deterministic model computes a Climate Vulnerability Score (CVS) by evaluating localized anomaly intensity against the plant type's operational sensitivities. AI Orchestration: Google’s Gemini models act as the system’s brain to autonomously determine region-relevant climate anomalies, trigger API calls, interpret the resulting CVS metrics, and structure the output for spatial rendering. Visualization: The results are converted into Keyhole Markup Language (KML), generating elements like Placemark, LookAt, and FlyTo for native, synchronized rendering and camera guidance on the Liquid Galaxy multi-screen rig. Outputs: Primary displays render immersive climate anomaly heatmaps and color-coded nodes indicating vulnerability levels, while secondary screens display dynamically generated HTML content and AI-driven insights.
The existing GPU profiling workflow in OpenVino, through benchmark_app connects kernels to the model layers (primitives) and reports their execution times. However, this level of abstraction is too coarse to identify kernel instruction level insights. Intel GTPin, on the other hand, provides instruction level GPU kernel metrics like clock cycle counts, but is unable to directly map such metrics to specific inference or layers. This project aims to build a GTPin-centered profiling capability within OpenVINO to identify hotspot kernels and analyze their execution characteristics. The approach involves integrating controlled GTPin profiling into the inference flow, developing a custom GTPin tool for collecting kernel-level metrics, and progressively interpreting these metrics using signals from OpenVINO performance counters, and kernel metadata. The expected deliverable is a GTPin-based profiling workflow integrated into OpenVINO, capable of identifying bottleneck kernels, providing insight into their behavior, and offering indicative optimization directions, with validation using tools such as VTune.
The std::arch in the standard library provides architecture-specific intrinsic functions, which directly map to a single machine instruction. The ultimate goal is to inline stdarch into rustc completely and archive the stdarch repository making stdarch tests reliable and maintainable inside rustc infrastructure. Which we will achieve by incrementally investigating the CI test suite of stdarch and port as much of it into rust-lang/rust. The clear set of deliverables for this project are Map stdarch CI to rustc, land x.py steps for verify + stdarch tests, enable core_arch (plain then assert_instr on Linux), port intrinsic-test in phases (host, then cross if feasible), minimal stdarch-gen checks, wire CI, document, final report.
At present, software regression testing at ATLAS is predominantly performed manually via inspection of metrics on the ATLAS project management board. This process is both time-consuming and error-prone, and it does not provide any easy way to identify potential root causes of a given decrease in software performance. To ensure reliability and robustness, it is necessary to design mechanisms which can autonomously detect anomalies and failures at scale as they occur. I will resolve these shortfalls by modifying the SPOT orchestration scripts to incorporate an automated anomaly detection pipeline which can issue alerts upon detecting anomalies. Statistical and machine learning approaches will be employed to detect anomalies, and tested, validated and verified on existing data. Additionally, I will also upgrade the performance monitoring board to provide improved at-a-glance visibility of recent anomalies to ease diagnosis and resolution.
This project aims to build a machine-learning taxon classifier for genomic classification in malaria mosquitoes, operating directly on raw sequencing reads (FASTQ files). Accurate taxonomic identification is essential for malaria vector genomics, since many Anopheles mosquitoes are morphologically indistinguishable and misclassification can lead to incorrect downstream analyses, flawed epidemiological interpretation, and suboptimal control strategies. Current approaches typically rely on genotype calls produced by variant-calling pipelines. While effective, these approaches introduce additional computational cost and complexity, and they are less convenient in settings where only raw reads are available. The goal of this project is to develop a lightweight FASTQ-based classifier that can guide a sample to the correct major taxonomic group or downstream genomic resource without requiring full genotyping or fine-scale species splitting. Rather than attempting detailed resolution within closely related complexes at the outset, the classifier will focus on robust assignment to broader taxonomic groupings or reference frameworks, such as An. gambiae, An. funestus, or An. stephensi.
Apache NuttX already supports ELF loading and shared objects, but it still lacks a practical lifecycle layer for installing, updating, versioning, and rolling back applications after the base firmware is deployed. This project will build a thin distribution helper on top of existing NuttX services instead of introducing a full package-manager ecosystem. The work will target a supported ESP32-S3 board with PSRAM and use sim for reproducible early validation. The implementation will reuse existing NuttX subsystems such as NSH, filesystems, networking, and BINFMT/ELF loading, while adding the missing pieces: local metadata, versioned application storage, direct dependency handling, staged activation, rollback, and shared-library reuse rules. The main deliverables are: reproducible ELF/shared-object validation on current mainline, a working on-device application update flow with rollback, support for reusing packaged shared libraries, documentation for sim and hardware validation, and reviewable upstream changes integrated with Makefile and CMake workflows.
This project implements a D-CAN driver for the AM335x controller on the BeagleBone Black and integrates it into the RTEMS CAN stack, addressing the current lack of CAN support for this widely used embedded platform. This enables RTEMS applications to access CAN communication through standard interfaces such as /dev/canX. The main challenge lies in bridging the mismatch between the mailbox-based D-CAN hardware architecture and the queue-based abstraction used in RTEMS. To address this, the driver will introduce a mapping layer that emulates FIFO-based reception using hardware message objects and implements a software-managed, priority-aware transmission mechanism. Synchronization will be carefully handled through IFx register access and interrupt management to ensure correctness and real-time behavior. The implementation will follow an incremental approach, starting with a minimal working driver (initialization, polling-based TX, FIFO RX), and then extending to interrupt-driven operation, improved mailbox utilization, and priority-aware scheduling. Validation will be performed on real hardware using loopback and cross-platform communication tests (RTEMS ↔ Linux). Deliverables include a fully functional and maintainable D-CAN driver integrated into RTEMS, along with documentation, test demonstrations, and validation results. This work will also serve as a reference for future CAN driver development within the RTEMS ecosystem.
DSOMM's Angular frontend currently runs on Angular 13, a version that reached end-of-life in 2023 and is eight major versions behind the latest release. This project migrates the application to Angular 21 through three workstreams: 1. An incremental version upgrade, 2. Adoption of Angular Signals to replace imperative state management, and 3. Packaging key views as Angular Elements for third-party embeddability. The migration follows Angular's official upgrade path, with tests and documentation updated at every step, leaving the codebase in a state that future contributors can build on rather than work around. #dsomm
CodeLabz is an open source tutorial platform by C2SI built on React, Redux, and Firebase. The codebase has no TypeScript, uses deprecated MUI v4 patterns, React Router v5, and lacks key features like notifications and progress tracking. I will complete the TypeScript migration of the entire frontend and Cloud Functions, upgrade React Router v5 to v6, migrate MUI v4 styling to the modern sx prop, improve UI/UX across all pages, implement organization RBAC, build a real time notification system with Pub/Sub architecture, build an interactive quiz and progress tracking system, and optimize Firestore queries by adding missing composite indexes.
Metaflow's metadata service returns unbounded JSON for every list endpoint. A single GET /runs on a production deployment returns megabytes of data the caller immediately discards. For AI agents, this is worse: a failure-diagnosis workflow generates 2,021 HTTP calls to check 1,000 tasks. This proposal adds cursor-based pagination and server-side tag filtering to the metadata service (prototyped in PRs #9 and #10, 65 tests passing), integrates pagination into the Python client SDK, and builds agent-friendly query utilities that, across five common agent workflows, collapse 11,828 API calls into 16. Server-side work is already prototyped. GSoC starts at hardening, not greenfield.
Mobile users currently lack native access to P2P protocols like hyper://, limiting the reach of decentralized web technologies. Although desktop browsers like PeerSky support these protocols, mobile platforms remain largely inaccessible without centralized gateways. To address this, this project proposes building PeerSky Mobile Browser, a React Native application for Android using Holepunch's bare-expo template, which provides the Bare runtime necessary for running Hypercore libraries that standard React Native cannot support. The project will implement native hyper:// protocol support with DHT-based peer discovery, basic HTTPS browsing via WebView, Holesail P2P tunneling through QR codes, and mDNS for offline discovery. So the core features will include secure key management using Android KeyStore, mobile-optimized UI with tab management, and comprehensive testing across Android versions. The deliverable will be a functional Android application that brings P2P browsing capabilities to mobile and extends the PeerSky ecosystem.
We seek to demonstrate the power of an open compiler stack and an open EDA stack in making contributions to software and hardware toolkits. By combining XLS and OpenROAD, we are able to test the ability of physical design to contribute to compiler design for Machine Learning acceleration. Along the way, we deliver several extensions to the XLS compiler, including several implementations of matrix multiplication and/or other ML-relevant operations. We also deliver a high level XLS-OpenROAD pipeline for future work, and for reproducibility.
Many Metasploit modules include documentation describing how to manually build vulnerable test environments. However, these setup steps are performed outside the framework and often vary between users, making exploit verification slower and less consistent. This project proposes a new Metasploit command, build_vuln, that automates the provisioning of vulnerable environments directly from within msfconsole. The command will resolve a module’s associated environment definition and launch the environment using OCI compliant container configurations. The system will support both Docker and Podman runtimes, including rootless execution, through a runtime abstraction layer that avoids tight coupling to a specific container engine. A health management component will ensure environments are ready before exploitation, while an in memory registry will track environments created during the active session and allow users to list, manage, and tear them down. The project will also introduce standardized reusable environment definitions that can be referenced by multiple modules. Selected modules that currently rely on manual Docker instructions will be refactored to use the new mechanism, and a CI integration prototype will demonstrate how these definitions can be reused for automated module verification. The final deliverables include the build_vuln command implementation, container runtime integration, standardized environment definitions, reference module refactoring, CI integration prototype, and comprehensive developer and user documentation.
The enhancements of the Auto translation module for Drupal 10 in this project include (1) individual field level translate buttons for editors to translate based on an individual field preview and accept/discard it, (2) a pluggable provider leverage of the Plugin API for swapping out the applicable translation provider (Google Translate, Deeble, or Azure) without having to make source code changes, and (3) a translation memory table to cache results that would reduce API expenditure and to ensure consistency in phrases. By the end of the GSoC, all content teams will have an effortless, reversible, and provider agnostic AI powered translation workflow that changes the nature of AI powered translation from an "batch job" to an "interactive and controlled process."
This proposal outlines modernization of Pygoat, focusing on scalability and a future-proof curriculum. The top priority is a complete structural and gamified overhaul, featuring a dynamic scoring system and a lab list updated for OWASP Top 10:2026. This is supported by a new Core API Gateway and a Dynamic Admin Control Center, which together allow for seamless, real-time monitoring of dockerized labs and centralized management of user data and security categories. A key innovation is the Plugin-Based Custom Lab Loader, allowing the community to integrate their own labs via a standardized labs.json format. To ensure long-term accessibility, the project includes a Tailwind CSS UI migration, automated CI/CD pipelines for multi-platform Docker builds, and a comprehensive MkDocs documentation hub. By bridging the gap between exploiting a vulnerability and implementing secure coding practices, these features provide a structured, professional, and engaging learning path for the new security developers.
Swarm external secrets project enables Docker Swarm services to consume secrets from external secret managers, but it still lacks several features needed for secure and production ready deployments. At present, some providers rely on older credential models, transport security can be improved, and support for newer secret backends and modern authentication workflows is limited. This project aims to close those gaps by making the plugin more secure, extensible, and operationally reliable. The proposed work will focus on adding modern identity-based authentication methods such as JWT and OIDC flows for Vault and related providers, improving TLS and mTLS support with better CA bundle handling, and strengthening secret lifecycle support such as version awareness and rotation compatibility. In parallel, the project will expand provider support by integrating additional backends such as 1Password, Doppler, and Infisical. The deliverables will include secure authentication improvements, stronger transport security, new provider implementations, improved tests and documentation, and better observability so that swarm-external-secrets becomes a more enterprise-ready secret management solution for Docker Swarm.
This project aims to bring real-time, AI-powered live translation to the eventyay-video platform. Currently, the SUSI Translator prototype works well but relies on local computer microphones and standalone scripts. To make it ready for live online events, this project will upgrade it into a fast, web-native system that works entirely in the browser. The solution captures live audio directly from the speaker's browser, immediately filtering out silence to save server costs. This speech is then streamed at high speeds to a backend server. There, AI models (Whisper and an LLM) transcribe and translate the speech. To prevent robotic or broken grammar, the AI uses a "sliding window" to remember the last few spoken sentences, ensuring translations make sense in context. Finally, the translated text is sent back to the audience's screen as smooth, easy-to-read subtitles. Key Deliverables: - A browser-based audio capture and silence-filtering module. - A high-speed server connection (WebSockets) for instant data transfer. - A context-aware AI translation pipeline that prevents grammatical errors. - A stable, flicker-free subtitle interface built directly into the eventyay-video player.
The current gate-level circuit simulator in qutip-qip utilizes a full sparse Qobj representation of each gate, expanding local gates to the Hilbert space before applying them to the state vector via matrix multiplication. This approach encounters significant memory and computational bottlenecks as the number of qubits increases. This project aims to address that limitation by refactoring the circuit simulator and adding tensor based executing via the recently added qutip.einsum. PR #225 in qutip-qip has made efforts to introduce a foundational tensor contraction approach, but it is only limited to the numpy backend and lacks support for GPU acceleration. Hence, this project aims to further implement JAX integration to the backend using qutip.einsum with JIT compilation for speedups on both CPU and GPU, As well as,to implement GPU accelerated circuit simulation using qutip-cuquantum.
The Problem: Spack’s combinatorial flexibility makes exhaustive CI testing computationally impossible. Current CI focuses almost exclusively on "leading-edge" configurations (latest packages with latest dependencies). This structurally excludes off-leading-edge scenarios where older packages meet newer, unbounded dependencies, leaving the ecosystem highly vulnerable to silent API/ABI breakages that users only discover in production. The Solution: This project introduces a Generative AI-assisted testing system to autonomously hunt for high-risk configuration breakages. The architecture treats configuration testing as a feedback-driven sequential decision-making pipeline. First, a data-driven heuristic risk model filters dependency pairs based on structural risk and historical failures. Next, an LLM acts as an iterative hypothesis generator to propose structurally diverse, high-risk abstract specs. Finally, a strict deterministic validation layer ensures mathematical correctness and bounds CI compute costs using Spack's Clingo ASP concretizer and semantic deduplication. Key Deliverables: Metadata Extraction Module: Parses package repositories to identify unbounded dependencies and analyze version gaps. Adaptive Risk Scoring Engine: Classifies package pairs into risk tiers using a multiplicative formula driven by structural signals and historical failure data. LLM Hypothesis Generator: An iterative prompt engine utilizing selective context retrieval and within-run adaptation to propose risky testing configurations. Validation Pipeline: A strict gating system utilizing spack.concretize_one() and 3-layered semantic deduplication to prevent redundant or hallucinated tests. State Management Registry: A unified SQLite database to map historical CI data, track tested configurations, and feed failure patterns back into the LLM context. Integration & Diagnostics: A working spack audit ai CLI subcommand and a heuristic log-triage pipeline.
This project investigates GPU-accelerated approaches for spatial searching and mesh intersection in CGAL, a widely used computational geometry library. These operations are fundamental to applications such as collision detection, mesh processing, and geometric querying, but are currently limited by CPU-based performance, especially for large or dense datasets. The core idea is to leverage the massive parallelism of GPUs to accelerate the broad-phase of spatial queries, where potential interacting primitive pairs are identified. These candidate pairs are then refined using CGAL’s exact geometric predicates to preserve robustness and correctness. The project will explore multiple architectural designs, including hybrid GPU–CPU pipelines, fully GPU-based approaches, and alternative spatial data structures such as bounding volume hierarchies and spatial grids. An initial exploration phase will compare these approaches across diverse input configurations (e.g., overlapping vs non-overlapping meshes) to identify the most effective design. The final outcome will be a modular and reusable GPU-accelerated spatial searching framework integrated with CGAL. Deliverables include a prototype implementation of selected GPU-based spatial data structures, a candidate pair generation system, integration with CGAL’s exact predicates, and a comprehensive benchmarking suite evaluating performance, scalability, and robustness across different workloads.