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.
LFortran's MLIR(Multi-Level Intermediate Representation) backend executes fortran code via LLVM dialect of MLIR, but requires major refactoring with every new MLIR version. This is because it calls unstable MLIR C++ APIs directly, which gets changed with MLIR version changes. This project focuses on finding the right design to solve this problem. Multiple approaches will be studied and compared including studying projects which support MLIR to identify the most stable and maintainable architecture. The best design will then be implemented and validated. The deliverable is a redesigned MLIR backend that is stable across MLIR versions, requiring minimal refactoring for adding support for newer versions in future.
OWTF's proxy silently drops every HTTPS transaction, blocks the entire event loop during live interception, and is written in deprecated Tornado coroutine syntax that prevents proper asyncio integration. I plan to fix this by rewriting the proxy core to use async/await throughout, replacing the threading-based CONNECT tunnel with a proper asyncio-native forwarding pipeline, and routing decrypted HTTPS traffic through the same CacheHandler and TransactionLogger chain that HTTP already uses. The result will be a proxy that records all traffic (HTTP and HTTPS), supports request and response modification hooks for both protocols, and does not freeze under concurrent load. Deliverables: async/await rewrite of proxy.py and main.py, working HTTPS transaction recording with PostgreSQL entries, fixed interceptor hook pipeline applying to both protocols, binary response handling using a bytes buffer instead of string accumulation, in-memory LRU cert caching, upstream cert CN/SAN mirroring, and functional tests covering each of these.
CircuitVerse provides a powerful digital logic simulator, but its classroom workflow lacks critical features required for effective teaching at scale. Currently, instructors cannot organize students into structured teams, assign collaborative work, reuse pre-built circuit templates, or rely on modern LMS integrations due to outdated LTI 1.1 support. These limitations lead to inefficient grading, repeated manual setup, and poor integration with platforms like Canvas. This project aims to enhance CircuitVerse’s classroom ecosystem by introducing four key improvements. First, a subgroup system will enable instructors to divide students into teams with defined roles, supporting structured collaboration. Second, group-based assignment workflows will allow submissions on behalf of a team, ensuring consistent grading and reducing redundancy. Third, a circuit template library with integrated test cases will enable reusable, pre-configured assignments and automated grading using a simulation-based evaluation pipeline. Finally, the project will upgrade LMS integration by implementing LTI 1.3 using OpenID Connect and OAuth 2.0, enabling secure authentication, deep linking, and modern grade passback via Assignment and Grade Services (AGS). The deliverables include: A fully functional subgroup and team management system with API support Group assignment workflows with submit-on-behalf functionality A template library with auto-grading using simulation-based test cases Complete LTI 1.3 integration including OIDC login, deep linking, AGS score submission, and NRPS roster access Comprehensive RSpec test coverage and documentation By addressing these gaps, this project will transform CircuitVerse into a scalable, LMS-integrated teaching platform capable of supporting modern classroom workflows and institutional requirements
According to the Google Summer of Code (GSoC) project ideas listed for One proposed DeepChem project involves adding support for the OLMo Large Language Model (LLM) family to the DeepChem repository using the Hugging Face Model wrapper. The goal of this project is to enable DeepChem users to perform tasks such as text generation, classification, and continued pretraining with large language models, including Open Language Model (OLMo). I have already contributed several improvements to DeepChem’s HuggingFaceModel integration, including improving typing and validation for the fill mask method and implementing a new generate() function that wraps HuggingFace’s text generation API. I have also already demonstrated partial compatibility with OLMo models through recent contributions to the generate() function and example scripts using allenai/OLMo-1B-hf. I have also added support for causal language modeling in the HuggingFaceModel wrapper, including integration with AutoModelForCausalLM and end-to-end validation through unit tests. My contributions demonstrate familiarity with the DeepChem codebase and provide the foundation for extending DeepChem to support large language models such as OLMo.
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.