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.
This project proposes a configuration-driven web application that visualizes data completeness across GraphQL datasets using an interactive heatmap. The system dynamically fetches data from GraphQL endpoints, normalizes hierarchical structures, computes attribute-level density metrics, and renders them as a scalable heatmap using D3.js. It enables researchers and data managers to quickly identify sparsity patterns and data quality issues. The project includes a working prototype, supports dynamic schemas, and focuses on performance, usability, and extensibility.
This project enhances the 3D protein structure viewer in cBioPortal by integrating AlphaFold predicted structures alongside experimentally determined structures from PDB, expanding structural coverage for proteins lacking experimental data. I will extend the G2S backend to support AlphaFold metadata and residue mapping based on sequence alignment. The frontend will be updated to visualize both structure types and support mutation mapping and structure selection. Deliverables include backend API extensions, metadata integration and mapping, and frontend support for AlphaFold visualization.
Offline change-point detection is a widely used statistical technique for identifying structural breaks in sequential data, with applications in fields such as signal processing, finance, and bioinformatics. Traditional methods, such as prune exact linear time (Killick et al., 2012) and binary segmentation (Hocking, 2024), are unsupervised, modelling shifts in the underlying data distribution without requiring prior knowledge or labels. While effective, they cannot leverage domain knowledge when it is partially available. Weakly supervised change-point detection methods bridge this gap by incorporating small amounts of coarse, inexact, or noisy labels to guide detection. Unlike unsupervised methods, many of which are efficiently implemented with consistent interfaces in packages such as changepoint (Killick et al., 2024) and rupturesRcpp (Nguyen et al., 2025), implementations of weakly supervised approaches are fragmented across packages, with no standardised tooling or shared interface currently available. This project aims to address this gap by extending the mlr3 ecosystem (Lang et al., 2019), a modular and extensible machine learning framework in R that provides unified interfaces for model training, evaluation, and benchmarking, to support weakly supervised change-point detection. It will also establish common abstractions for tasks, learners, and evaluation protocols tailored to change-point problems within the mlr3 design. The resulting framework will be rigorously tested and benchmarked, benefiting practitioners across various fields, enabling systematic comparison across methods, and providing a foundation for future extensions.
This project aims to make contract execution easier by removing the need to write TypeScript logic for every template. Instead, it uses an LLM to understand the contract and execute it automatically. The system adds three modes—disabled, fallback, and force—so users can choose between normal typescript logic and LLM execution. It also includes proper validation and formatting to ensure correct outputs. The project will be tested on different real world templates and compared with existing logic to check accuracy and performance.
omegaUp has several Python cronjobs for rankings, badges, and recommendations that have gotten slow and hard to maintain over time. This project rewrites the inefficient SQL queries, adds proper error handling instead of bare-except blocks, brings in test coverage with pytest and moves hardcoded values into database config. The goal is to make these scripts faster, easier to debug and actually testable.
Currently, Oppia’s feedback system is disjointed. Users can only submit lesson-specific feedback through the lesson player, which does not allow for screenshots or session logs. This makes it hard for users to report issues on the platform and for developers to fix problems based on that feedback. This project aims to create a feedback system that everyone can access. Users will be able to submit both platform-level and lesson-specific feedback from any page. The system will allow for optional screenshots and capture light session logs. All feedback will be stored in one place and can be reviewed easily through an admin interface. The existing creator feedback tab and the feedback-updates page will also be redesigned to work with the new system.
Chainvoice's privacy path is completely broken Lit Protocol is defunct, which means invoice creation and rendering fail for real users. Meanwhile, StablePay hardcodes its payment logic per Djed variant, so every new variant is a mini rewrite. And even though these two products live in the same ecosystem, a merchant still has to manually match invoices to on-chain transactions because nothing connects them. I'm fixing all three. First, I'll replace the broken Lit dependency with a mentor-confirmed alternative (ECIES with an on-chain key registry is my primary proposal, but the final call gets made during bonding). Second, I'll introduce a DjedVariantRouter in StablePay so supporting Classic, Wren, or any future variant is a config change, not a code change. Third, I'll bridge Chainvoice and StablePay using invoiceId as the shared anchor when a payment settles in StablePay, the invoice in Chainvoice flips to paid automatically. On top of that I'll ship lightweight merchant analytics derived from on-chain events (no backend needed), a module refactor that cleans up the encryption/payments/analytics boundaries, and a Dockerized dev environment. If core work finishes early, I'll build a typed Chainvoice SDK so any Web3 app can embed invoice flows without forking the frontend.
DataLoom is a browser-based data wrangling workspace that enables users to upload tabular datasets, apply reversible transformations, and manage data visually without writing code, supported by a checkpoint and revert system. Currently at the MVP stage, DataLoom supports only CSV files and lacks key capabilities such as data profiling, visualization, dataset merging, and efficient column selection. This project expands DataLoom into a full data preparation platform by introducing multi-format ingestion, automated data profiling, dataset joins and concatenation, formula-based transformations, reusable pipelines, interactive visualizations, and an automated data quality engine with scoring and one-click fixes. It also adds multi-format export and downloadable reports. Key deliverables include multi-format ingestion and export, a profiling API with a reusable column selector, join and merge operations, a visualization panel, a data quality engine, a formula editor, reusable pipelines, downloadable reports, a full frontend TypeScript migration, a refactored backend, comprehensive testing, and a redesigned scalable UI. The outcome is a robust, end-to-end data preparation tool that supports the complete workflow from raw data ingestion to cleaned, analyzed, and export-ready datasets.
Currently, during an IKEv2 negotiation in Libreswan, each peer independently selects its authentication method without knowing what the other side supports, which can lead to SA establishment failures when peers are configured with multiple credentials. The goal of this project is to implement RFC 9593, which introduces the SUPPORTED_AUTH_METHODS notification to allow peers to announce their supported authentication methods during SA establishment, enabling Libreswan to adjust its authentication selection to a method both sides support. The deliverables include: New ipsec.conf configuration option. Modifications to emit and parse SUPPORTED_AUTH_METHODS notification across IKE_SA_INIT, IKE_INTERMEDIATE, and IKE_AUTH exchanges. Modifications to select the applicable authentication method based on the peer's announced capabilities. Additions to the test-suite.
This project aims to bring Ariane+OpenPiton closer to RISC-V RVA23 compliance by adding support for the Svadu extension. By enabling hardware-managed Accessed and Dirty bit updates, Svadu eliminates unnecessary software-managed page faults and improves virtual-memory efficiency. I will implement the required changes across the PTW, TLBs, LSU-side update path, and a new hardware unit, Page Table Entry Updating Engine (PUE), while building a robust verification framework based on Spike, Verilator, and handwritten assembly tests. In addition to a complete Svadu implementation, the project will deliver evaluation results, reusable verification infrastructure, and upstream-ready contributions for future RISC-V MMU-related RVA23/RVB23 extensions.
JPEG XL is an image format that allows for lossy and lossless compression, and is generally better than JPEG at this. LibreOffice currently supports many image file formats, but JPEG XL is not one of them. This project would add such support. The potential for storage savings that support for this image format would bring will mean a better experience for experienced and newer LibreOffice users alike. In addition, web browsers are increasingly supporting JPEG XL (it is available in nightly Firefox builds), so this project will also help LibreOffice users by improving compatibility.
Genomic data sharing is slowed by manually cross-checking consent and data-use language against dense GA4GH and related policy text, while generic LLMs risk hallucinated citations. This project extends GA4GH-RegBot, an open-source RAG assistant that ingests policy PDFs into a Chroma vector store with a BM25 manifest, retrieves with dense embeddings plus BM25 fused via reciprocal rank fusion, and generates structured compliance JSON with hard grounding: chunk-ID allow-list verification with automatic retries and token-overlap filtering on the LLM path. Deliverables across the GSoC period include hierarchy-aware parsing and richer metadata for GA4GH PDFs, cross-encoder re-ranking on top of the existing hybrid stack, an open-source LLM path alongside the current OpenAI integration, Streamlit and CLI updates, Ragas or TruLens-based evaluation with documented thresholds, expanded tests and CI, and polished documentation for contributors and REWS stakeholders.
VLC's Vulkan video output module is missing two features: HDR tonemapping and subtitle rendering. HDR content played on an SDR monitor appears washed out because no color mapping is applied. The project will be integrating libplacebo tonemapping into Vulkan's fragment shader, so HDR videos can be displayed correctly, by using libplacebo API to generate GLSL code at runtime, compiling it to SPIR-V using shaderc, and injecting it into the fragment shader. Also, currently, subtitles are not rendered at all in the video output module of Vulkan. The project will implement a dedicated Vulkan sub-renderer (similar to the OpenGL one) with alpha-blending enabled to upload the RGBA subtitle regions as textures, to be able to draw them over the video output in their correct positions.
This proposal combines the MLPCpp submodule and Algorithmic Differentiation (CoDi) natively in SU2 for in-solver training, allowing researcher to train their PINNs withing the exact same run instead of training them outside and injecting the weights for inferencing.
The Problem General-purpose Automatic Speech Recognition (ASR) often fails language researchers and learners because it is designed to "clean up" speech. In second-language learner data, it is critical to capture exact production, including disfluencies, attempts at pronunciation, and interjections. Current models often struggle to segment these recordings correctly or erroneously "fix" a student's grammatical and phonological errors. The Solution My proposal implements a robust, three-phase automated pipeline: - Pre-processing: I will implement noise reduction using tools like noisereduce or DeepFilterNet and utilize industry-standard VAD (Voice Activity Detection) such as Silero VAD or Pyannote.audio to segment audio into single-sentence blocks. - Transcription: Using high-fidelity models like faster-whisper, the system will capture all vocalizations with word-level timestamps. This phase focuses on preserving the learner's actual speech patterns rather than idealized grammar. - Post-processing: The pipeline will identify pauses, match transcriptions to target sentences, and use Large Language Models (LLMs) with Constrained Prompting. This allows the system to distinguish between intelligible learner errors (to be preserved) and actual [gibberish] (to be flagged). Key Deliverables - Python-based CLI Tool: An efficient command-line interface capable of transcribing raw MP3 files. - High Accuracy: A system designed to achieve >90% agreement with human transcribers. - Structured Output: Final results formatted as an Excel sheet for easy analysis by researchers and learners.
We experience video through seeing and hearing it. To make that experience as immersive as possible, I am developing audio filters that push the auditory side to its full potential. By using SRS WoW 3D effects, the filter transforms standard stereo into a wider, surround-like soundstage. Building on that, the upmixer filter intelligently expands stereo audio into 5.1 surround. It analyzes how sound is balanced between channels to reconstruct a full surround experience that was originally hidden within the stereo track. The final deliverables include working individual VLC audio filter modules, documentation and a demo.
Deploying Intel Edge AI Suites (Metro AI, Manufacturing AI, Retail AI, Robotics AI) requires users to manually configure OS images with correct drivers, dependencies, and optimizations—a multi-step process involving kernel setup, GPU/NPU driver installation, and OpenVINO configuration. This project creates a web interface for OS Image Composer that dramatically simplifies this workflow through AI-powered natural language interaction. Users describe their target workload (e.g., "smart intersection with sensor fusion" or "defect detection for manufacturing") and receive a production-ready OS image template with all required packages pre-configured. The interface features conversational template refinement using Template-Enriched RAG, visual YAML editing with real-time validation, and build progress monitoring. By abstracting the complexity of edge image configuration, this project accelerates developers' path from Edge AI Suite selection to deployment-ready custom OS images (image templates).
DebNet models the Debian archive as a graph to identify critical packages maintained by too few people. Using data from the Ultimate Debian Database (UDD), it builds a package dependency graph and a maintainer-package graph to compute practical metrics like the Bus Factor, Fragility Score, and Dependency Impact for every source package. The goal is to answer questions like "which packages would cause the most damage if their maintainer became unavailable?" and "where should new contributors focus to help the most?" The deliverable is a FastAPI backend that serves all computed metrics through a REST API with filtering by release, maintainer, and package. This includes bus factor per package, maintainer load distribution, staleness detection, and orphan risk scoring.
The 52°North Weather Routing Tool (WRT) computes fuel-optimal maritime routes but is entirely configuration-file-driven, making it inaccessible to non-developer users. This project delivers a QGIS plugin that solves this problem. A six-page guided wizard covers route setup with map-click waypoint entry, vessel parameters, weather and depth dataset upload with validation, algorithm selection, and constraint configuration - exporting a ready-to-run JSON config. A dockable weather panel renders NetCDF variables as time-animated layers with spatial subset statistics. A route visualization module displays WRT output with per-waypoint fuel consumption popups and distance calculation. An optional component runs the WRT directly from QGIS via an isolated Python venv, streaming live progress to the canvas. Deliverables: installable QGIS plugin, all four components and full documentation.
This project aims to build a complete end-to-end LiDAR perception pipeline for Automotive Grade Linux (AGL) using ROS 2 and the CARLA simulator by establishing a Hardware-in-the-Loop (HIL) architecture where CARLA generates LiDAR data on a host system, which is processed through a ROS 2-based perception pipeline and visualized on an AGL-powered Raspberry Pi via a Flutter-based HMI. The system will include a PCL-based LiDAR detection pipeline, real-time visualization interface, and a Yocto layer (meta-agl-lidar) for seamless integration into AGL builds. Deliverables include a ROS 2 perception node, Flutter HMI, RViz configuration, Yocto integration layer, and comprehensive documentation to enable reproducibility and adoption by the AGL community.
Neovim embeds a VT220/xterm terminal emulator based on libvterm, which lets us work with the terminal right inside Neovim. However, `:terminal` buffers currently lose all their content when Neovim restarts, the buffer is closed, or a session is reloaded. My proposal aims to close this gap by preserving terminal history and bringing it back when users need it.
This project aims to develop an agentic AI system for predictive maintenance of urban infrastructure using OpenVINO. The goal is to enable intelligent monitoring and decision-making by combining multimodal perception with reasoning capabilities on edge devices. The proposed solution integrates a vision-language model to detect defects (Deformation, Obstacle, Rupture, Disconnect, Misalignment, Deposition) from visual data and a language model to interpret these defects in terms of severity, risk, and maintenance priority. These components will be connected through an agentic pipeline that performs perception, reasoning, and action in a unified workflow. The system will be implemented using OpenVINO-optimized models and deployed on Intel edge hardware to ensure efficient, low-latency inference. Open datasets will be used to validate the system in realistic scenarios. Expected deliverables include: - An end-to-end agentic AI pipeline for predictive maintenance - Integration of multimodal perception and LLM-based reasoning modules - Deployment and optimization using OpenVINO on edge platforms - Benchmark results evaluating performance and system effectiveness - Comprehensive documentation and reproducible codebase
Deploying a honeypot is only half the battle; the real value lies in the intelligence we can extract from it. Currently, standard honeypot deployments leave valuable attacker logs isolated on individual virtual machines. If an instance is terminated, that threat data is gone forever, making it impossible to correlate global attack patterns or build a cohesive defensive strategy. This proposal shifts the C2SI Honeynet from a collection of isolated servers into a centralized, serverless Threat Intelligence Platform. Using Terraform and Ansible, I will build a modular framework to deploy secure, Dockerized sensor nodes across multiple cloud providers (AWS and GCP). Instead of logging locally, these edge nodes will use Fluent Bit to stream attacker telemetry in real-time to a centralized AWS S3 data lake. From there, an event-driven Python Lambda function will automatically enrich attacker IPs with global threat scores and geolocation data, making the raw attacks instantly queryable for researchers via Amazon Athena. I am not starting this project from scratch. To prove this architecture is viable and cost-effective, I have already engineered the core serverless pipeline, secured the remote Terraform state with DynamoDB locking, and built the hardened GCP modules in my preliminary Pull Requests (PR #8, #13, #14, #15, #35). Over the 350-hour GSoC period, my goal is to scale this proven foundation into a production-ready system that allows C2SI security teams to deploy a global honeynet and hunt threats with a single command.
Rocket.Chat currently uses multiple virtualization patterns across list-heavy UI surfaces, especially in core room and contextual views. This makes scrolling behavior, pagination, testing, and future maintenance less consistent, and increases the effort required to review or extend list implementations. My project will establish a shared virtualization baseline for Rocket.Chat using a reusable wrapper integrated with the existing OverlayScrollbars-based scrollbar system, then apply that baseline to a focused set of core user-facing surfaces such as Threads, Discussions, and Message Search. The implementation will build on existing Rocket.Chat frontend patterns, including TanStack Query-based pagination hooks and shared query/cache infrastructure, so the migration can be incremental rather than disruptive. The main deliverables are: a reviewed shared virtualization abstraction suitable for merge, a reusable migration pattern for flat list surfaces, migrations of selected core components, focused test coverage for the wrapper and migrated screens, and contributor documentation covering wrapper usage, pagination integration, scrollbar wiring, and testing. If time allows, I will also migrate an additional core surface such as Room Files or prepare the path for future grouped-list migrations.