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 to build diagnostic tooling for extracting debugging information from CVMFS processes stuck in uninterruptible sleep (D-state), where standard tools like gdb, gcore, and ptrace fail due to their dependence on signal delivery. The implementation will include a core dump constructor that reads process state directly from /proc interfaces to produce GDB loadable ELF core files, a diagnostic snapshot wrapper that captures core dumps alongside system and CVMFS specific context in a single command, and a debugging cheat sheet for site administrators.
The aim is to shift omegaUp from reactive to proactive operations by building a complete monitoring and alerting system across the PHP frontend, Go services, MySQL, and Kubernetes. The project will add missing instrumentation (latency histograms, business context attributes, backend tracing), pipe Prometheus metrics into New Relic for unified alerting, and build Grafana dashboards with recording rules and longer retention. It will then define alerting policies, SLI/SLO targets, and runbooks, delivering actionable notifications and a clear operational view during contests without changing user‑facing behaviour.
This project integrates Planter, an in-network machine learning framework, into the P4Pi Raspberry Pi platform. The work includes adding a p4c-dpdk target adapter to Planter, implementing 1–2 additional ML algorithm modules, developing end-to-end example applications on a DPDK-based software switch, and packaging the result as a ready-to-use P4Pi system image with teaching-oriented documentation and tutorials.
Music Blocks students have no ownership of the projects they create. When a project is saved it lands in a MySQL database they can never see, with no version history and no guarantee it will exist next year. This project completes the migration from that aging PHP and MySQL stack to a modern system backed by GitHub and SQLite, making the transition completely invisible to students while giving every project a permanent, version-controlled home. The work happens in four phases. First, setting up the migration environment with a read-only database connection, GitHub App credentials, and a SQLite database that will power the new backend. Second, running a streaming migration pipeline that processes all 10,000+ existing Planet projects one at a time, pushing each one to GitHub as a repository with full metadata and thumbnail, while skipping duplicates using SHA-256 content hashing. Third, building the seven API endpoints the Planet frontend needs to browse, search, like, and load projects, all backed by SQLite for sub-millisecond response times. Fourth, connecting the frontend to the new backend through a single drop-in adapter file, overhauling the UI with proper modals, a clean commit history timeline, and an interactive Git onboarding walkthrough that teaches students how to save versions, go back in time, and fork projects using Music Blocks language with no Git jargon.
BeagleBoard devices currently lack support for Greybus Camera and Audio class protocols, preventing them from acting as multimedia bridges. This project implements these missing protocols within the Zephyr RTOS subsystem by mapping Greybus operations to Zephyr's native video and audio driver APIs. To guarantee reliability over constrained network transports, the architecture leverages hardware-level compression and strict buffer management. Deliverables include fully validated native_sim mock endpoints with comprehensive ztest suites, physical hardware transport validation on the BeagleConnect Freedom and BeaglePlay using optimized peripherals, and a robust set of upstream pull requests.
This project extends the Accord Project Template Playground by implementing an end-to-end, sandboxed logic execution pipeline to solve its inability to test interactive smart contract behaviors natively. By utilizing a secure Web Worker architecture, the platform will safely evaluate user-authored TypeScript logic and validate all states and requests against strict Concerto models directly in the browser. The core deliverables include an integrated Monaco-powered logic editor, an interactive contract runner UI for initialization and request handling, dynamic execution results visualization, and comprehensive multi-state contract templates. Together, these features transform the platform from a static authoring tool into a complete, interactive development workspace for smart legal contracts.
FunctionMesh is a Kubernetes-native platform that automatically breaks a polyglot monolith apart into a distributed auto-scaled function mesh. Currently, making a polyglot codebase distributed requires service boundaries to be manually defined, RPC layers to be hand-coded, and routing configurations that have nothing to do with the actual problem being solved. FunctionMesh takes a program analysis approach to solve this problem by consuming the AST, call graphs, and data flow output of the MetaCall parser to automatically determine the deployment topology, group communicating functions into co-located namespaces, detect type mismatches at build time, and create the entire RPC layer for the user without any intervention. The functions are then packaged using the Builder CLI into a self-contained unit called a FunctionImage containing MetaCall core and the correct language loader, deployed as a FunctionUnit CRD onto a Kubernetes cluster, and connected using Istio Ambient Mesh for transparent routing, mutual TLS, and autoscaling independence. The output is the FunctionMesh Operator, Builder CLI, MetaCall RPC Gateway, Client Stub Generator, Istio Integration, Function Registry, Autoscaler Policy, and complete documentation with end-to-end demo.
ArduPilot flight logs are currently analyzed manually, making it difficult to understand why crashes or unexpected behavior occur. Users have to inspect multiple signals across time, which requires experience and is not reliable for most people. A Python tool that runs locally and takes a .BIN log as input. The data is aligned across time and processed to extract signals such as attitude error, battery behavior, GPS error and other signals. Physics-based checks detect sustained issues based on flight behavior, while a Hidden Markov Model observes patterns over time to filter out short disturbances. Results are treated as reliable when both agree over a consistent duration. An LLM based agent coordinates the workflow by running the analysis steps and combining their outputs into a clear explanation, while all calculations follow rule-based logic. The analyser adapts to different firmware versions by reading parameters and detecting configuration related issues by comparing them with expected ranges from the ArduPilot codebase. It outputs what happened, when it happened, and why, along with linked telemetry evidence and possible fixes. Deliverables include a complete Copter focused diagnostic pipeline, ML integration, dynamic parameter lookup, structured output generation, and a packaged command line tool with documentation.
The existing Neural-lam probabilistic forecasting model, GraphEFM, currently exists in an isolated branch (prob_model_lam) with a monolithic ARModel class encapsulating both the training, rollout, and single-step prediction functionality in a single file. Meanwhile, PR #208 refactors the deterministic models into a clean three-layer hierarchy: ForecasterModule (Lightning training harness), Forecaster (rollout strategy), and StepPredictor (single-step prediction). The GraphEFM model cannot be merged into main until it is ported to this new hierarchy. This project ports the GraphEFM model into the new hierarchy by refactoring it into three new classes that mirror the existing separation of concerns: GraphEFMPredictor (extends StepPredictor : owns the encoder, prior, decoder, latent variable logic), EnsembleForecaster (extends Forecaster : owns the AR rollout with separate prior and encoder paths), and EnsembleForecasterModule (extends ForecasterModule : owns the ELBO training, ensemble metrics, and visualization). Key design decisions include using explicit forward() and forward_encoder_path() instead of gating on self.training (handled automatically by PyTorch Lightning), making the predictor self-contained with its own per_var_std buffer, and replacing all hardcoded constants with the datastore API introduced in PR #208. Deliverables: - All components of the encoder/decoder moved, GraphEFM predictor that fulfills the contract of StepPredictor, EnsembleForecaster with both paths tested, and end-to-end graph efM training of --model graph_efm on MEPS, along with ensemble metrics. - KL/CRPS warmup schedules, ensemble parameters defined via configuration, Zarr-based ensemble prediction saving, additional ensemble visualizations, spread maps, and spaghetti plot, checkpoint backward compatibility, and architecture documentation.
While Python Stingray is powerful for X-ray timing, its computational overhead creates a massive bottleneck for processing multi-megabyte event files. My project builds upon Stingray.jl's high-performance foundation by introducing advanced cross-spectral analysis, time lags, and energy-resolved timing tools natively in Julia. To do this It took me Long research Hours and proper Interests matching around my Idea and I Finally came up with the Idea of building structured Powerspectrum and Crossspectrum types, alongside time lag and coherence tools for mapping black hole reverberation. My deliverables also include variability-energy spectroscopy tools, multi-threaded Lomb-Scargle periodograms for unevenly-sampled data, and intuitive one-liner Makie.jl plot recipes. Everything is backed by comprehensive test suites and cross-validated against the Python Stingray package to guarantee absolute scientific accuracy.
This project aims to improve playlist management in ListenBrainz by making it easier for users to search, organize, and interact with their playlists. Currently, while some backend support exists, the user experience lacks intuitive features for managing personal playlists effectively. To address this, I plan to implement four main features. First, I will complete and enhance playlist search directly on the user playlists page. Second, I will introduce tag-based organization, allowing users to categorize and filter playlists efficiently. Third, I will add in-playlist track sorting options such as sorting by title, artist, date added, and shuffle. Finally, I will enable users to view their MusicBrainz collections as playlists and optionally save them within ListenBrainz. The project will involve backend changes such as adding new database tables and API endpoints, along with frontend integration using React to provide a smooth and consistent user experience. The final deliverables will include a fully functional playlist search feature, tag-based organization system, track sorting functionality, and MusicBrainz collection integration, along with tests and documentation for all components.
Poppler (The C++ PDF rendering library used by Okular) does not support font subsetting as of now. In simple terms, if someone creates an annotation containing content "hello" with font Cantarell then the embedded font object inside the PDF will contain mappings for a lot of characters other than 'h', 'e', 'l' and 'o'. This leads to unnecessary increase in size. This project aims to solve this problem. My approach is to implement font subsetting by:- - Parsing appearance streams and default appearance of all modified annotations/forms on save, and build a structure containing key-value pairs of (fontname, ref) and the characters to be rendered with that font. - Another class consumes this structure, uses Harfbuzz to generate subsetted fonts, and replace the old font objects with the new ones.
Alaska's Arctic coastline is eroding rapidly, and tracking these changes at scale requires automated coastline extraction from satellite imagery. Manual digitization is too slow, and the existing pipeline has several gaps: training data includes cloud-affected and artifact-contaminated pixels, the dataset covers only 2017-2019, the model underperforms near coastal bluffs and in shadowed regions, and the pipeline outputs binary raster masks rather than the GIS-ready vectorized coastlines needed for erosion modeling. To address this, I have already studied the codebase end-to-end, fixed the bugs that were preventing the pipeline from running, and replaced the baseline U-Net with an Attention ResUNet - a pretrained ResNet-34 encoder with attention-gated skip connections and a combined BCE + Dice loss - achieving a Dice score of 0.941 and IoU of 0.921 on the current dataset. During GSoC, I will close the remaining gaps: integrate PlanetLabs Usable Data Masks to exclude bad pixels from training; expand the dataset to cover 2020 onward; improve segmentation in cliff and shadow regions; investigate SWIR and elevation data as additional inputs; and produce vectorized coastline outputs with per-transect erosion rates. The result will be a pipeline that runs from raw PlanetLabs imagery to quantified shoreline change, ready to apply across Alaska.
In Rust, trait visibility currently implies implementability. If a trait is visible within a given scope, it can also be implemented in that same scope. However, we do not always want everyone to be able to implement it. To address this, the so-called “sealed trait” pattern is used, which allows a trait to be used while restricting its implementation. This is typically achieved by defining a public trait in a private module. Similarly, field visibility implies mutability. However, we do not always want readable fields to be writable as well. As a result, developers often use private fields together with public getter methods. The Restrictions RFC extends the Rust syntax to be able to explicitly restrict the implementability of traits and mutability of fields. For example, `pub(super) impl(self) trait Trait {}` means that `Trait` can be used within the parent module, while its implementation is restricted to the current module. `pub(super) struct Struct { pub mut(self) field: u8 }` means that `Struct.field` is readable within the parent module, while its mutation is restricted to the current module. These impl and mut restrictions are optional. Although the RFC was accepted in 2022, implementation efforts have stalled. Our goal for this project is to implement both impl and mut restrictions in the Rust compiler.
Maglev is OneBusAway's next-generation, high-performance Go REST API server designed to replace the legacy Java architecture. To achieve full production readiness for real-world transit agency deployments, this project focuses on four core deliverables. First, it ensures strict 1:1 API parity through automated, field-by-field output validation against the legacy server integrated directly into CI. Second, it executes a complete Go rewrite of the GTFS merge and transformer modules, creating native CLIs that enable runtime multi-feed loading directly into Maglev. Third, the project integrates the GTFS-Flex specification to support demand-responsive paratransit services, and finally, it expands the existing GTFS-RT pipeline to handle real-time structural trip modifications. Together, these enhancements will transform Maglev from a fixed-route Western transit tool into a globally deployable platform capable of serving diverse transit ecosystems across South Asia, Africa, and Latin America.
This project aims to develop a comprehensive ConnectTheDots activity for the Sugarizer platform that combines creative expression, structured learning, and strategic gameplay into a single unified experience. Currently, Sugarizer lacks an activity that integrates these three aspects. Existing tools typically focus on only one area, leaving a gap for an engaging, multi-mode activity that supports diverse learning styles for children aged 5–11. To address this, the project will implement three core modes using Vanilla JavaScript, HTML5, CSS3, and the Sugar-Web framework: Draw Mode: A free-form mode where children can draw on a dot grid with real-time feedback. Number Mode: A guided learning mode where users connect numbered dots to reveal shapes, with support for custom templates and Journal integration. Game Mode: A strategy-based territory capture game with accurate capture logic and an AI opponent using a greedy heuristic approach. The final deliverable will be a production-ready, optimized activity that runs smoothly on low-end devices and high-DPI touch screens, providing an engaging and scalable learning experience within Sugarizer.
Integration of the Faust programming language into the Godot game engine as the form of an extension (GDExtension) as well as a static version using the faust2xx model. At the end of the project, the following deliverables will be available : · Faust Godot extension available publicly for any version of Godot. · A faust2godot command line tool to compile Faust program into Godot native language statically. · A Godot demo project to show off extension capabilities and help users getting started using the extension. · Technical documentations for both the GDExtension and faust2godot as well as a user manual with examples to make the tools as intuitive as possible to use.
Optimize the React Native bridge and new architecture to improve startup times and animation framerates on lower-end Android devices. (MLH Fellowship)
SQLite is widely used in mobile, desktop, and edge applications but has no production-ready Change Data Capture connector. This project builds a Debezium source connector for SQLite that captures row-level changes by directly parsing the SQLite Write-Ahead Log (WAL) binary file by decoding B-tree leaf pages, diffing old and new page states, and producing standard Debezium change events with correct before and after values, without any application modifications. Deliverables include a deployable Kafka Connect plugin with full WAL binary parsing, initial snapshot, streaming with safe checkpoint lifecycle management, transaction metadata support, and a complete test suite with documentation.
Developing a scalable and reproducible research pipeline within SeqTrainer for bacterial DNA sequence modelling and annotation using SBOL-based datasets. The project addresses a key challenge in synthetic biology: the lack of accessible, machine learning–ready datasets and standardized workflows for genomic modelling. The primary focus is on E. coli and Gram-negative bacteria, with applications in promoter classification and sequence annotation. The work involves reproducing and benchmarking existing CNN-based baselines, followed by integrating and evaluating foundation models such as DNABERT2 and Evo 2 within structured experiment pipelines. Experiments explore challenges including overfitting and class imbalance through methods such as weighted loss functions, undersampling, learning-rate tuning, and early stopping. A major component of the project is the development of a modular and reproducible experiment framework within SeqTrainer, including configuration-driven workflows, reproducible dataset splitting, evaluation utilities, metric logging, and improved SBOL-to-dataset conversion pipelines with validation and provenance tracking. The final outcome aims to transform SeqTrainer into a more experiment-friendly framework for genomic ML research, enabling accessible, extensible, and reproducible machine learning workflows for synthetic biology researchers.
The goal of this project is to improve GreedyBear’s threat intelligence capabilities by incorporating honeypot payload files received from T-Pot. Currently, GreedyBear only receives and handles metadata such as IP addresses, ports, and credentials from Elasticsearch logs, while actual threat payloads received from honeypots remain unused and inaccessible to analysts . In this regard, this project proposes a secure end-to-end payload ingestion pipeline between T-Pot and GreedyBear. To achieve this, a FastAPI-based microservice will be deployed along with T-Pot to dynamically expose payload files and their associated metadata such as hashes and MIME types via authenticated APIs without altering existing honeypot functionality or imposing additional system overhead. On the GreedyBear end of the pipeline, a scheduled Django Q2 task will be implemented to fetch new payloads and securely store them in a quarantined environment while ensuring deduplication via cryptographic hashes and metadata indexing in PostgreSQL for easy retrieval via a REST API while imposing strict access controls to only allow authorized personnel to download payload files. Moreover, the system will also be designed to optionally share received payloads with MalwareBazaar to contribute to the threat intelligence community as well. In summary, this project aims to greatly improve GreedyBear’s threat intelligence and security analysis capabilities by not only ingesting threat indicators but also threat payloads to become a comprehensive threat intelligence platform for the organization and the entire threat intelligence community at large.
This project introduces Conjugate, an Android and iOS open-source mobile application that provides a privacy-respecting verb conjugation tool powered by Wikidata. It aims to offer a free and accessible alternative to existing solutions that are often paid or ad-driven. The application will integrate prebuilt SQLite databases to enable fast verb search, real-time autocomplete, and structured conjugation views. Development will reuse existing Scribe-Android components and adopt SwiftUI for iOS, with a focus on modular architecture and performance. Key deliverables include fully functional apps on both platforms, efficient multilingual search, a dynamic conjugation interface, and a well-tested, maintainable codebase that expands the Scribe ecosystem.
The proposal is on the project Montage which is the most used photo evaluation tool under WLM ( Wiki Loves Monuments ). The plan is mainly about adding required features and infrastructural upgrades like multi worker system or redis on the project as the amount of entries ( images ) it handles is very high and the current structure barely supports it.
The APAP MCP server currently routes every tool call through an internal HTTP loop back to its own Express server, adding unnecessary latency, making MCP handlers impossible to unit test, and discarding all HTTP error context behind generic error strings. The MCP layer has zero automated tests and no client-specific documentation beyond a basic setup guide. This project introduces a shared service layer that both MCP tools and REST routes call directly via Drizzle ORM, eliminating the HTTP round-trip. Structured error types replace generic strings with machine-readable codes and HTTP status preservation. Deliverables: 1. Shared service layer refactor with structured error types across all 8 MCP tool handlers 2. Four-tier test suite (unit, integration, contract, E2E) with 90%+ coverage enforced in GitHub Actions CI 3. Client-specific tutorials for Claude, ChatGPT, and MCP Inspector 4. Developer experience improvements: Docker Compose quickstart, Pino structured logging, /healthz endpoint, and updated CONTRIBUTING.md A working proof-of-concept implementing the core refactor with 53 tests and 98.55% statement coverage is already live at github.com/JayDS22/apap-mcp-poc.