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 develop an agentic AI system for predictive maintenance of urban infrastructure using OpenVINO. The goal is to enable intelligent monitoring and decision-making by combining multimodal perception with reasoning capabilities on edge devices. The proposed solution integrates a vision-language model to detect defects (Deformation, Obstacle, Rupture, Disconnect, Misalignment, Deposition) from visual data and a language model to interpret these defects in terms of severity, risk, and maintenance priority. These components will be connected through an agentic pipeline that performs perception, reasoning, and action in a unified workflow. The system will be implemented using OpenVINO-optimized models and deployed on Intel edge hardware to ensure efficient, low-latency inference. Open datasets will be used to validate the system in realistic scenarios. Expected deliverables include: - An end-to-end agentic AI pipeline for predictive maintenance - Integration of multimodal perception and LLM-based reasoning modules - Deployment and optimization using OpenVINO on edge platforms - Benchmark results evaluating performance and system effectiveness - Comprehensive documentation and reproducible codebase
Deploying a honeypot is only half the battle; the real value lies in the intelligence we can extract from it. Currently, standard honeypot deployments leave valuable attacker logs isolated on individual virtual machines. If an instance is terminated, that threat data is gone forever, making it impossible to correlate global attack patterns or build a cohesive defensive strategy. This proposal shifts the C2SI Honeynet from a collection of isolated servers into a centralized, serverless Threat Intelligence Platform. Using Terraform and Ansible, I will build a modular framework to deploy secure, Dockerized sensor nodes across multiple cloud providers (AWS and GCP). Instead of logging locally, these edge nodes will use Fluent Bit to stream attacker telemetry in real-time to a centralized AWS S3 data lake. From there, an event-driven Python Lambda function will automatically enrich attacker IPs with global threat scores and geolocation data, making the raw attacks instantly queryable for researchers via Amazon Athena. I am not starting this project from scratch. To prove this architecture is viable and cost-effective, I have already engineered the core serverless pipeline, secured the remote Terraform state with DynamoDB locking, and built the hardened GCP modules in my preliminary Pull Requests (PR #8, #13, #14, #15, #35). Over the 350-hour GSoC period, my goal is to scale this proven foundation into a production-ready system that allows C2SI security teams to deploy a global honeynet and hunt threats with a single command.
Rocket.Chat currently uses multiple virtualization patterns across list-heavy UI surfaces, especially in core room and contextual views. This makes scrolling behavior, pagination, testing, and future maintenance less consistent, and increases the effort required to review or extend list implementations. My project will establish a shared virtualization baseline for Rocket.Chat using a reusable wrapper integrated with the existing OverlayScrollbars-based scrollbar system, then apply that baseline to a focused set of core user-facing surfaces such as Threads, Discussions, and Message Search. The implementation will build on existing Rocket.Chat frontend patterns, including TanStack Query-based pagination hooks and shared query/cache infrastructure, so the migration can be incremental rather than disruptive. The main deliverables are: a reviewed shared virtualization abstraction suitable for merge, a reusable migration pattern for flat list surfaces, migrations of selected core components, focused test coverage for the wrapper and migrated screens, and contributor documentation covering wrapper usage, pagination integration, scrollbar wiring, and testing. If time allows, I will also migrate an additional core surface such as Room Files or prepare the path for future grouped-list migrations.
This project adds two missing features: struct field tag extraction and interface method name recovery. Tags like json:"user_id" tell a reverse engineer how data is serialized over the network; Go stores them in the binary even after stripping, but GoReSym was not reading them. This project extends the parser to recover tags across all supported Go versions (1.5–1.26) and completes interface method name extraction, with test coverage added for both.
This project brings autodiff and offload into Rust CI by making them buildable and verifiable in the CI pipeline. Autodiff is currently only partially supported in CI, and offload is not yet enabled there at all. The project will focus on the CI and bootstrap changes needed to validate both areas more consistently before merge, including deeper build-system work such as resolving LLVM linking constraints on macOS where required. Deliverables include CI support for autodiff and offload builds and validation, the required bootstrap integration, and supporting infrastructure improvements to keep the workflow reliable and maintainable over time.
HarmonyHub is an open-source platform designed to improve music education through interactive and technology-driven learning experiences. While the current application provides note practice and visualization features, its mobile experience requires improvements in performance, responsiveness, and stability. This project focuses on strengthening the mobile application by optimizing UI responsiveness, improving performance across devices, enhancing error handling, and introducing offline capabilities. In addition, it proposes the development of a relative intonation learning module built on top of the existing chromatic tuner, enabling users to practice pitch accuracy and musical intervals with real-time feedback. Key deliverables include a fully optimized mobile experience, a functional relative intonation training system with real-time feedback, improved audio processing performance, and cross-platform stability for iOS and Android devices. The final result will be a more robust, scalable, and pedagogically effective mobile application, making music learning more accessible, interactive, and engaging.
Over the years, AnkiDroid has evolved in many ways but the UI has remained unchanging. This project aims to redesign how users navigate the app and also redesign the main deck picker. The main deliverables are: 1) Implement a Bottom Navigation Bar 2) Redesign the deck picker screen
The goal of this project is to build a standalone Open Banking fintech application using Kotlin Multiplatform that integrates with the Open Bank Project (OBP) APIs. This app will serve as a reference implementation demonstrating how third-party fintechs can leverage Open Banking standards (PSD2, UK Open Banking) to provide innovative financial services to users of Mifos/Fineract-powered institutions and beyond.
This proposal aims to improve the developer experience of using VLC in Unity. Right now, developers have to write extra boilerplate code and use raw strings just to play a video and configure settings instead of using standard Unity tools. I plan to change this manual setup into a simple plug and play experience. To achieve this, I will integrate standard Unity features like the Package Manager and ScriptableObjects for visual menus. I will also add useful features like video preloading, a playlist API, unified logging, and better demo scenes. Overall, this proposal aims to make the plugin much easier to use and reduce setup errors, which will encourage more developers to choose VLC for their projects.
MetaSSR already delivers fast SSR and does well on the benchmarks, which is promising. But the dev mode, tests, and error handling still need hardening to be production‑ready. This project aims to make MetaSSR more mature and production-ready, focusing on improving the API handler (the core idea of MetaSSR, Polyglot programming via MetaCall), stabilizing and adding feature to the dev mode, expanding tests, and improving CI/reporting and documentation. If needed, the work will include changes to the MetaCall Rust port to support MetaSSR reliability & maintainability.
This project focuses on redesigning Wagtail’s Bakerydemo so it better represents modern, real-world websites and larger content needs.The content strategy will broaden beyond breadmaking (e.g., city/community storytelling) while keeping templates and blocks generic and reusable. The work will be delivered incrementally through small pull requests, adding a theme-ready design system, reusable StreamField components, and broader content sections beyond breadmaking while keeping the architecture simple and maintainable. It will also strengthen multilingual and RTL support, improve mobile and zoom behavior, and expand demo data coverage for scale testing. The goal is to provide a more practical, accessible, and reusable demo experience for Wagtail users and contributors.
Sky engine is one of the oldest and most mature engines in ScummVM. One of the most popular games it powers is Beneath a Steel Sky that was created by Revolution Software in 1994. In 2009, Revolution Software created an enhanced version of the game for iOS, named iBASS. This project integrates the iBASS engine to ScummVM's existing sky engine.
This proposal targets the HSF 2026 idea Clad as a first class gradient engine in libtorch, a 350-hour project intended to make compiler-generated gradients available from LibTorch and, eventually, easier to reuse from the ROOT ecosystem. My goal is to build a practical and well-scoped integration path that allows a LibTorch C++ training loop to call Clad-generated derivative code for a small but meaningful subset of workloads. The primary implementation path is to wrap Clad-generated backward logic inside torch::autograd::Function, because the PyTorch C++ frontend explicitly supports custom autograd functions and presents them as the standard way to integrate optimized forward and backward code in extensions. If time permits and the API proves cleaner, I will also evaluate a custom-operator path based on the PyTorch C++ extension mechanisms. This proposal is intentionally scoped as a proof of concept, not as a general replacement for LibTorch autograd. A realistic first milestone is to differentiate selected training kernels or small model components written in C++, expose them to LibTorch, and measure where compiler-generated derivatives are correct, maintainable, and competitive. This produces a concrete result for mentors and also establishes a clear baseline for future work on broader operator coverage, deeper ROOT integration, or GPU support.
GeoSaurio is an interactive visualization project designed for the Liquid Galaxy platform that allows users to explore dinosaurs through their geographical distribution on Earth using Google Earth. The system uses the central screens to display the planet and show dinosaur locations through KML elements, while the side screens present detailed information about each selected species. Users interact with the experience through a Flutter-based companion application, where they can select geological periods and regions, explore dinosaur lists, and trigger visualizations on the Liquid Galaxy system. Each dinosaur includes structured information such as physical characteristics, diet, and visual comparisons with humans, along with additional features like fossil-to-reconstruction timelines, 3D models, and optional AI-based narration. By combining geospatial visualization, multi-screen interaction, and educational content, GeoSaurio provides an engaging and immersive way to discover prehistoric life and understand how dinosaurs were distributed across the planet.
ListenBrainz has an Android app but no iOS version. A previous Swift attempt just duplicated the codebase, meaning every bug fix had to be written twice. This project fixes that by migrating to Kotlin Multiplatform - one shared codebase for both platforms. Most of the work is tedious: swapping Android-only libraries for multiplatform equivalents across navigation, dependency injection, paging, and more. Media playback is trickier. ExoPlayer and WorkManager are too Android-specific to share, so both get wrapped behind common interfaces, with ExoPlayer on Android and AVPlayer on iOS underneath. One thing genuinely can't move: the notification listener that reads what's playing in Spotify relies on an Android-only permission iOS doesn't allow. Those screens stay Android-only, no workaround exists. Everything else: one codebase, both platforms.
Managing compliance today means juggling dozens of independent reports - SPDX, CycloneDX, CLIXML, ReadmeOSS - generated separately for each component, with no way to merge, track, or evolve them as a whole. This project introduces a Report Aggregator Tool for FOSSology and SW360 that consolidates multiple compliance reports into a single, authoritative document. Users will be able to select reports across formats, merge them through a transparent aggregation UI, inspect and edit the combined data with full traceability, and propagate changes incrementally when source reports are updated. With seamless integration into FOSSology’s agent framework and SW360’s project hierarchy, this tool will transform fragmented compliance artifacts into unified, audit-ready documentation - making FOSSology an even more complete solution for meeting regulation like the EU Cyber Resilience Act
This project focuses on redesigning the ListView component in MIT App Inventor to address key architectural, performance, and cross-platform consistency issues. Currently, the component suffers from inefficient full adapter rebuilds, lack of a structured data model, and inconsistencies between Android and iOS implementations. These issues lead to performance overhead, unreliable behavior, and poor developer experience, especially for beginners. To solve this, the project introduces a structured, phased approach: Core Refactor (Reliability): Introduce a dedicated ListDataModel to manage items, selection state, and filtering. This eliminates full adapter reconstruction and enables efficient incremental updates. Cross-Platform Consistency (Continuity): Establish a behavioral contract and parity tracking system to systematically align Android and iOS implementations, fixing missing features, type mismatches, and runtime inconsistencies. API Expansion (Extensibility): Add block-level operations such as AddElement, RemoveElement, UpdateElement, ScrollToElement, and SelectionElements, along with full multi-select support. User Experience Improvements: Enhance the Designer with a UIBinder-based list editor, keyboard navigation, and introduce a swipeable (carousel-style) layout for modern UI interaction. Deliverables Modular ListDataModel architecture with incremental update support Eliminated full adapter rebuilds and improved performance Android–iOS feature parity with validated behavior New block-level APIs and multi-select functionality Redesigned Designer editor with improved usability Swipeable ListView layout implementation Comprehensive testing, documentation, and backward compatibility assurance This project aims to make ListView more scalable, consistent, and beginner-friendly, while establishing a maintainable foundation for future enhancements.
This project introduces a firmware-backed persistent boot counter into the FreeBSD base system to address the early-boot entropy problem. During system startup, before the kernel’s random number generator is sufficiently seeded, certain subsystems may produce predictable values, which can weaken authentication mechanisms such as HMAC-based protocols. The proposed solution leverages the UEFI monotonic counter, accessed during the loader stage (before ExitBootServices), and transports it to the kernel using the existing metadata mechanism. The kernel exposes this value via a read-only sysctl (kern.bootcount), allowing early-boot consumers such as networking subsystems to incorporate it into their computations and ensure per-boot uniqueness. The implementation involves modifying loader.efi to capture the counter, extending the metadata pipeline, and adding a kernel module for ingestion and exposure. The project also includes a fallback mechanism for non-UEFI systems, a testing framework using QEMU/OVMF, and documentation. Deliverables include a working kernel interface, regression tests, documentation, and optional integration with subsystems such as SNMP and CARP via the opencrypto framework.
Identification of close kin is a critical quality control step for genomic analysis, as well as an analytical goal in itself. Demographic processes such as inbreeding, and variation in recombination rate over small genomes, may make accurate relatedness inference challenging for Anopheles taxa. Kinship statistics derived from the condensed Jacquard coefficients offer the possibility of more accurate relatedness estimation, especially where inbreeding is an issue. However, standard tools for these calculations such as NGSRelate are difficult to integrate into Python and use a computationally expensive expectation-maximization algorithm. The recent development of Kindred suggests a constrained least-squares formulation that may be fast enough to be used in an interactive environment. This project will develop a Python library that combines both approaches in a hybrid algorithm that should make estimating the Jacquard coefficients both fast and accurate. This library will be integrated into the MalariaGEN API and make relatedness estimation of Anopheles taxa accessible to a broad audience on Google Colab.
The Agent Conduit is a lightweight, self-hosted, unified agent gateway that addresses this problem end-to-end. Conduit is constructed around four pillars. An AAP-compliant Identity Server that provides each agent with its own cryptographic identity. A Platform Connection Registry that centralizes and governs credentials for Slack, GitHub, Google, and any REST API. A Token Router that provides tool schemas on demand rather than loading them all up front, and a structured Observability layer that attributes every action to the agent that took it.
This project adds zstd:chunked compression to Konflux builds while keeping compatibility with older Docker versions. It does this by pushing both gzip and zstd images in the same index, so older clients use gzip and newer ones get faster pulls. I’ll update build tasks, fix release pipeline issues caused by dual manifests, and ensure everything works with proper tests and docs. The result is faster image pulls with no breakage for existing users.
Apache Iceberg's Spark readers process scan tasks sequentially, causing significant overhead for small-file workloads on object storage where file open latency dominates. This idea introduces an optional parallel execution path in BaseReader by decoupling task opening from record consumption using a producer-consumer model built on Iceberg's existing ParallelIterable. A working prototype (PR #15341) benchmarked on AWS S3 shows 76.4% reduction in execution time for 1000 small files. Deliverables include a configurable async execution path, unit and integration tests, and documentation.
This task involves various enhancements, such as: "Clone" Support for Edge Slide: An option for the Edge Slide tool which, when enabled, duplicates the corresponding edges first and then slides them. See RCS#2rcbbc, RCS#QDbbbc. Edge Flow: Adjusts the edge loop via spline interpolation such that it respects the flow of the surrounding geometry. See RCS#vddbbc. Loop Cut Curvature Preservation: Option added to loop cutting that when enabled places loop vertices on the curvature of the surrounding geometry with spline interpolation rather than with flat linear interpolation. See RCS#fSdbbc Expected outcomes: Additional loop-editing operators available in edit-mode. Skills required: Proficient in C++, Linear Algebra. Possible mentors: Campbell Barton, Tariq Sulley Expected project size: 350 hours Difficulty: hard
The proposed Personal Finance Management (PFM) system for Mifos Pay Mobile represents a strategic evolution from a transaction-centric mobile wallet into a comprehensive financial intelligence platform. While existing mobile banking solutions primarily focus on enabling payments and account access, they often lack holistic tools that empower users to understand, manage, and optimize their financial behavior. This limitation is particularly significant for users in emerging markets, where financial literacy, fragmented account ownership, and limited access to advanced financial tools hinder effective money management. This project aims to bridge that gap by introducing a unified, intelligent, and extensible PFM layer built on top of the existing Mifos Pay ecosystem.