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.
Millions of lines of open-source Verilog exist but remain verbose and hard to maintain. TL-Verilog offers a cleaner abstraction, but almost none of this codebase has been converted. This project strengthens the LLM-driven conversion pipeline in the conversion-to-TLV repository by improving error recovery, refining prompt recipes for complex Verilog patterns (FSMs, parameterized modules, arithmetic pipelines), and applying the flow to real open-source modules including RISC-V components. All conversions are formally verified using SymbiYosys and EQY, generating high-quality training data for future LLM improvement. Deliverables include a fast working failure-classification system, improved prompts.json recipes, 10+ converted and verified modules, and structured training data registered in the project repository.
This project proposes a modular, real-time gesture-to-sound mapping framework for the GestureCap system. It will enable users to translate hand gestures into expressive audio control for music and speech applications. The system introduces a mapping engine that sits between gesture recognition (via MediaPipe in Python) and sound generation (in Max/MSP). The engine will allow users to define how gestures control sound using deterministic mapping (rule-based), learned mappings (customizable, ML-based), and hybrid mappings combining the two. It will emphasize real-time performance, flexibility, user-friendliness, and reusability with mappings that can be saved/loaded as JSON files. This project will enable rapid prototyping of gesture-controlled musical instruments and other sound generation for creative as well as research-oriented objectives.
DJ software today has no reliable way to confirm that two audio files are the same specific mastering of a track. AcoustID uses only the first 120 seconds of audio for identification, returning a confidence percentage rather than a definitive match — meaning different masterings of the same recording end up grouped under the same MusicBrainz ID. This makes it impossible to safely share DJ metadata (beat grids, cue points, BPM shift points) between users. This project builds the Mixxx-side foundation for the Canonical Master Release Track (CMRT) system: a new database table storing complete Chromaprint fingerprints, an AnalyzerChromaprint pipeline step that fingerprints entire tracks, mastering duplicate detection in the library, pregap offset calculation between files of the same mastering, and scaffolding for future MusicBrainz sharing. The CMRT — the highest-quality local copy of a mastering — becomes the anchor for all shared metadata, enabling the larger DJ-Intelligence vision of exchanging accurate BPM, key, and POI data between DJs worldwide.
Webpack currently lacks a modern, automated documentation site. Existing documentation is manually maintained, lacks API reference generation, and has no automated pipeline to stay in sync with webpack's source code. This project aims to build a fully automated documentation system for webpack using TypeDoc and @node-core/doc-kit. The pipeline extracts API documentation directly from webpack's types.d.ts, generates structured markdown, and renders a complete website - including API reference, guides, loaders, plugins, and core pages like Home and Download. Key deliverables: • A complete TypeDoc theme producing doc-kit-compatible markdown. • Webpack-branded site using doc-kit's theming system (#theme/* components) that aligns webpack's documentation with the OpenJS Foundation's design standards. • Multi-version documentation support (v5, v6 and beyond). • Fully automated CI/CD pipeline that syncs with webpack releases. The overarching goal is zero manual documentation maintenance - every webpack release automatically triggers doc regeneration and deployment, keeping the documentation accurate and fresh without human intervention.
The SU2 code relies heavily on sparse linear algebra, and there is significant speed-up potential in this area through GPU-based processing. In the current implementation, the FGMRES Linear Solver GPU-offloading is being limited by frequent data copies between Host and Device. In this project, I propose to study and implement a truly GPU-native FGMRES linear solver. My idea is to refactor the code so that the largest number of operations is offloaded to the GPU for the duration of the iterative process, all while being compatible with the current level of abstraction and software logic.
Astronomical observations of protoplanetary disks often contain noise that obscures important structures such as rings and gaps that may indicate planet formation. This project proposes to develop a machine learning pipeline for denoising astronomical observations using deep learning techniques including convolutional autoencoders, U-Net architectures, and diffusion models. The project will implement a complete workflow for loading FITS datasets, preprocessing observations, training denoising models, and evaluating performance using PSNR, SSIM, and MSE metrics. The final deliverables will include a reproducible open source pipeline, trained models, and evaluation tools for improving the quality of protoplanetary disk observations.
The DU Event Board currently uses manual inputs and basic validation to manage event data. As the number of events grows, this can make it harder to maintain consistency, avoid duplicate entries, and optimize API usage. Event discovery is also primarily based on simple filters and does not yet include offline access. This project improves how event data is processed and maintained. On the backend, it extends the existing GitHub Actions workflow to automatically fetch event metadata (image and description), detect duplicates using title and date similarity, and perform geocoding only once per event by writing coordinates back to the source file. These changes prevent duplicate entries, reduce repeated API calls, and remove the need for manual data fixes. On the frontend, the project adds full-text search, map-based filtering with a time slider, relative date display, and offline support. It also introduces a guided event submission flow that creates structured GitHub Issues, making it easier for contributors to add events. Together, these changes reduce manual review work and make it easier for users to search, filter, and access events.
This project implements five concrete improvements to animint2 across the R compiler, animint.js renderer, and CI pipeline. First, polygon holes via geom_polygon(aes(subgroup)) — the JS renderer will use D3's d3.geo.path.projection(null) with fill-rule: evenodd to correctly draw multi-ring SVG paths instead of silently garbling them. Second, the CI race condition where R_coverage and JS_coverage share a hardcoded GitHub repo name will be fixed by deriving a unique repo name per job from the existing TEST_SUITE variable. Third, the inner apply() kernel of getCommonChunk() moves to C++ via Rcpp — benchmarks show 28x speedup for numeric columns and 32.5x for character columns. Fourth, scale range calculation moves from the R compiler to the JavaScript renderer — computed at click-time from visible data only, eliminating exponential blowup in plot.json. Fifth, stats and positions (stat_bin, position_stack, position_dodge) will be computed in JavaScript after showSelected is applied — fixing the silent breakage in geom_histogram and grouped bar charts. All features include renderer tests, documentation, and wiki updates. The RJSONIO → jsonlite migration will also be completed to remove a deprecated CRAN dependency.
The ScummVM Director engine supports a number of games built with Macromedia Director, but many still have bugs or missing features. This project improves the engine across four areas: (1) enhancing the ImGui visual debugger with crash fixes, missing cast detail views, and search improvements, (2) completing Filmloops and Movie Cast Members for games like TrekTech, Gus (3) fixing bugs in Gus Goes to the Kooky Carnival and The Journeyman Project, and (4) getting the screenshot regression tool working for automated visual testing on the buildbot. If these tasks finished early, I will work on other incomplete Director engine features and fix bugs.
The EBRAINS Software Distribution is a monolithic Spack environment that takes over 48 hours to build, making rapid deployment and testing difficult. This project solves this by extending the dedal tool to generate modular, lightweight dependency subgraphs that bypass heavy server-side compilation. Additionally, it standardizes a variant-based pattern to decouple backend services from their clients using Spack's concretizer rules. Core deliverables include the subset generation CLI, a Micro-ESD mock testing framework, and a standardized service compatibility template for the platform.
The MusicBrainz XML/JSON API makes you stack inc= parameters just to get related data, and looking up multiple entities of the same type in one request isn't possible at all. This project aims to build a GraphQL server in Rust to fix that properly. It covers five entity types: Artist, Release, Release Group, Recording, and Label with MBID based lookup including transparent redirect handling for merged entities, keyset cursor pagination, and field coverage matching the existing API: aliases, annotations, tags, genres, ratings, ISRCs, IPIs, and release tracklists through the correct Medium and Track chain. Artist credits are exposed as structured types rather than raw joins. DataLoaders batch database queries across all relationship resolvers to prevent N+1 problems. Depth and complexity limits reject expensive requests before they touch the database. Caching is only applied where load testing shows it actually helps, not speculatively. Deliverables include a working server with Docker setup, integration tests, a documented performance baseline, and API docs auto-generated via magidocs CLI.
Unsupervised anomaly detection models in Anomalib rely on synthetic anomalies to calibrate decision thresholds, but the current Perlin-based pipeline produces unrealistic and static anomalies, leading to unstable threshold estimation and poor generalization to real defects. This project proposes a hybrid, on-the-fly synthetic anomaly generation pipeline that combines multi-scale fractal masks with self-sourced Poisson blending to generate realistic, localized anomalies with controlled difficulty levels. By generating diverse anomalies dynamically during validation, the model can learn a stable and reliable decision threshold without requiring labeled anomaly data. The project will deliver a structured literature survey, integration of the proposed pipeline into Anomalib, and a benchmarking study comparing it with the current baseline using PyTorch and OpenVINO, focusing on threshold stability, detection performance, and CPU efficiency.
Navigating archived pages on the Wayback Machine requires significant manual effort. This project builds an experimental Chrome extension that uses Chrome's built-in Prompt API with Gemini Nano to automatically summarize archived pages and detect broken or soft-404 captures, all processed locally on the user's device for privacy. Deliverables include a working MV3 extension with page summarization, two-layer soft-404 detection using DOM signals and the CDX API, a lightweight overlay UI, and a public evaluation report.
The OpenMRS Authentication module supports powerful features like Multi-Factor Authentication and TOTP, but there is no working integration with the modern O3 frontend. When the backend issues a secondary authentication challenge, O3 has no way to handle it gracefully and will breaking the user's workflow and losing their unsaved work. My plan is to fix this on both sides. On the backend, I will update the backend to return structured JSON responses instead of legacy redirects, and expose new REST endpoints for TOTP setup and verification. On the frontend, I will update to pause and replay requests around authentication challenges, and build the React components that handle the TOTP flow that all without interrupting what the user was doing.
ArduPilot flies over a million vehicles but has never controlled a humanoid, I intend to change this. I've spent the past several weeks building an 8-DOF humanoid in Gazebo Harmonic with ArduPilot SITL already connected, with the EKF3 reading attitude at 50Hz, joints responding, and the robot standing under real physics. During GSoC I'll extend it into a real platform with stable ZMP-based walking, active arms with reach and grasp, crouch and stand functions, MAVLink navigation commands, and a PR to ArduPilot main. By the end of summer ArduPilot will be able to command a humanoid to walk somewhere and interact with objects, using the same battle-tested infrastructure that already runs drones and rovers.
The core external libraries that power Unikraft (musl, lwip, and gcc) are currently a few years out of date. This creates technical debt and prevents developers from using modern C/C++ compiler features. The project aims to solve this by updating these critical libraries to their latest versions: musl to 1.2.5, lwip to 2.2.1, and gcc to 14.2.0. To ensure this update doesn't break existing projects, I will implement Unikraft's new Microlibrary Versioning RFC. Instead of completely overwriting the old libraries, I will add the modern versions as selectable options, allowing users to toggle between the legacy and updated toolchains safely. The core technical work will involve manually rebasing Unikraft's custom patches, fixing new compilation errors, and ensuring network stability. The final deliverables for this project will be: 1). Fully updated, patched, and integrated versions of lib-musl, lib-lwip, and lib-gcc running alongside their older counterparts. 2). Verified stability for complex catalog-core applications (like SQLite, Nginx, and Redis) built using the new toolchain. 3). Documentation explaining how users can seamlessly switch their projects between the legacy and modern library versions.
This project aims to add native support for the UV Python package manager to Hermeto, enabling hermetic builds for projects using pyproject.toml and uv.lock. Currently, Hermeto only supports pip-based workflows, limiting adoption for teams using modern Python tooling. The main challenge is that UV tightly couples dependency resolution, fetching, and installation, which conflicts with Hermeto’s requirement to separate prefetching from build execution. Additionally, URL and Git dependencies must be handled in a way that works fully offline. To address this, Hermeto will directly parse uv.lock as the single source of truth and deterministically fetch all dependencies without invoking UV. An inject-files mechanism will rewrite remote sources in pyproject.toml to local paths, enabling offline installation. The project will also implement marker-based artifact and wheel selection, ensuring compatibility with the target environment, and include SBOM generation using lockfile data to improve supply chain transparency. Deliverables :- 1)A complete uv.lock parser integrated into Hermeto 2)Support for fetching: -PyPI (registry) dependencies -Git dependencies -Direct URL dependencies -Local/editable/file dependencies 3)Artifact and wheel selection logic based on marker/environment filtering 4)Implementation of the inject-files system for offline installation 5)Integration with Hermeto’s existing prefetch and build pipeline 6)SBOM generation from uv.lock data 7)Comprehensive documentation -Architecture and design decisions -User workflow and setup guide -Examples and edge case handling 8)Testing(Unit & Integration)
This project improves CloudMonkey CLI autocompletion by addressing a key limitation where enum-type parameters (such as protocol, state, and intervaltype) do not provide any value suggestions due to the absence of corresponding list APIs. While existing completion works well for commands, parameter names, and boolean values, enum parameters currently result in no suggestions, reducing usability. To solve this, the project introduces a structured allowedValues field in CloudStack’s API discovery layer, making valid parameter values machine-readable and accessible via listApis. CloudMonkey will be enhanced to consume this metadata and provide direct value suggestions, along with improvements to entity-reference completion using existing related API mappings. The deliverables include extending the CloudStack API framework, implementing enum-aware autocompletion in CloudMonkey, annotating high-impact parameters, improving entity completion reliability, and adding supporting tests and documentation. This ensures a backward-compatible, user-friendly enhancement to CLI interaction without changing existing APIs.
This project aims to add a practical mesh networking framework to ArduPilot so multiple vehicles can continue sharing telemetry and coordination data even when direct links to the ground station are lost. The proposed solution is a new ArduPilot subsystem, AP_SwarmMesh, which builds standard MAVLink peer streams, wraps them in a lightweight peer routing header for multi-hop forwarding, and exchanges them over a dedicated peer link using both a "Full" and "Lite" backend. The main deliverables are the AP_SwarmMesh library, peer packet framing and forwarding logic, bounded onboard peer state tracking, SITL validation, and hardware demonstrations showing resilient multi-vehicle communication across both backend types.
This project proposes an experimental Android-specific backend for package:webcrypto that replaces the bundled BoringSSL native library with calls to Android's built-in Java Cryptography Architecture (JCA), accessed through package:jnigen. The current BoringSSL/FFI backend ships an approximately 300-500 KB native library per ABI. A JCA backend eliminates this binary overhead entirely by using cryptographic providers already present in the Android runtime. The project will implement Dart wrappers for all Web Crypto primitives (digest, HMAC, AES-GCM/CBC/CTR, RSA, ECDSA, ECDH, HKDF, PBKDF2) behind the existing webcrypto platform interface, with full conformance testing against the BoringSSL backend. A working sample project already demonstrates the approach for P0 primitives (SHA-1/256/384/512, HMAC, AES-GCM) with statistical benchmarks across 7 Android devices showing JCA is 7-29x faster for hashing at large payloads while BoringSSL retains advantages for AES-GCM. Deliverables include the complete JCA backend on an experimental branch, a performance analysis report with binary size comparison, documentation, and a migration guide.
Pocket Paint is a drawing app currently being rewritten in Flutter. The original Android app includes advanced options like antialiasing and stroke smoothing, which help users create clean, high-quality artwork. However, these features are currently missing in the new Flutter version. This project will bridge that gap by bringing these advanced drawing capabilities to the new app. The final deliverables will include a native-matching "Advanced Options" UI menu, the integration of smoothing and antialiasing across all drawing tools (such as the Brush, Eraser, and Shapes), and ensuring that all artwork saves correctly and remains compatible with older Catrobat project files.
This project aims to improve the parallel scaling of JetReconstruction.jl, a Julia package for jet clustering in high-energy physics. While the package already shows strong serial performance, its multi-threaded behaviour has not yet been systematically measured and appears suboptimal. My plan is to first build a reproducible benchmark suite, including a FastJet C++ reference, to measure event-level parallel performance across algorithms, multiplicity ranges, and thread counts. I will then use profiling to identify the dominant bottlenecks, such as allocation overhead, garbage collection pressure, load imbalance, or memory-locality issues. Based on that evidence, I will implement targeted optimisations and validate every change against reference outputs to ensure correctness is preserved. In addition to performance improvements, this project will produce reusable benchmarking and validation infrastructure, along with practical documentation for users on how to run JetReconstruction.jl efficiently on multi-core machines. The overall goal is to make the package scale better in parallel while also giving maintainers a clear, reproducible framework for future performance work.
This project focuses on rebuilding the Jira integration to make it more reliable, faster, and easier to use. The goal is to let users create, view, update, comment, and receive real-time updates on Jira issues directly within Rocket.Chat, without needing to switch between tools. By bringing everything into one place, it helps reduce context switching and makes team collaboration smoother and more productive.
Problem: Brian2CUDA offers significant GPU acceleration for neural simulations, but its current "beta" state contains friction points that hinder widespread adoption. Key issues include unreliable Windows support due to POSIX-specific build assumptions, slow incremental compilation that often exceeds simulation time, silent GPU failures that are difficult to debug, and startup crashes related to preference file validation. Solution: This project aims to make Brian2CUDA "production-ready" by modernizing its backend infrastructure without adding heavy external dependencies. The plan involves: Stabilizing the Windows workflow by implementing a robust nmake/MSVC build path and platform-independent path handling. Optimizing compilation speed through deterministic source grouping and granular dependency tracking in generated Makefiles. Implementing a synchronized C++/Python logging system with structured CUDA error-checking to eliminate silent failures. Resolving preference validation conflicts to ensure reliable configuration loading. Deliverables: - A validated cross-platform build system supporting Windows (nmake) and Linux/macOS (Makefile). Optimized code-generation templates for faster incremental builds. A unified diagnostic logging framework. A suite of regression tests and "Getting Started" documentation for Windows users.