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 aims to modernize the LLVM Integrated Tester (lit) to improve its execution speed and long-term maintainability. Performance is currently hindered by synchronous subprocess management and the high OS-level overhead of launching separate processes for routine commands. To address this, the execution engine will transition to a non-blocking, asynchronous model using asyncio, and core built-ins like cat and diff will be moved in-process to eliminate redundant interpreter startups. Additionally, the project will resolve functional limitations in internal shell utilities and leverage Scalene for data-driven performance profiling. Deliverables include a modernized Python 3 codebase, an asynchronous execution engine, integrated in-process built-ins, and a comprehensive performance evaluation report.
MusicBrainz contains data about upcoming and past events. This data is not surfaced, nor available to ListenBrainz users in any way. This data should be utilized in ListenBrainz to provide it's users with an easy way to discover events. This will be achieved by copying over, and caching the event data from MusicBrainz in a suitable format, and creating endpoints, as well as adequate frontend to display this information. The user should be able to discover events, gather event data from ListenBrainz itself, and find events relevant to them based on their preferred artists.
This proposal aims to implement three deep learning-based causal discovery algorithms in pgmpy: DiffAN, GraN-DAG, and CAREFL. Each algorithm leverages neural networks to go beyond classical score-based or constraint-based methods, enabling discovery on non-linear, non-Gaussian data. All three will be implemented inside pgmpy/causal discovery to isolate the soft dependencies (PyTorch, diffusers, nflows) from the rest of the library.
During late-night beam tests, physicists must leave detector halls to find workstations with Qt installed just to check satellite status. This project creates a browser-based interface that lets researchers monitor and control Constellation experiments from any device on the lab network without installing software. The project delivers three components: (1) upstream contributions to Constellation's Python API adding callback mechanisms for satellite state changes and discovery events, plus porting C++ topic management classes to Python; (2) a WebSocket bridge wrapping ScriptableController and MonitoringListener via multiple inheritance to expose satellite control and monitoring to browsers; (3) a SvelteKit frontend implementing the full satellite state machine for real-time control and monitoring. I have verified the multiple inheritance approach through hands-on testing. Discovery, commands, heartbeat state tracking, and CMDP log callbacks all work through a single combined class. I also created a custom satellite and controlled it through the complete FSM cycle. Deliverables include merged upstream MRs for callback APIs and topic management, a working WebSocket bridge with callback-driven state updates, a browser dashboard with state visualization and command controls, a log viewer mirroring Observatory's subscription model, comprehensive documentation, and tests.
This project aims to extend Rizin's OOP binary analysis capabilities across multiple languages. It completes support for Objective-C and Swift binaries, and introduces support for Rust and Java, focusing on vtable detection, devirtualization, and inheritance graph reconstruction. It also adds Windows Structured Exception Handling for both x86 and x64. Demanglers for Swift and D will be integrated into rz-libdemangle.
This project improves Manifold’s CI and benchmarking by adding missing determinism, sanitizer, and performance regression checks. I will implement a required cross-platform determinism check (Linux/macOS/Windows), add a dedicated ASan+UBSan CI lane for a curated `manifold_test` subset, and introduce PR benchmark regression checks (`base` vs `head`) with non-blocking warnings. I will also add a scheduled benchmark pipeline that publishes versioned history and define a noise-control policy so results stay reliable. The final deliverable includes an interactive benchmark dashboard that visualizes trends and regressions over time using the published benchmark data.
This project's goal is to enhance the usability and accessibility of GNU Aris. It addresses the issues that students currently struggle with when using Aris and implements their requested features: - Detailed and helpful error messages - Full internationalization (i18n) support. - An exclusive disjunction operator and an option to use the the rule of inference for a proof by contrapositive. - UI/UX enhancements: Zoom functionality, an in-application help/documentation, syntax highlighting, etc.
Ensembl VEP's web interface offers dozens of configuration options for variant annotation, overwhelming new users and generating recurring helpdesk queries. Ask VEPai is a locally-hosted, open-source AI assistant that translates natural-language descriptions into recommended VEP configurations with justifications. The system uses Retrieval-Augmented Generation (RAG) grounded in a curated knowledge base, with a deterministic constraint checker that catches species violations and option conflicts the model misses. Beyond the project brief's scope of option labelling, training data, and a prototype model, this proposal adds four components: (1) the constraint checker, empirically validated across three model sizes, (2) a quantitative evaluation framework with leave-one-out methodology and multi-run statistical replication, (3) a structured JSON schema mapping recommendations directly to VEP web form sections for "click to apply" integration, and (4) an interpretability layer where every recommendation includes a source citation traceable to the knowledge base. A working demo validated across Qwen 2.5 3B/7B/14B shows +19–30% Enable F1 from the knowledge base, with all code and results published. Core deliverables: expanded KB (~55 options), 15–20 gold-standard examples, RAG pipeline, constraint checker, JSON schema, evaluation report, and documentation. My availability (~400 hours) supports extending to a 350-hour Large project, adding QLoRA fine-tuning, attribution testing, FastAPI wrapper, and VEP output explainer.
This project aims to improve and stabilize the racoon2 IKE daemon in NetBSD, which currently suffers from issues related to Security Association handling, connection management, NAT traversal, and lack of IPv6 support. The work will focus on fixing bugs, completing missing functionality, and ensuring correct behavior according to modern standards. Key improvements include reliable SA lifecycle management, proper connection termination, enhanced NAT-T support, IPv6 integration, and better configuration handling. The final deliverables will include a more stable and secure IKE daemon, implemented fixes for core networking components, improved tooling, comprehensive testing, and clear documentation for maintainability and future development.
NetBSD is capable of running binaries compiled for Linux through a thin in-kernel translation layer, the Compat Linux. Currently, the Linux emulation is not covered by the NetBSD test suite, this project aims to target that area, focusing on testing the syscalls emulations. To achieve this, the syscalls tests from the Linux Test Project will be used. They will be compiled for Linux and the resulting binaries will be run with the Compat Linux. This project will focus on the most basic/used syscalls, this allows for a great coverage of use cases, and will make running more complex tests easier in the future. The syscalls to be tested are: Basic IO: read, write, open, close, lseek, stat, fstat Processes: fork, execve, exit, waitid, dup, dup2, pipe Memory: nmap, munmap, mprotect, brk Sockets: socket, bind, connect, accept
CppInterOp is a Clang-based library that provides an API to examine C/C++ code, enabling language bindings such as cppyy to interact with C++ code at runtime. While CppInterOp exposes function metadata, it currently lacks the ability to expose two critical properties of C/C++ code: memory ownership and thread safety characteristics of functions. Language bindings have no way to determine if the function allocates memory on the heap, whether the caller is responsible for deallocating the memory, what allocation mechanism was used, or which function should be called to free it. Similarly, there is no information about whether a function is safe to call from multiple threads. This project proposes to implement analysis using Clang’s AST and LLVM IR to extract memory ownership and thread safety information from C++ code, and expose this information for language binding tools. The analysis starts from declaration-level checks (return type, const qualifiers, attributes) and continues to function body traversal for exposing further details.
LibreHealth EHR manages sensitive patient data but currently has no automated security testing or vulnerability detection integrated into its development workflow. This means security issues like SQL injection, cross-site scripting, and broken access control can go undetected during code reviews. This project builds a four-layer automated security assessment pipeline integrated directly into the CI/CD workflow. The pipeline consists of a static analysis stage using PHPStan, Enlightn, and Composer Audit to catch code-level vulnerabilities; a dynamic testing stage using OWASP ZAP to simulate real-world attacks against a running EHR instance; a custom CVSS scoring engine that adjusts risk scores based on PHI sensitivity of the affected data; and a security gate that automatically blocks merge requests when high-severity vulnerabilities are detected. The key deliverables are a Meaningful Use workflow security test suite covering 7 clinical workflows, a fully configured GitLab CI pipeline, an automated security gate with PHI-aware scoring, and per-build HTML, JSON, and CSV security reports for both humans and machines.
First responders file the same incident data across multiple agencies - fire, EMS, law enforcement, county/state each with different forms and formats. This redundant data entry costs hours per shift and increases error risk. I propose building FireForm's complete processing pipeline: a responder speaks or types once, a locally-hosted LLM extracts structured data through a schema-aware multi-step pipeline with validation and completeness tracking, and the system generates all required agency PDFs automatically. A visual template registry allows any agency to register new forms without code changes. Missing data is tracked per form and can be supplemented incrementally. Deliverables: REST API with agency-scoped access control and async job processing, schema-aware extraction pipeline with validation layer, visual template editor and registration API, coordinate-based PDF generation, completeness tracking with form generatability status, supplement and manual patch endpoints, test suite with CI integration, and developer documentation.
This project will develop a browser-based, real-time dashboard for molecular dynamics simulations using the new IMDv3 streaming protocol, enabling live monitoring, analysis, and visualization of running simulations. The dashboard will leverage imdclient and MDAnalysis to receive a data stream from a running simulation.
This project extends the OpenAFS fs examine command to provide visibility into each component of a given path, instead of only the final object. In a distributed file system, paths may traverse multiple volumes, cells and mount points, making it difficult to understand how a path is resolved. The proposed solution introduces a new optional flag that iteratively resolves each component of a path and retrieves volume and file information using existing pioctl calls. The implementation will handle intermediate path construction, mount point detection, symbolic links and error cases while preserving backward compatibility. The final deliverables include a working implementation of the new flag, support for edge cases such as mount points and symlinks, updated documentation and tests to validate correctness.
Sprocket is a bio-informatics workflow engine developed by St. Jude Children's Research Hospital. While Sprocket contains powerful tooling for analyzing the Workflow Description Language (WDL), it is only accessible through the Rust programming language. As Python is the dominant language in bio-informatics, this is a proposal for creating Python bindings for Sprocket's wdl crate. This will enable developers to write WDL tooling built on Sprocket's foundation in pure Python, without any need to learn Rust. I propose to create Sprocket's WDL Python bindings such that they are easily accessible to Python programmers, powerful enough to achieve non-trivial goals, and easy to maintain for the Sprocket developers.
This proposal aims to improve observability for Kerberos- and certificate-based authentication workflows in Metasploit. At present, operators often need to interrupt module execution, export authentication artifacts such as .ccache, .kirbi, .pem, or .pfx, and analyze them with external tools in order to understand failures, inspect identities, or validate exploitation steps. This project introduces two opt-in tracing facilities, KerberosTicketTrace and CertificateTrace, together with a reusable X.509 inspection backend to surface protocol and artifact metadata during module execution without changing default Metasploit behavior.
PostgreSQL B-tree indexes often suffer from severe bloat after heavy UPDATE and DELETE workloads because the core engine currently cannot consolidate sparse pages. This project introduces safe, concurrent in-core leaf page merging. By utilizing a two-phase protocol, it consolidates two sparsely populated sibling pages into one without blocking concurrent forward or backward scanners. Key deliverables include the core atomic merge logic, a two-stage flag system to safely route concurrent traversals, atomic WAL logging for crash resilience, VACUUM cleanup integration, and analytical visualization tooling built via pageinspect.
This project aims to complete the transition of Pocket Paint (Paintroid) to Flutter by ensuring compatibility with legacy Kotlin/Java-based .catrobat project files and implementing missing native features in the Flutter version. Currently, older projects cannot be reliably opened, which risks loss of user data and limits adoption of the new app. To solve this, I will design and implement a compatibility layer that parses legacy Kryo-serialized binary data from the native Android application and converts it into the Flutter-compatible JSON-based project structure. The system will follow a structured pipeline (binary decoding → Dart model mapping → JSON serialization → rendering) to accurately reconstruct layers, strokes, and metadata. In addition, I will implement fallback rendering strategies for unsupported tools to preserve visual fidelity and ensure all legacy files remain accessible. Once the compatibility layer is stable, I will focus on implementing selected missing native drawing tools in Flutter to further close the feature gap between the old and new applications. The project will follow a test-driven approach with extensive unit and integration testing using real legacy files to ensure correctness and stability. Deliverables include: - Kryo-to-Dart parsing system for .catrobat files - Fully integrated backward compatibility layer in the Flutter app - Fallback rendering for unsupported legacy features - Comprehensive unit and integration test suite - Documentation for architecture and long-term maintenance - (Stretch goal, if time permits) Implementation of selected high-priority missing native tools (e.g., Fill Tool)
Traditional archaeological modeling often relies on "least-cost paths" that only account for terrain steepness, treating human movement like water flow. Similarly, standard visibility analysis is typically 2-D and planimetric, ignoring building heights, window apertures, and translucent partitions. This project proposes an ML-enhanced framework for the Necropolis of El Bagawat. By using multispectral ground surface classification (SAR-MS.tif) to weight movement costs and incorporating building entrance orientations from architectural plans (Site_Plan.pdf), I will develop a probabilistic path ensemble that reflects social and physical realities. Furthermore, I will implement a true 3D ray-casting viewshed that accounts for 3D geometry and window openings, delivering high-fidelity GIS vector layers and 3D volumes to rewrite the embodied history of this late antique site.
This project aims to implement state-of-the-art protein design models, RFDiffusion and RFDiffusion-2, within the DeepChem framework using a clean, end-to-end PyTorch pipeline. The goal is to make advanced generative protein modeling accessible through standardized DeepChem abstractions such as TorchModel, Dataset, and Featurizer, facilitating integration with existing deepchem workflows. The model leverages diffusion-based generative techniques to transform random noise into realistic protein structures, built on a RoseTTAFold inspired architecture that jointly captures sequence, pairwise interactions, and 3D geometry. By incorporating SE(3)-equivariant operations, the system ensures physically consistent predictions while maintaining modularity through the use of existing equivariant libraries.
Currently, the debuginfo test suite has a number of shortcomings: it is sensitive to the installed debugger and python version; it does not account for the unavoidable visualization difference between PDB and DWARF debug info; the raw string comparisons are fragile and cause unreasonable numbers of failures when visualizer scripts are changed intentionally; and many properties the visualizers rely on are only tested incidentally. As a result, the tests are difficult to run in CI, difficult to run locally (particularly on Windows), failures are difficult to diagnose, and updating tests for expected changes is arduous. This proposal intends to add a new directive ("{debugger_prefix}-repr") to compiletest/runtest/debugger that leverages the debuggers’ public Python API. Python scripts will check the debugger’s in-memory representation of objects and the underlying debugee memory to verify accurate debug info and visualization. These scripts will also be able to alter their behavior based on debugger version and debug info format. This will allow for more specific errors when tests fail. Test data will be “blessable” (i.e. automatically updateable) to make intentional changes to the visualizer scripts significantly easier.
Julia's medical imaging stack currently relies on 3D U-Net variants for segmentation, which lose spatial relationships through max-pooling. This project implements 3D capsule network architectures in Lux.jl that preserve part-whole spatial hierarchies through dynamic routing-by-agreement. I will build reusable capsule layer primitives (PrimaryCapsule3D, ConvCapsule3D, routing modules), two full architectures (3D SegCaps and a SegCaps-UNet hybrid), and custom GPU-accelerated routing kernels using KernelAbstractions.jl. The full pipeline integrates with MedPipe3D.jl for data loading, training, and evaluation. Deliverables: (1) Capsule layer primitives as Lux.jl modules, (2) 3D SegCaps architecture, (3) SegCaps-UNet hybrid, (4) GPU routing kernels, (5) training pipeline with MedPipe3D.jl, (6) benchmarks across all 10 Medical Segmentation Decathlon tasks (Dice, HD95, cross-task transfer vs 3D U-Net), (7) documentation and pretrained weights, (8) PRs to JuliaHealth.
RustCloud unifies cloud provider APIs for Rust developers, but Generative AI support is completely missing. Every GenAI provider uses a different auth model, API style, and request format, forcing developers to maintain separate HTTP clients for each one. Rust has no equivalent of Python's LiteLLM or LangChain. This project delivers concrete LlmProvider implementations for AWS Bedrock, GCP Vertex AI, and Azure OpenAI, a complete GCP BigQuery module, a UnifiedLlmClient with Explicit/ModelBased/Fallback routing strategies, RetryMiddleware with exponential backoff, and a full test suite targeting 85%+ coverage with complete documentation. I have been contributing to RustCloud since March 2026 with 19 PRs across all four cloud providers, including working proof-of-concept implementations of all three GenAI providers and the routing layer. The GSoC period is where these drafts become production-quality, tested, and merged modules.