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 extend the plot module by implementing the missing building blocks needed for end-to-end chart creation. The work will focus on improving how data is mapped to visual representations, adding support for a broader range of visual elements, and enabling better composition of charts. Additionally, the project will introduce features for interactivity, layout management, and common data processing operations, making the API more practical for real-world usage. Each component will be developed with proper testing, documentation, and performance considerations to ensure reliability and consistency with the stdlib ecosystem. By the end of the project, users will be able to programmatically generate complete and reusable visualization specifications using a modular JavaScript API, without relying on manually written JSON.
This project implements the compiler infrastructure—including missing intrinsics and lang items—required to compile Rust’s alloc crate in GCC Rust (gccrs). The work focuses on bridging architectural gaps and ensuring alloc is ready for integration once core support is finalized. Deliverables include core heap-related functionality, regression tests, and documentation of the resolved compiler limitations.
Modern object-oriented binaries depend heavily on vtables, RTTI, and dynamic dispatch. Rizin's current class and vtable analysis is siloed and not integrated with the type system or decompiler. This project finishes the 2025 Objective-C inheritance PR (#5415), then adds field recovery, constructor/destructor identification, exception metadata extraction, and improved devirtualization. The core goal is a bidirectional bridge between class metadata and RzBaseType so recovered structures can be used directly in analysis and the decompiler.
Eclipse ThreadX is an open-source, safety-certified real-time operating system (RTOS) deployed on over 12 billion devices. Currently, the developer onboarding experience is limited to a single evaluation board (MXChip AZ3166) with residual coupling to Microsoft Azure IoT services. This proposal addresses this gap by creating use-case-driven starter applications for at least three distinct evaluation boards, prioritizing STMicroelectronics with a RISC-V target as a stretch goal. The project will deliver real-world embedded scenarios like an Environmental Monitoring Station, an Embedded Web Dashboard, and an Industrial Data Logger. Additionally, it provides a reusable starter template for future boards, comprehensive documentation, and a CI/CD pipeline for automated build validation.
AOSSIE, as a non-profit educational organization, serves as a hub for impactful open-source projects. However, many of these projects lack modern, user-focused landing pages that effectively communicate their value. This project aims to design and implement high-quality, scalable landing pages that enhance visibility, usability, and adoption across AOSSIE projects. I will go beyond visual design by incorporating robust engineering practices, including internationalization (i18n), localization (l10n), WCAG 2.2 accessibility compliance, and optimizations for performance, SEO, and security. Using a reusable, component-based approach, I will ensure consistency and maintainability across all implementations. The goal is to create interfaces that are not only visually appealing but also intuitive, accessible, and aligned with real user needs. Ultimately, this project focuses on elevating AOSSIE’s overall product experience, transforming landing pages into powerful tools for communication, engagement, and growth, while establishing a scalable design and development standard for future contributors.
The current GIMP Shortcut Dialog is outdated and not so user-friendly. During this GSoC term (2026), I can contribute improving the Shortcut Dialog. I have planned to implement these five major changes in the shortcut editor. 1. Support for importing and exporting shortcut profiles 2. Replacement of the deprecated GtkTreeView with side-by-side categorized lists to improve navigation. 3. Active keybinding search to quickly locate actions by assigned shortcuts. 4. Ability to assign and manage multiple shortcuts per action. 5. Add the missing icons
This project implements a new storage backend for ThingsBoard using Apache IoTDB 2.X's table mode. It introduces new DAO implementations (IoTDBTableTimeseriesDao, IoTDBTableLatestDao, IoTDBTableBaseDao) built on ITableSession, using Tablet-based writes and standard SQL queries. The design adopts a single generic table with TAG columns for tenant, entity, and key filtering, supports direct SQL aggregation via date_bin(), and relies on native TTL for data retention. The approach has been validated through a working proof of concept (https://github.com/PDGGK/thingsboard-iotdb-table-poc), tested against IoTDB 2.0.5 with all proposed access patterns. Deliverables include the full DAO implementation, Docker-based integration tests, performance benchmarks, and migration documentation.
Parents and caregivers increasingly turn to social media for pediatric ENT advice, where misinformation about conditions like ear infections and hearing loss spreads rapidly and without clinical oversight. This project builds a production-ready, open-source AI surveillance system that monitors Reddit, YouTube, TikTok, and Instagram in real time, classifies emerging trends as HARMFUL, CONCERNING, or SAFE using a 6-node LangGraph agentic pipeline grounded in live PubMed evidence retrieval, and surfaces results to clinicians through a Next.js dashboard with SSE alerts and email notifications for high-risk trends. A working 4-node prototype validated on live Reddit and YouTube data is already implemented. The GSoC deliverables extend this foundation with TikTok and Instagram collectors, ASSESS and REPORT nodes, a production Next.js dashboard replacing the existing Streamlit prototype, APScheduler end-to-end integration, Docker Compose deployment, and formal evaluation against a 300-post clinician-labeled reference set targeting precision > 0.85 on HARMFUL and F1 > 0.80 overall.
The current Alpha One Labs platform (alphaonelabs/website) is feature-rich but built on an older Django-based architecture, while the new alphaonelabs/learn repository introduces a modern Python Cloudflare Workers stack with an encrypted database model that is not yet fully complete. This project focuses on migrating all relevant features from the existing platform into the new Learn repository, while adapting them to the Workers based architecture and ensuring full frontend integration. Along with migration, the project will also strengthen the existing encryption model and ensure secure handling of user data within the constraints of the Cloudflare Workers environment. The goal is to build a fully functional, production-ready system that preserves core learning workflows such as courses, sessions, study groups and communication features. The migration will follow a structured approach starting from backend logic, then database integration using Cloudflare D1 and finally connecting the frontend for complete end-to-end user flows. Along with this, the system will be improved by modularizing backend services, removing unnecessary components and maintaining a clean, scalable and secure architecture for future development.
This project aims to enhance Checkstyle by providing complete and up-to-date support for the OpenJDK Code Convention and the emerging OpenJDK Java Style Guidelines. The current implementation, based on the outdated sun_checks.xml configuration from 2004, lacks coverage for many modern rules and newly introduced Checkstyle modules. This project will systematically review both old and new guidelines, implement missing checks, refine existing configurations, and resolve known issues. The goal is to make OpenJDK coding conventions fully enforceable within Checkstyle, improving code quality and developer experience. Key deliverables include updating configurations, adding new modules where required, improving test coverage, and creating detailed documentation to clearly represent rule coverage and support levels.
This project adds a combinator builder to WP1 that lets users combine multiple existing selection builders into one result. Instead of using just one method, users can mix different builders using simple operations like union, intersection and difference. The goal is to make it easier to create flexible and powerful article selections while keeping the interface simple and easy to use. The project includes designing the system, building a clear UI, and making sure it works efficiently.
This project aims to port EROFS to FreeBSD kernels, providing a native implementation of EROFS that allows users to mount native EROFS images directly. This project will integrate EROFS with FreeBSD’s VFS, buffer cache, and VM systems, and lay groundwork for future BSD ports (OpenBSD, NetBSD).
This project aims to extend the Julia linear algebra ecosystem by developing vendor-agnostic GPU kernels in NextLA.jl for large-scale structured matrices. It focuses on tile low-rank (TLR) representations, which exploit low-rank structure to reduce computational cost and memory usage. The project will implement truncated SVD routines and core TLR arithmetic kernels, including low-rank GEMM, TRSM, and SYRK with adaptive truncation. These kernels will serve as building blocks for large distributed TLR algorithms, demonstrated through the implementation of a distributed TLR Cholesky factorization. By the end of the project, NextLA.jl will provide a portable, composable foundation for GPU-accelerated distributed linear algebra.
The more notes you accumulate, the harder it gets to keep them organised. At some point, manually tagging things or deciding which notebook something belongs to just stops happening and things pile up. What I'm building is a plugin that handles that quietly in the background. It analyses your notes, figures out which ones are about similar things, and suggests tags and notebook structures that reflect what's actually in your collection. You review the suggestions, pick what makes sense, and apply them. Nothing changes without you saying so. The deliverables are the plugin, the embedding and clustering pipeline, the recommendation system, and the review UI.
KubeVirt extends Kubernetes with virtual machine (VM) APIs, virt-api is the component that serves these APIs to the cluster. Historically, the virt-api component has relied on a custom HTTP server implementation to manually handle TLS, authentication (Authn), authorization (Authz), API discovery, and OpenAPI serving. This VEP proposes migrating virt-api to the k8s.io/apiserver library to leverage the standard Kubernetes API server infrastructure. Adopting this upstream standard will significantly reduce maintenance overhead and enable seamless security updates for the system.
AsterixDB currently assigns static memory budgets to memory-intensive operators (join, sort, group-by) that never change during execution, leading to memory underutilization and performance degradation under concurrent workloads. This project implements a dynamic memory resource broker for AsterixDB that reallocates memory between operators at runtime based on demand and priority. The broker maintains a reserve pool for immediate grants and a priority queue to track operators approaching memory pressure, allowing for the victimization of low-priority operators when needed. Key deliverables include the resource broker implementation, a memory-adaptive hash join operator, TPC-H benchmark results comparing dynamic vs static allocation, and an extensible interface for future memory-adaptive operators.
Currently Jitsi uses traditional Picture in Picture in Electron application. Browser meetings support is not yet implemented. This idea proposes to implement Document Picture in Picture for browser meetings for supported browsers and traditional Picture in Picture otherwise. Document Picture in Picture mode allows to embed arbitrary HTML contents. The idea will be to use React's portal to create interactions buttons inside the Document PiP window that will share the redux state change. Interactions such as audio/video toggle, chat window will be added. Apart from that, different layouts such as compact, gallery, speaker will also be available inside the window.
This project completes VLC netsync and then enables fully Rust-written VLC modules by introducing Rust bindings for the vlc_player API. The work is carried out in three stages: first, rebasing and restoring the existing Player Clock API and netsync implementation on current VLC master; second, developing a new vlcrs-player binding crate with safe Rust abstractions over vlc_player.h; and third, rewriting the netsync module entirely in Rust. The final deliverables include a restored netsync implementation, a reusable Rust player binding crate, and a pure-Rust VLC module that serves as a reference for future development.
The project develops an improved Python-based CLI for the CBRAIN distributed computing platform, aiming on usability and modular design. It replaces complex command usage with interactive, prompt-based workflows, reducing reliance on memorization. The system leverages existing CBRAIN API routes and restructures the codebase into a clean, feature-based architecture. It supports user, project, file, task, and data provider management, along with advanced operations like authentication, batch processing, multi-session, data upload / download, file querying / selection and server control. Administrative tools for logs, quotas, and system monitoring are included. Overall, the project delivers a scalable, maintainable, and user-friendly CLI that enhances productivity.
This project aims to implement a native Java based LDAP authentication provider in Uyuni to eliminate dependency on OS level authentication mechanisms such as SSSD and PAM. The solution will enable administrators to configure LDAP integration directly through the web UI while supporting automatic mapping of LDAP groups to Uyuni roles. The implementation will extend the existing authentication flow by integrating LDAP authentication within UserImpl.authenticate without requiring major refactoring. It will include secure bind and search operations, efficient connection pooling, and seamless coexistence with existing local and PAM based authentication methods. Additionally, the project will introduce dynamic RBAC mapping where LDAP groups are mapped to Uyuni roles at login time, ensuring correct permissions without manual intervention. A configuration interface in the Admin Setup section will allow administrators to manage LDAP settings and role mappings easily. The final deliverable will be a scalable, maintainable, and secure authentication system that improves usability and enterprise readiness of Uyuni.
This project aims to build an automated performance regression detection system for the D compiler (DMD). It introduces a PR-based benchmarking bot that compares changes against the master branch and reports meaningful differences in compile time, memory usage, and binary size. Alongside this, a modular benchmark suite will simulate real-world and synthetic workloads to ensure accurate measurements. A lightweight dashboard will track performance trends over time, helping identify regressions and evaluate optimizations. The system is designed to be practical, maintainable, and tightly integrated with the existing D ecosystem.
This project aims to extend SourceKit LSP to add DocC Language features like go-to-definition and diagnostic support for missing or broken symbol links. It also enhances the documentation preview by making it interactive with clickable symbol links and web URLs, along with syntax highlighting for .tutorial and .md files.
I work on Gitcord, a tool that connects a GitHub organization with a Discord server to help track and manage open-source contributions. The system will collect GitHub events such as issues, pull requests, reviews, and merges, store them locally, and calculate contributor scores based on configurable rules. The automation will follow a simple pipeline (Read → Plan → Report → Apply) so that every action can be reviewed before it is applied. To keep the system safe, it will run in dry-run mode by default and generate audit reports for maintainers. The project will also include a Discord bot that allows contributors to interact with the system directly from Discord. Contributors will link their GitHub and Discord accounts using a verification step instead of OAuth. Through bot commands, users will be able to check contribution summaries, view pull request information, request issues, and receive notifications about reviews, assignments, and merged pull requests. Gitcord will follow a local-first approach, storing data in a SQLite database rather than relying on external services. It will maintain records such as contribution history, identity mappings, audit logs, and notification history. The project will also include documentation, YAML-based configuration, Docker support, and automated tests so that organizations can deploy and maintain the system more easily.
The NOS OFS Skill Assessment package is a Python-based framework used to evaluate operational forecast systems (OFS) through observation retrieval, model processing, skill computation, and visualization. As the system continues to evolve, gaps in automated testing, continuous integration, and user-facing validation create challenges in maintaining reliability and usability. This project focuses on improving developer and user experience without modifying the scientific computation pipeline. The primary objectives are to introduce a GitHub Actions-based CI workflow, expand deterministic unit test coverage across core modules, and enhance the existing tkinter-based GUI with structured parameter grouping, validation logic, and contextual tooltips derived from existing argument definitions. In addition, the project will improve contributor onboarding by restructuring documentation using MkDocs. A lightweight, read-only dashboard will also be explored to organize and present outputs from completed skill assessment runs, providing a concise operational overview.