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.
SW360 currently imports license and obligation data through five disconnected paths with no coordination between them, meaning multiple instances can hold different obligation text for the same license with no way to detect the gap. This project makes LicenseDB the single authoritative source by implementing scheduled REST based synchronization. It covers paginated license and obligation sync, incremental daily updates via the audit log, field-level mapping that preserves SW360-specific compliance fields, read-only gating of legacy import paths, and CouchDB-first lookup for CLI attachment processing. Deliverables include JWT authentication, automated daily scheduling via ScheduleHandler, admin REST endpoints for sync control and health monitoring, encrypted credentials, circuit breaker and rate limiting, a migration guide, and test coverage.
Strong gravitational lensing is among the most powerful observational probes of dark matter substructure. High-resolution lensing images encode the morphological fingerprints of different dark matter models. Most available lensing images today and expected from upcoming surveys such as Euclid and LSST are ground-based and limited in resolution by atmospheric seeing. Obtaining matched high-resolution counterparts from space-based instruments like HST for every ground-based image is impractical at survey scale. This project addresses two main challenges in the proposed ML4Sci topic. First, it explores a super-resolution pipeline that does not require matched real low-resolution and high-resolution lensing observations for training. Instead, the model is trained on simulated high-resolution lensing images constructed with realistic source morphologies and survey-calibrated degradations, while remaining unsupervised with respect to real telescope HR targets. Second, it tests whether using real galaxy morphologies and limited ablations, can reduce the realism gap introduced by purely parametric Sérsic source models.
This project aims to revamp the Wagtail Editor Guide by addressing key limitations in versioning, localization, developer experience, and frontend performance. It introduces an automated versioning system with selective updates and redirect handling, integrates robust multilingual support using wagtail-localize with RTL compatibility, and reduces contributor friction through improved setup and realistic data fixtures. Additionally, the project modernizes the frontend by removing unnecessary dependencies, optimizing fonts, and enhancing UI/UX interactions, resulting in a faster, more maintainable, and globally accessible documentation platform.
Mesa-Geo currently suffers from three structural problems that make it impractical at realistic geographic scale: a memory bottleneck from instantiating one Python object per raster pixel, a fractured coordinate system that silently conflates three incompatible reference frames, and a broken Cell/Agent abstraction that floods the agent registry with millions of ephemeral entries. This project resolves all three problems through four focused changes: refactoring RasterLayer onto a PropertyLayer NumPy backend, decoupling Cell from mesa.Agent through a weakref identity cache, delivering a RasterCellCollection aggregation API with scipy.ndimage-powered spatial statistics, and overhauling the visualization pipeline to render rasters as a single ipyleaflet.ImageOverlay instead of millions of polygon draws. All work is aligned with Mesa 4.0's unified reactive architecture, positioning Mesa-Geo as the geospatial pillar of Mesa's next generation rather than a legacy bolt-on. Core deliverables: PropertyLayer-backed RasterLayer, decoupled Cell with three explicit coordinate properties, RasterCellCollection aggregation API, SolaraViz-compatible make_geospace_component, a geo predator-prey benchmark model, and a full Mesa-Geo 3.x migration guide. Stretch goals: H3 hexagonal grid support, a GeoSpace redesign proof-of-concept (#2585), and a Kalman filter temporal state estimation API for PropertyLayer.
This project extends Clang API Notes to support overload-specific annotations for C++ member functions. Today, API Notes cannot distinguish between overloaded methods such as foo(int) and foo(double), so annotations are applied to all overloads with the same name rather than to a specific function. The project introduces overload-aware matching for C++ methods, allowing API Notes to target individual overloads based on their parameter types while preserving compatibility with existing notes. This enables more precise annotations and improves interoperability for real-world C++ APIs, such as Swift bindings. The core deliverable is a working and tested implementation for explicit-parameter overloads (Phase 1), including typed-vs-legacy handling and regression tests. The project then extends this to support const- and ref-qualified member functions (Phase 2), completing support for receiver-sensitive overloads.
Clang-Doc is LLVM's modern C/C++ documentation generator built on the compiler AST rather than heuristic text parsing. A key blocker to its adoption is the absence of Markdown support inside documentation comments. Fenced code blocks, pipe tables, and lists currently pass through to output generators as raw text, making generated documentation unreadable for any project that uses Markdown in its comment workflow, which includes LLVM itself. This project implements a standalone Markdown parsing library that takes text and returns typed data structures, with no knowledge of comments or Clang internals. Clang-Doc is the immediate consumer, but the library is usable by any LLVM tool. It follows the same pattern as the Mustache library from GSoC 2024, with no third-party dependencies. Deliverables include the full library, Clang-Doc integration, updated HTML and Markdown generators, end-to-end lit/FileCheck tests, a libFuzzer harness, and an LLVM blog post. Stretch goal: Clang AST support for Doxygen group comments, flagged by mentors as particularly valuable.
BookBrainz is currently English-only, limiting its global reach. This project integrates i18next with BookBrainz's React SSR pipeline to enable full internationalization: locale-detection middleware (Accept-Language + cookie), a language selector in the navbar, English translation JSON files, ~620 strings migrated across ~120 files, and a BookBrainz project on translations.metabrainz.org so volunteer translators can contribute immediately — with no rebuild required per translation update.
This project focuses on improving the developer experience around the Kirigami framework by making the development workflow more connected and efficient. Kirigami already provides well-structured documentation and examples, but these resources are spread across different places, making it harder to explore them interactively and move smoothly from learning to practical hands-on. To address this, I will enhance Kirigami Workbench and integrate it with KAppTemplate. The project introduces an interactive gallery of examples with live previews and editable code, along with a plugin-based system so new examples can be easily added and explored within a single environment. Developers will also be able to generate ready-to-use application projects using KAppTemplate, with selected examples as the starting point, along with added Python support for developing Kirigami applications using PySide6/PyQt6 within Workbench. The main deliverables include the example gallery with search and filtering, plugin support, project generation using KAppTemplate, Python support, and multi-tab functionality for working with multiple files. Overall, this project makes working with Kirigami smoother and more connected, bringing everything into one place.
This project would make the Eventyay badge creator much more user-friendly and also add badge printing in the event check-in workflow itself. Right now, event organizers have to separately go to a different page in order to download badge PDFs before they can even print them out, adding friction during busy events and slowing down the check-in process. This project will integrate badge printing into the webcheckin interface so event staff can print attendee badges immediately after ticket redemption. There are also ticket types, a modal pop-up for the badge layout creations workflow (optional role-based template badges: speaker /attendee/ volunteer/ exhibitor), and improved badge editor experience. Implementation will make a wrapper around existing Django-based badge plugin and Vue. jsWebCheckin application used in Eventyay. Its exact features will include usage of existing badge download APIs, refactored frontend integrations for printing, optional config settings for automatic printing and updated documentation and tests. Deliverables badges design flow; embedded on-line badge printing for check-in app; usability improvements in badge editor;API documentation: performance enhancement (caching, asynchronous generation handling); updated developer and user documentations. This will save a lot of time at check-in and provide a better management experience to the organizers using Eventyay.
Apache Fineract is open-source banking software used by institutions around the world to serve people who don't have access to traditional banks. Every time someone opens an account, creates a loan, or uploads a document, the system has to read the incoming data, validate it, and save it. The current code that does this was written about twenty years ago, the data arrives as plain text, and the system manually picks apart each field by hand. This causes silent bugs, makes the code hard to change, and produces thousands of lines of repetitive plumbing. The Fineract community has already built a modern replacement that uses strongly-typed data objects, so data is automatically structured and validated the moment it arrives. The new system is in production for 13 features; around 57 features still use the old approach. My GSoC project is to move 5–7 of those remaining features onto the new system, one feature at a time, strictly following the migration guide the team has already written. Proposed features (subject to mentor confirmation): Holidays, Account Number Format, Codes / CodeValues, Office, Fund, and Calendar. For each feature, I will design new typed data classes, rewrite the related handler code, simplify the business logic to accept typed inputs, replace hand-written validation with built-in checks, and make sure all existing tests still pass. Where test coverage is thin, I will add new automated tests in line with the community's quality direction. This work reduces long-standing technical debt and makes future development faster and safer in a system that real banks depend on every day.
BLT University is an interactive security learning platform built on top of OWASP BLT that transforms existing labs into hands-on, code-driven exercises. It migrates the current Django-based labs into a static Jekyll system where content is stored and rendered as Markdown, making it more scalable and easier to maintain. Instead of static, theory-heavy content, users work directly with vulnerable code through a structured Identify → Explain → Fix workflow to understand how vulnerabilities appear and how to fix them in practice. The project also includes GitHub Actions workflows for validation and syncing, along with a security intelligence pipeline that analyzes GitHub issues, pull requests, and review comments to identify recurring vulnerability patterns. These insights power a dashboard and a recommendation system, helping connect real-world security issues with relevant labs and improve hands-on learning for contributors. It aims to help contributors build a practical security mindset while improving the quality of open-source contributions.
Neovim currently cannot run natively in web browsers because its build systems and dependencies, such as libuv rely on OS-level features unavailable in WebAssembly (WASM). This project aims to enable Neovim as a WASM build target by adapting its build systems, creating a WASM compatibility layer to stub or replace unsupported OS features, and integrating a browser frontend. It involves compiling Neovim’s core editing engine, Lua 5.1 interpreter, and runtime files into WASM, adapting asynchronous event loops, handling virtual filesystems via Emscripten, and providing replacements for system calls like signals, threads, and process management. The deliverables include a fully functional nvim.wasm binary with embedded runtime files, a browser frontend capable of rendering the UI and handling input via Neovim’s RPC protocol. This will allow Neovim to operate within the browser which increases accessibility, enables integration with online IDEs and educational platforms, and expands Neovim’s ecosystem to new users and contributors.
Currently, Mixxx uses PortAudio as a high level abstraction over audio APIs across all supported platforms, which only exposes the common subset of all those APIs, missing Linux specific features and conventions. This implementation will add Pipewire audio API support to Mixxx for Linux, listen for PipeWire events to support soundcard hotplug and update routing UI according to changes made in an external patchbay. It will also allow Mixxx to route audio to and from any source/sink. This proposal also attempts to achieve ALSA comparable latency with the PipeWire backend.
This project aims to improve the accuracy, completeness, and accessibility of Indian holidays in the Open World Holidays Framework (OWHF). It focuses on verifying and updating national and subdivision-level holidays using official government sources, ensuring consistency across all 28 states and 8 union territories. In addition, the project will expand localization support by providing holiday names in widely used Indian languages, making the framework more accessible to a broader user base. To enhance long-term consistency and maintainability of calendar-based holidays, the project will also introduce generator scripts for solar and lunisolar holidays. These scripts will be used to generate and validate holiday dates across extended year ranges, while keeping the runtime implementation lightweight and dependency-free. The final outcome will be a more accurate, fully localized, and scalable holiday dataset for India, aligned with real-world usage and the design principles of the holidays framework.
I propose to build a reproducible benchmark framework for evaluating cloud-native storage options for Uyuni on RKE2. The problem is that different Kubernetes storage backends can behave very differently for the kinds of operations Uyuni depends on, especially PostgreSQL transactions, repository metadata handling, and package distribution. The project will address this by starting from a storage-only control baseline and then extending the evaluation into PostgreSQL benchmarking and Uyuni-specific workload benchmarking, while collecting synchronized observability data for each run. The same benchmark method will be reused across selected storage backends so that results remain comparable and can support a practical recommendation for which StorageClass Uyuni should support on RKE2. The main deliverables will be a reusable benchmark harness, benchmark results for the tested storage backends, PostgreSQL and Uyuni workload comparison data, observability-backed summaries, and a final report that explains the benchmark method, compares the backends, and recommends the most suitable StorageClass. The project will also produce the configuration artifacts and scripts needed to rerun the benchmark process and reproduce the tested setup.
Specialization is a compiler transformation that optimizes generic program code such that code using primitive types can execute without significant overhead. The @specialized annotation in the Scala 2 programming language allowed programmers to direct the compiler to create optimized generic data structures for each primitive type. @specialized is used significantly in the implementation of high-performance Scala 2 libraries, allowing for performance without the productivity of generics. This optimization trades performance at the cost of extra space, as generic code must be specialized for each of the primitive types, scaling exponentially on the number of type parameters. Since the Scala 3 programming language has evolved significantly from Scala 2, the @specialized annotation is no longer available. This proposal will prototype a new scheme of specialization for the Scala 3 compiler based on inline traits that avoids the performance pitfalls of the Scala 2 implementation, enabling the evolution of many high-performance Scala 2 libraries into Scala 3.
Scikit-bio offers a great toolkit for working with biological data that has a tree-like structure. Although the current implementation, TreeNode, can accommodate a large variety of use-cases, its pointer-based nature limits its scalability to large trees with billions or even trillions of nodes. This project aims to remedy this problem by implementing a succinct data structure for trees based on its balanced parentheses representation, such that the memory usage and the time required for operations are minimized. There are two main components to this project. The first component pertains to the implementation of the data structure proposed in using Numba and NumPy based on improved-octo-waddle, a previous implementation using Cython. The other component relates to integrating the new data structure into the back-end of the existing TreeNode class within the library to enable compatibility with the existing APIs. The core deliverables include: an implementation of the new data structure that can be interfaced via TreeNode, an extensive suite of tests for correctness and benchmarking to ensure performance uplifts, and documentation to guide users on the usage of the new data structure. As a potential extension, GPU support will be investigated along with the exploration of an alternative solution proposed by Córdova, J. and Navarro, G. (2016).
This proposal aims to improve LFortran by compiling and validating real-world Fortran packages such as M_intrinsics, fman, and gtk-fortran. Instead of focusing on isolated features, it follows a compilation-driven approach to identify and resolve limitations across different stages of the compiler, including parsing, semantic analysis, code generation, and runtime support. Key issues such as incomplete I/O specifier handling, quadruple precision support, and array constructor transformations will be addressed. The project emphasizes iterative development, testing, and validation against reference compilers, with the goal of improving LFortran’s robustness, correctness, and support for complex, real-world applications.
A lot of everyday computer tasks—like navigating applications, managing files, and configuring settings—are repetitive and require multiple manual steps. Existing automation solutions rely on brittle scripts or cloud-based AI systems, which introduce latency, privacy concerns, and limited adaptability. This project aims to build a native desktop GUI agent that can understand natural language instructions and autonomously operate the computer interface. The system will combine Vision-Language Models (VLMs) for screen understanding and Large Language Models (LLMs) for reasoning and task planning, all running locally using OpenVINO for efficient, low-latency inference. The proposed solution uses a multi-agent architecture consisting of a Router, Planning, UI Grounding, Action Execution, and Reflection agents. The VLM (Phi-3.5 Vision) will interpret screenshots and map UI elements to coordinates, while the LLM (DeepSeek-R1 Distill Qwen 7B) will decompose tasks and generate action sequences. A PyQt-based desktop interface will allow users to interact with the agent, monitor execution, and configure settings.
Implementation of a direct integration between SimNIBS and InVesalius to enable subject-specific head model generation and TMS electric field (E-field) simulations within InVesalius. Currently, head modeling and E-field simulations require external workflows and manual data handling. This project will integrate the full pipeline into InVesalius, allowing users to generate MRI-based head models, position and orient TMS coils using existing neuronavigation tools, configure simulation parameters, execute simulations internally, and visualize E-field magnitude (|E|) directly on 3D anatomical models. The activity will focus on implementing a Python-based interface to SimNIBS, aligning coordinate systems, handling simulation inputs/outputs robustly, and integrating results into the InVesalius visualization environment. Deliverables: Integrated MRI-based head modeling pipeline. Python interface module connecting InVesalius to SimNIBS. UI panel for head modeling and simulation configuration. Execution of TMS E-field simulations within InVesalius. 3D visualization of E-field magnitude (|E|). Technical documentation.
This project improves AI agent reliability in Apache Airflow by addressing long-context degradation in realistic multi-turn development sessions. I will build auto-synced SKILL.md artifacts from Airflow’s contributor docs to prevent context drift, a community workflow for collecting and triaging real agent failure cases, and an Airflow-specific benchmark for evaluating workflow compliance on real tasks. The final deliverables include CI-backed skill generation, failure-case aggregation, benchmark scenarios with scoring, and a modular skills folder that reduces context pressure by loading only task-relevant guidance.
Apache Fory provides high-performance serialization & deserialization and code generation from IDL, but it currently lacks end-to-end gRPC service integration for C++ and Rust. As a result, developers may still need to rely on external toolchains (e.g. protoc/prost) to generate service bindings, which prevents Apache Fory from being used as a complete gRPC solution. This proposal aims to enable Apache Fory to generate gRPC-compatible client and server code for both C++ and Rust, while reusing the existing gRPC runtimes (gRPC C++ and tonic). The core idea is to extend the Apache Fory compiler to generate service stubs and integrate Fory's serialization & deserialization into the gRPC pipeline by replacing the default codec (protoc and prost). The design decouples API definitions from transport- layer bindings and introduces reusable codec implementations. The project will also include comprehensive testing (unit, differential, and cross-language), CI integration, and documentation. This work will make Apache Fory a practical alternative to existing protobuf-based toolchains in gRPC frameworks and provide a reference architecture for adding gRPC support to other languages in the future.
Scrum Helper currently supports only GitHub and a partially-integrated GitLab, with all platform logic tightly coupled in a 2,190-line monolithic file. This makes adding new SCM platforms nearly impossible without duplicating the entire data-fetching flow. This project refactors Scrum Helper's core into an extensible Provider Pattern architecture by defining a standardized SCMProvider interface that decouples platform-specific API calls from the report generation engine. I will then implement native providers for GitLab (including self-hosted instances), Gitea, and Bitbucket, each returning normalized data through a unified schema. Deliverables: (1) SCMProvider interface with normalized data models, (2) Refactored GitHubProvider with full regression coverage, (3) GitLabProvider with self-hosted baseUrl support, (4) GiteaProvider tested against Codeberg, (5) BitbucketProvider with OAuth 2.0 auth, (6) unified caching and cross-provider error handling, and (7) architecture guide and contributor docs for adding future providers. All 4 platforms will generate identical scrum reports by project end.
Liquid Galaxy is an open-source panoramic multi-display system used in museums, universities, and science centers worldwide. Its entire installation infrastructure install.sh and all supporting configuration files was written for Ubuntu 16.04 LTS, which reached End of Life in April 2021. As a result, Liquid Galaxy cannot be installed on any currently supported Ubuntu version, leaving existing deployments without security patches and blocking new ones entirely. This project is a systematic, layer-by-layer migration of Liquid Galaxy to Ubuntu 24.04 LTS (Noble Numbat). Rather than patching each broken line individually, I will introduce an OS abstraction layer a lib/ directory of functions that encapsulate every OS-dependent operation, from network detection and display manager configuration to package management and service control. This ensures the system can survive future Ubuntu LTS releases without requiring a full rewrite each time. Deliverables: 1) Updated install.sh working end-to-end on Ubuntu 24.04 2) lib/ OS abstraction layer with testable, version-aware functions 3) GitHub Actions CI pipeline 4) Post-install smoke test suite 5) MIGRATION.md, TROUBLESHOOTING.md, and updated README.md with complete architecture documentation.