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.
Submitty currently has bash scripts that require direct database calls. To improve maintainability, I will be working on some of Submitty’s bash scripts, converting the scripts to use the API. This will involve refactoring some existing scripts to be able to call the API. I will also expand the API to allow more remote management without requiring UI interaction. These changes will allow for better maintainability and easier utilization of the scripts.
This project aims to enhance the PSLab application by improving stability, expanding sensor and experiment support, and making the app more user-friendly and accessible. I plan to thoroughly test the application to identify and fix hidden bugs, improve UI responsiveness, and implement missing features such as sensor integrations, experiment modules, and configuration utilities. Additional work will include implementing new sensors, improving experiment interfaces across domains such as electronics, physics, and environmental science, and enhancing the overall user experience. To make the application easier to use for beginners, I will introduce in-app guided tutorials and interactive walkthroughs for instruments. I will also improve the PSLab documentation website by adding missing documentation, updating outdated content, and creating clear contribution guidelines for new contributors. By the end of the project, the PSLab application will become more stable, feature-complete, and user-friendly, with improved sensor support, structured experiment modules, interactive onboarding guides, and enhanced documentation.
Thousands of bioinformatics workflows registered on public platforms like Dockstore and WorkflowHub cannot run on modern cloud platforms. Not because the science is wrong, but because the engineering hasn't caught up. Missing containers, hardcoded paths, HPC-specific executors, and unstructured inputs and outputs make these workflows incompatible with GA4GH's WES standard and cloud-based research platforms. Workflow Clinic fixes this automatically. It is a Python-based CLI tool with two core components. The Workflow Critic scans a workflow repository, runs a deterministic rule engine followed by an optional AI agent team, and produces a structured diagnosis.json report identifying every cloudification gap with severity levels and remediation suggestions. The Workflow Doctor reads this report, applies fixes directly to the workflow files using a 3-layer strategy (AST-based, regex-based, and AI-assisted as a last resort), and opens Pull Requests to propose the changes. GitHub interaction is purely optional examine and fix work fully offline without any credentials. When a GitHub PAT is provided, the tool can additionally publish findings as GitHub issues and open Pull Requests. Without a PAT, the same outputs are generated locally as issue.md and fix.md files.
Seata Go currently lags behind the Java version in registry support and operational diagnostics. This proposal introduces a shared multi registry foundation for Seata Go, implements Nacos, ZooKeeper, Consul, and Redis support in a phased and reviewable way, addresses NamingServer and path compatibility issues needed by the Go SDK baseline, and extends seata ctl with server and config self checks, transaction and lock diagnostics, and structured output. The project deliverables include the shared registry layer, four registry adapters with tests, a bounded diagnostic command set, and follow up TUI, sample, and documentation polish.
This proposal focuses on improving the Djed Stablecoin Protocol by making it simpler, more efficient, and easier to use in real-world applications. The main work involves developing improved versions like Tefnut and Isis, optimizing smart contracts, and building a clean and user-friendly interface for seamless interaction. It also includes integrating the system with StablePay to enable practical payment use cases. Overall, the goal is to create a reliable and accessible stablecoin ecosystem that bridges the gap between complex DeFi systems and everyday usability.
Currently, CRIU cannot checkpoint or restore systemd-managed containers if there are SCM_CREDENTIALS messages waiting in a Unix socket queue. Because systemd uses these credentials for almost all service communications, any in-flight message causes CRIU to fail. We aim to solve this problem by adding support for SCM_CREDENTIALS and the newer SCM_PIDFD to CRIU’s socket queue logic. I will implement PID remapping to ensure credentials remain valid after restore and add support for modern socket options like SO_PASSPIDFD. The final deliverables will include core code updates to the socket subsystem and extend image formats.
This project improves Netlink support in FreeBSD tracing tools by enabling structured decoding of Netlink message payloads. Currently, truss(1) shows raw hexadecimal output for Netlink calls, making it difficult to interpret structured Netlink messages used by subsystems such as pf . The project will implement decoding within libsysdecode by parsing Generic Netlink headers (genlmsghdr), safely iterating over Type-Length-Value (nlattr) attributes, and dispatching to family-specific decoders. Deliverables include Generic Netlink support, a bounds-safe TLV parsing engine, a modular dispatch framework, and at least one functional decoder (pf), enabling human-readable output and providing a scalable foundation for future Netlink decoding.
InVesalius's 3D mask editor suffers from two critical bottlenecks: slow single-threaded Python geometry math that freezes the UI on high-resolution medical images, and a memory-intensive undo system that copies entire 500×500×500 voxel matrices on every edit, causing out-of-memory crashes on resource-constrained machines. This project addresses both problems through three tightly integrated deliverables. First, the heavy polygon-to-mask projection math will be ported from Python's skimage into multi-threaded Rust via PyO3, using zero-copy rust-numpy bindings to eliminate expensive matrix duplication across the Python/Rust boundary. Second, a new delta-encoded Undo/Redo engine will be built that records only the coordinates of changed voxels rather than full volume snapshots, paired with a disk-backed crash-recovery system and a visual history panel in wxPython for intuitive workflow management. Third, a native interactive 3D Brush Tool will be introduced, allowing users to paint or erase mask selections directly onto the 3D model with a configurable voxel depth, powered by native Rust ray-casting algorithms. Deliverables include a working invesalius_rs Rust module replacing the skimage dependency, the DeltaHistoryStack integrated across all 3D tools (polygon, brush, select parts, thresholding), the Mask3DEditorState decoupling class to eliminate ghost polygon UI bugs, cross-platform unit tests and CI validation, and a contributor benchmark report comparing performance against the current v3.0 baseline.
Boa is an embeddable JavaScript engine written in Rust. JavaScript is garbage collected by specification, meaning the runtime is responsible for managing memory and reclaiming values once they become unreachable. Boa's current collector (boa_gc) works and is well tested, but it was designed for correctness first, and now carries design debt that holds back performance and maintainability. Experimental redesign work is already underway in the separate Oscars repository. This project focuses on evaluating that work, auditing the current design, improving the GC where needed (tracing strategy, allocation model, rooting) and integrating a production ready collector into Boa's runtime, backed by stress tests, benchmarks and documentation covering the design decisions and tradeoffs. Extensions may include incremental or generational collection, GC aware VM optimizations and heap visualization tooling.
This project aims to harden IntelOwl's connector ecosystem - the critical egress layer for routing threat intelligence data by resolving Django ORM inefficiencies, task-safety mutability bugs in Celery workers, and false-positive health checks. The project will be executed by fixing core database and syntax bottlenecks, implementing native API diagnostics, and introducing a shared CTIConnector base class to de duplicate observable extraction logic. Finally, a lightweight dockerized CI testing pipeline will be established for the MISP connector to ensure long-term ecosystem stability.
Strong gravitational lensing is a powerful tool for studying dark matter, but machine learning models trained on simulated data often fail to generalize to real observations due to noise, domain shift, and lack of physical constraints. This project addresses this gap by developing a physics-informed deep learning framework that incorporates the gravitational lensing equation directly into the training process. The proposed approach augments a deep neural network with physically derived deflection field channels and introduces a physics-consistency loss that enforces agreement between learned and predicted physical parameters (e.g., Einstein radius). This enables the model to learn representations that are both data-driven and physically grounded, improving robustness, interpretability, and cross-domain generalization. The project will deliver a modular, open-source library for physics-informed lensing analysis, including baseline and physics-augmented models, reusable physics layers (e.g., SIS/NFW profiles), training and evaluation pipelines, and reproducible benchmarking tools. Additional deliverables include pretrained models, documentation with tutorials, and a systematic evaluation of performance on both simulated and real lensing datasets.
I plan to focus on three concrete deliverables during GSoC: an advanced fuzzing tool, an image injection tool, and a new GitHub Actions workflow for periodic fuzzing. My goal is not only to implement these components, but also to make them understandable, reproducible, and genuinely useful for long-term EROFS development. The expected implementation order is to first establish a format-aware fuzzing workflow, then build an image injection tool that helps reproduce and analyze specific issues, and finally connect the resulting workflow to periodic CI-based robustness testing.
I would like to volunteer to develop SSH Client/Server support for NuttX. I believe this is a highly valuable feature, as it would enable remote access to NuttX-based hardware in the field for maintenance and operational purposes. With SSH support, we could remotely interact with devices, trigger I/Os, manage peripherals, and perform diagnostics in a way that is conceptually similar to what we already do on Linux-based systems. Also, this is a great opportunity for me to develop my skills. The implementation would be based on Dropbear, a lightweight and complete SSH stack with a small footprint, which makes it well-suited for embedded environments. There is already a reference port available that I plan to use as a development guide: https://github.com/david-cermak/dropbear The project would be structured in the following phases: Initial study phase to assess requirements and dependencies, including evaluation of cryptographic library integration and system constraints. Review of existing ports for other platforms (for example, ESP-IDF) to understand architectural decisions and integration patterns. Porting of the required SSH client and server functionalities to NuttX. Testing, validation, performance assessment, and resolution of identified issues. Mentors: Alan C. Assis, acassis@gmail.com
Mifos Payment Hub EE is a payment orchestration engine that coordinates and routes payment transactions among core banking systems, switches, wallets, and external financial partners. The Payment hub exposes multiple APIs for payment initiation, status queries, partner integrations, and operational management, creating a large surface area for critical risks such as Broken or inconsistent authorisation across endpoints, replay or duplicate payment requests. This project will focus on conducting a comprehensive API security assessment of the Payment Hub API, with emphasis on the OWASP API Security Top 10 and real-world payment threat models. The goal is to identify, document, and help mitigate security vulnerabilities within the system’s RESTful APIs. This project will be centred mainly around: - API Surface Mapping, which deals with enumerating the APIs found in the PaymentHub and identifying the authentication flows, request headers and partner-specific parameters used. - Threat modelling deals with mapping the threats found to the OWASP category - API Penetration Testing focused on the OWASP API Security Top 10 - Tooling and Automation, dealing with developing custom scripts and reusable test cases - Reporting and Remediation, dealing with producing a detailed vulnerability report and providing fixes and mitigation to the different vulnerabilities found. By the end of the project, the following deliverables are expected: 1) A documented Payment Hub EE API threat model and API Penetration testing checklist 2) An automated or semi-automated API security test suite for reusing in other projects 3) A detailed vulnerability assessment report with remediation guidance will be provided to help developers make patches when needed and follow secure API Practices.
The Kolibri Design System contains resources for designers and developers building Kolibri products.KDS ensures accessibility, responsiveness, and cross-browser compatibility across all Kolibri products. Currently, Kolibri Studio relies on Vuetify 1.5.24 for multi-select dropdown functionality an outdated library that conflicts with KDS and blocks Studio's ongoing migration. This project builds a fully accessible multi-select dropdown on native KDS primitives, following the WAI-ARIA APG 1.2 combobox pattern and WCAG 2.1 Level AA from the ground up .Hence, replacing VAutocomplete instances in Studio and laying a foundation for an eventual KDS component.
This project aims to mainly address issues and implement features and functionalities requested by users to make using Zulip's mobile app a more enriching experience. I will address 17 issues in the zulip-flutter repository over 350 hours, encompassing improvements to various aspects of the app, including but not limited to content parsing, message composition, API handling, tooling, and home view.
This project aims to build a reliable OpenSCAD to JavaScript compiler using ManifoldCAD, making it possible to run existing OpenSCAD code in a modern JavaScript environment. The main challenge is that OpenSCAD works in its own ecosystem, while ManifoldCAD cannot directly execute OpenSCAD programs. Current tools are limited and often don’t handle modern features or correct semantics. To solve this, I will develop a proper compiler that accurately models OpenSCAD behavior instead of relying on JavaScript shortcuts. Building on my existing prototype, I will design a structured pipeline with parsing, semantic analysis, and an intermediate representation (IR) to ensure correctness. Key areas include handling modules vs functions, children(), special variables, and improving debugging through source mapping. The final result will be a robust, production-ready compiler integrated into the Manifold ecosystem, enabling developers to reuse OpenSCAD libraries with confidence.
This proposal aims to improve Zulip integrations by making them more accessible and user-friendly. It introduces a backend permissions system to enforce bot access levels at runtime, the project replaces API key-based authentication with an OAuth 2.0 flow using django-oauth-toolkit. Additionally, it redesigns the integrations UI to use a “Add to Zulip” button which eliminates the manual bot setup. Together, these changes simplify integration workflows for non-technical users while making the integrations more secure.
This project develops an expressive gesture-to-sound mapping layer for GestureCap, enabling low-latency gesture data to control playable instruments such as a Hyper-Theremin. It focuses on continuous control, microtonality, and adaptive mappings to support expressive performance and accessibility.
During GSoC, I propose to build a carbon-aware fitness tracker application from scratch that combines personal health tracking with environmental awareness while prioritizing user privacy. The project addresses two key problems: the lack of privacy in existing fitness apps, which often rely on external servers, and the absence of tools that help users understand their daily carbon footprint. To solve this, I will develop a Flutter-based mobile application along with a Wear OS companion app, integrating them using the Data Layer API and platform channels to seamlessly transfer fitness data such as steps, heart rate, and activity metrics from the watch to the phone. On the Wear OS side, I will use the Health Services API to collect real-time data, while the mobile app will feature a transport logging system that calculates carbon emissions or savings based on user travel choices, along with a dashboard displaying weekly summaries, visual charts, and actionable sustainability suggestions. All user data will be stored locally using SQLite to ensure complete privacy, and the application will be supported by comprehensive unit, widget, and integration testing to ensure reliability. The final deliverables will include a fully functional mobile and Wear OS application, a secure local data management system, a carbon footprint tracking and visualization module, and a production-ready app prepared for deployment on Android and Wear OS platforms.
Neutralinojs currently lacks an automated system for creating platform-specific installers, forcing developers to manually package applications for each release. This project aims to build the Neutralinojs Builder, an official plugin for the neu CLI, to automate the installer generation process. The plugin will be implemented using a modular Node.js architecture to support Windows .exe (NSIS), Linux .deb and .AppImage, and macOS .dmg formats. Key deliverables include a dynamic module loading system, automated dependency validation for local build tools, and integrated GitHub Actions for cross-platform verification. Once completed, this tool will provide a reliable distribution pipeline for production-level Neutralinojs applications.
Sugar Activity on Demand addresses a key barrier in Sugar Labs: the difficulty learners face in creating their own activities due to the need for programming knowledge. This limits access to constructionist learning, where students learn best by building meaningful projects. This project introduces an AI-assisted system that allows learners to describe an activity in natural language and receive a fully functional, installable Sugar activity. The system combines a model-agnostic LLM pipeline, a retrieval-augmented knowledge base built from real Sugar Activity source code, and an AST-based validator to ensure that generated Python code is both correct and safe. Activities are generated with proper GTK3 interfaces, toolbar integration, and Journal support, ensuring they are fully compatible with the Sugar ecosystem. Beyond generation, the project emphasizes learning through a Reflective Studio, where learners explore, understand, and modify the generated code. Using scaffolded challenges, inline annotations, and reflection prompts, the system follows the constructionist Use → Modify → Create progression, enabling learners to gradually take ownership of their creations rather than passively consuming generated output. Deliverables AI-powered activity generation pipeline (prompt → plan → code → installable bundle) RAG-based knowledge system using real Sugar Activity examples AST-based security validation and safe code generation framework Interactive Reflective Studio with guided editing, annotations, and challenges Integration into Sugar’s Home View with a seamless “Create with AI” entry point Support for iterative refinement, version history, and sharing via the Sugar Journal This project aligns with Sugar Labs’ constructionist philosophy by transforming AI from a passive generator into an active learning partner, empowering learners not just to use software, but to understand and create it.
The current Kubeflow SparkClient (KEP-107) provides a solid foundation for running interactive Spark workloads on Kubernetes, but it is still missing key capabilities required for real-world usage, such as batch job submission, consistent job lifecycle management, and production-level observability. This project focuses on extending the SparkClient to support complete, production-ready Spark workflows. The primary goal is to implement a robust submit_job() API for batch job execution using the SparkApplication CRD, supporting both script-based and function-based workloads. Alongside this, I will design a consistent set of lifecycle APIs such as job listing, status tracking, log retrieval, and cleanup, ensuring they align with existing Kubeflow SDK patterns. To improve usability in production environments, the project will also introduce observability features, including metrics collection from the Spark REST API, structured event tracking, and basic health monitoring. These additions will help users better understand job execution, debug failures, and monitor resource usage. The implementation will build on the current architecture without breaking compatibility, focusing on reliability, validation, and consistency. The final outcome will be a more complete and production-ready SparkClient that enables users to run, monitor, and manage Spark workloads on Kubernetes in a simple and consistent way.
Extend ffigen to support C++, enabling Dart developers to use C++ libraries without manual wrappers. The project simplifies integration, reduces errors, and improves productivity by automating the process and providing a seamless developer experience.