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.
GCC's static analyzer (-fanalyzer) lacks C++ class hierarchy awareness, causing it to miss bugs in exception catch blocks that use base types and limiting virtual function resolution. This project implements exception subclass matching (PR119697) and improves virtual function dispatch (PR97114) by adding type hierarchy infrastructure to the analyzer.
This project develops an intelligent clustering system that groups student submissions by similar patterns, algorithmic approaches, and correctness levels. The system enables TAs to efficiently manage large-scale grading while maintaining fairness and consistency. Problem: TAs face repetitive, time-consuming grading of similar submissions with risk of inconsistency and human error, especially in large courses (100+ students). Solution: Automated clustering of submissions using hierarchical agglomerative clustering with interactive dendrogram visualization. TAs can merge/split/reject clusters, bulk apply feedback templates, and flexibly grade (bulk or individual). Key Deliverables: - Feature extraction engine (68-dim for code, 389-dim for text) - Hierarchical clustering with Ward linkage - Interactive dendrogram UI for TA manipulation - Bulk feedback application system with per-student customization - Flexible grading modes (bulk, individual, hybrid) - Comprehensive testing and documentation Expected Impact: 80-90% reduction in grading time while improving consistency and feedback quality. Time savings: 45 submissions graded in 15 minutes vs 225 minutes without clustering.
Variational quantum circuits are essential for near term quantum algorithms but designing them involves complex manual trial and error. This project solves this bottleneck by creating an automated agentic framework using Large Language Models to synthesize and optimize quantum circuits. By interacting with quantum simulators in a closed loop the AI agent will debug circuits and minimize gate depth automatically. The main deliverables include custom Orchestral AI tools for quantum simulators an iterative feedback pipeline for hyperparameter tuning and comprehensive benchmarking to uncover novel gate sequences.
LLM agents built with LangGraph and LangChain retrieve documents, call tools, and write to memory - but nothing validates what enters the model's context. A poisoned RAG document can hijack an agent's behaviour. A malicious tool parameter can exfiltrate data. A single memory write can silently alter every future response. There's no standard security layer for any of this. ACF-SDK is a Zero Trust firewall that sits between the agent and the LLM - intercepting every input across four hooks (prompt, context, tool call, memory) and enforcing policy-as-code decisions through an isolated Go sidecar. I want to take this pipeline from hardcoded ALLOW to real enforcement: upgrade the semantic scanner to catch paraphrased attacks, wire scanner signals into the real sidecar, build memory write protection with HMAC and provenance tracking, ship a Docker demo anyone can clone and run in 5 minutes, and stress-test the whole system against adversarial evasion techniques with a technical evaluation report. The foundation is already built. I've shipped 6 PRs - semantic scanner, benchmark harness, LangGraph adapter, Rego policy templates for all four hooks, audit logger, and a Go scan stage implementation. 155 tests passing. GSoC wires these components into a running system and proves they hold up under real attacks.
Implement high-throughput CCSDS telemetry packet parsing with zero-copy ring buffers for real-time deep-space mission telemetry displays.
Apache Fluss contains dormant RoaringBitmap aggregation infrastructure but the BITMAP type is trapped in UnsupportedKeyword making it inaccessible to users. This project promotes BITMAP to a first-class logical type wires it to the existing AggregationMergeEngine and implements five SQL functions via FlussCatalog. The centrepiece is a pushdown optimization in FlinkTableSource.applyAggregates() that intercepts BITMAP_OR_AGG queries and redirects them to the TabletServer native merge engine reducing network cost from O(N) to O(G). A working prototype with 4 passing unit tests is already available. Deliverables include type system bridge server-side wiring Flink connector pushdown integration tests performance benchmarks and a quickstart guide.
The goal of this project is to bring VLC’s media playing capabilities to watchOS using the newly added support from VLCKit. The watchOS app will be able to play audio files locally as a standalone app as well as sync with the iOS app to act as a remote for controlling audio playback.
When I first tried exploring open-source organizations on GitHub, I kept running into the same problem. GitHub shows great details for each repository, but almost nothing that helps you understand an organization as a whole. I had to open repo after repo just to figure out which projects were active, which languages were common, and who was actually contributing. It felt slow, manual, and frustrating. That experience led me to build OrgExplorer. OrgExplorer is a fully client-side web app that turns raw data from the GitHub REST API into clear, organization-level insights. There’s no backend, no login, and no setup. You simply enter one or more organization names and, within seconds, you can see language distribution, repository health, contributor coverage, governance risks, and activity trends. Everything is cached locally so the app feels fast and doesn’t waste API requests. Behind the scenes, OrgExplorer merges repositories and contributors from multiple organizations into a single data model. From that, it highlights practical signals like bus factor risk, cross-repo contributor coverage, dead issues, zombie pull requests, and how activity changes over time. By the end of GSoC, OrgExplorer will support multi-organization analysis, an interactive contributor–repository network graph, repository health classification, governance audits, activity trend charts, exportable reports, deep-linked views, and offline support as a Progressive Web App. Smart caching ensures it stays within GitHub’s rate limits, with optional token support for larger explorations.
This proposal aims to add a simple built in way to uninstall applications directly from the GNOME shell App Grid Right now users have to open the GNOME software app or use the terminal just to delete a application. This project solves that by adding an "Uninstall" option straight into the app's right click menu. When a user clicks it, the system will quietly tell GNOME software to remove the app in the background. To show the user that it is working, the app's icon will fade slightly and then disappear completely once the uninstallation finished. By cutting out extra steps and keeping users in their normal workflow, this feature will make managing apps much faster. This will promise to smooth out a very common task and noticeably improve the daily experience for anyone using GNOME desktop
When a Cassandra node shuts down, clients experience timeout errors because drivers cannot distinguish planned shutdown from a crash. CEP-59 introduces a GRACEFUL_DISCONNECT event in the native binary protocol that lets the server signal drivers before closing connections. My implementation uses a self-draining mechanism that hooks into the existing cleanup() callback in CQLMessageHandler — each connection closes itself when its last response flushes out, after a grace period that accounts for network-latent requests. Three conditions added to an existing callback, no new threads or timers. Deliverables: server-side four-phase shutdown (SEAL, SIGNAL, DRAIN, DEADLINE), Python driver support with DRAINING host state, configuration and observability metrics, protocol spec update, and unit/integration tests. Java driver support as a stretch goal. JIRA: CASSANDRA-21265 (7 sub-tasks).
This proposal aims to extend DIPY's image registration framework by implementing new similarity metrics, with a particular focus on Mutual Information (MI) for nonrigid registration. While MI is currently available in DIPY for affine registration, support for nonrigid registration is not yet implemented despite its importance for multimodal medical imaging. This project will design, implement, and integrate an efficient MI-based similarity metric within DIPY's existing registration pipeline, together with appropriate validation and testing.
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.