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 enhance Wayshot by implementing the newly standardized ext_image_capture_source_v1 Wayland protocol, which provides a standardized method for display and window capture, replacing the current dependency on the non-standard wlr-screencopy protocol. I will develop a new backend that fully utilizes this official protocol while maintaining the existing wlr backend for backwards compatibility, enabling native top-level window capture capabilities and improving user experience. The implementation will include a security notification system utilizing D-Bus to alert users which applications were captured by Wayshot clients, enhancing transparency and user privacy. Additionally, I will integrate the standardized protocol with xdg-desktop-portal-luminous to enable WebRTC streaming capabilities, The deliverables of this project are: a complete solution that includes the new backend, backwards compatibility, security notifications, WebRTC streaming support, and comprehensive documentation.
Implement an efficient Bloom Filter to reduce JOIN's computations. Idea is to apply Bloom filter on columns to filter the data as much as possible, and then feed the data to JOIN. This will significantly reduce the amount of memory taken by JOIN operation and increase its performance.
Pharo currently lacks robust, well-designed implementations of fundamental data structures, with existing collections being weakly supported and inconsistently designed. This project addresses this gap by developing a comprehensive library of essential data structures including Buffers, Linked lists, Stacks, Queues, Heap and various types of Trees (like Binary Search Trees, AVL, Red-Black & Tries) . The implementation will deliver a flexible, extensible framework with consistent APIs, thorough documentation, and comprehensive Test coverage. The result will be a production-ready collection of data structures that follow object-oriented principles, enhance developer productivity, and integrate seamlessly with the Pharo environment, enabling more efficient and maintainable code for the entire Pharo community.
Fuzzing is an automated testing technique that feeds random or unexpected inputs to programs to find bugs and security issues. OSS-Fuzz is a SaaS by Google that continuously runs fuzzers against open source projects to catch these issues early. This project aims to expand OSS-Fuzz integration across more KDE libraries, focusing on those that handle external inputs like file parsers and thumbnail generators, which are prone to parsing and memory bugs. By identifying high-priority targets, writing and setting up dedicated fuzzers, the goal is to catch potential vulnerabilities early and improve the security and stability of the KDE ecosystem.
This project aims to increase editorial coverage to 70-80% by automating creation with AI. Admins can generate editorials in bulk from the problem list, while authors can trigger generation during problem creation. The system validates editorials by testing solutions and automatically fixes issues found during validation.
This project aims to enhance connection pool management in Apache Seata’s AT/XA transaction modes by introducing a unified, user-friendly monitoring and configuration system. Currently, Seata lacks a visual and configurable interface for observing and managing internal connection pools, which are essential for maintaining performance and stability in distributed transaction processing. This project addresses that gap by developing a new console dashboard that displays real-time connection pool metrics (such as active, idle, and total connections) and provides controls for adjusting parameters like minimum/maximum connections, timeouts, and keep-alive durations. The solution will include front-end Vue components, back-end Spring Boot APIs, and a service layer to handle the core business logic. It will also include thorough unit and integration testing to ensure reliability and correctness. Deliverables include: 1. A real-time dashboard for connection pool monitoring 2. A dynamic console interface for configuration management 3. Backend REST APIs and business logic for pool metrics and settings 4. User and developer documentation 5. Comprehensive unit and integration tests
Jump Label Implementation aims to eliminate branch overhead in kernel code by dynamically patching JMP/NOP instructions at runtime using GCC's asm goto feature. This involves defining static branch templates (ARCH_STATIC_BRANCH_ASM for NOP cases and ARCH_STATIC_BRANCH_JUMP_ASM for JMP cases) and implementing core functions (arch_static_branch and arch_static_branch_jump) along with a runtime patching mechanism (arch_jump_label_transform). The key deliverable is near-zero-cost branch decisions, significantly improving performance for frequently checked kernel conditions like tracepoints and debugging checks. Ftrace Implementation provides efficient function tracing (function) and call-graph profiling (function_graph) with minimal overhead. The -pg compiler flag inserts mcount() calls that dynamically redirect to either a no-op stub (when disabled) or a full tracer (when enabled). The implementation includes dynamic redirection in mcount(), the core function tracer (ftrace_trace_function), and the extended function_graph tracer with entry/exit hooks (ftrace_graph_caller and return_to_handler). This enables deep call-stack analysis while maintaining low runtime cost when tracing is inactive, supporting dynamic kernel debugging with minimal performance impact.
The Contribution Hub will be a platform that helps newcomers find mentors for open source projects. The system will let users log in with GitHub, create profiles showing their skills, and get matched with the right mentors based on what they know and want to learn. Contributors will see a dashboard with project suggestions and issues that match their skill level. They'll also be able to track their progress and see how they're improving. For beginners, the platform will highlight easy-to-start issues and group similar tasks together for hackathons. The system will help solve common problems new contributors face by providing guidance, recommending tasks they can handle, and connecting them with experienced mentors who can help them grow. Regular feedback from both mentors and contributors will help make the platform better over time.
I propose to enhance the Mifos Initiative's Kotlin Multiplatform (KMP) Multi-Module Project Generator to streamline cross-platform application development and make it more valuable for developers. My plan is to create a customizable Material Design 3 component layer for a consistent UI across platforms, implement a unified configuration system, and enhance GitHub Actions workflows for comprehensive CI/CD. I'll develop pre-built infrastructure components (networking, database, storage), streamline dependency management with Gradle plugins, improve the sync directories system, add a type-safe API client with Ktorfit, and automate library publishing to Maven Central. With my experience in Kotlin (3+ years) and Kotlin Multiplatform (2+ years), plus my extensive contributions to Mifos projects, I have the technical foundation to implement these enhancements successfully. I've created a detailed 15-week implementation plan with clear deliverables for each stage. These improvements will transform the KMP Project Generator into a more powerful and user-friendly tool, benefiting both the Mifos ecosystem and the broader KMP community by reducing development time and ensuring best practices across platforms.
This project builds an AI-powered agent for KnowledgeSpace using Retrieval-Augmented Generation (RAG) to deliver precise, context-aware, and scientifically accurate answers. It combines Elasticsearch results with vector search (e.g., Vertex AI Vector Search) through an agentic system implemented in LangGraph, which orchestrates tool calls and fuses evidence for high-quality responses. The backend is a FastAPI service deployed on Google Cloud Platform with Vertex AI, and the frontend is a responsive React application. An automated update script regularly ingests new datasets and refreshes indices/embeddings to keep answers current. Together, these components streamline how neuroscientists explore and use complex neuroscience data.
The AQM Evaluation Suite is an automated framework based on RFC 7928 that simplifies simulation setup, topology creation, traffic generation, execution, and results visualization of AQM algorithms in ns-3. Originally developed in 2017 and maintained until 2019, the suite now needs an upgrade to: - Migrate its build system from waf to CMake - Integrate support for state-of-the-art AQM algorithms and enhanced ECN functionalities - Update simulation examples to reflect modern traffic control models and data center load balancing scenarios - Package and publish the suite on the ns-3 App Store
Xrefer currently functions as an IDA plugin for static binary feature extraction. The goal of this project is to abstract Xrefer’s core functionality into a flexible multi-backend pipeline supporting static analysis on IDA, Ghidra and Binary Ninja.
This project integrates Open Concept Lab (OCL) test concepts into OpenELIS-Global by parsing OCL ZIP files from a Configurations/ocl directory at startup, mapping them to the TEST table, and using checksums to process only modified files. It enhances lab standardization and interoperability, reducing manual setup time (e.g., 2 hours to 10 minutes) for technicians and ensuring consistent updates across sites for admins.
This project aims to develop a system that detects whether code was written by a student or generated by AI tools like ChatGPT or GitHub Copilot. With AI becoming common in academia, especially in programming, distinguishing genuine student work from AI-generated code is increasingly challenging. Existing tools like MOSS are ineffective against AI-generated content. The proposed system will assign a confidence score to indicate the likelihood of AI involvement, supporting educators in maintaining academic integrity.
FateCoin Protocol introduces an innovative decentralized finance platform enabling perpetual speculation on real-world events through a dual-token system (bullCoin and bearCoin). Unlike traditional prediction markets with expiration dates, our protocol maintains continuous liquidity via automated reserve redistribution and dynamic fee mechanisms. This proposal outlines the development of smart contracts for token economics, a responsive frontend with analytics, and cross-chain deployment - creating a self-sustaining ecosystem for price-linked asset trading.
I aim to enhance the Sprocket VSCode extension by integrating advanced language features for the Workflow Description Language (WDL) through the Language Server Protocol (LSP). This includes implementing go to definition, go to declaration, references, rename, auto-completion to improve the development experience for WDL authors. As a stretch goal, I will extend support to other editors like IntelliJ IDEA and Neovim
I'm tackling Casanovo's slow beam search decoding, which stalls big proteomics datasets. By reducing GPU-CPU transfers and removing redundant steps, I've cut its function run time by about 180 times. Next, I plan to add parallel and container-friendly setups so it can handle even larger loads across multiple machines. My final deliverables include code changes, tests, and documentation, helping researchers run analyses faster and more reliably.
This project will significantly enhance the PyLadiesCon Sponsorship Portal, a Django-based Python web application, by introducing advanced backend and frontend capabilities to better support sponsor engagement, tracking, and design team collaboration. Key features include an admin sponsorship review workflow with role-based access control, an automated notification system using Django signals and SendGrid, and a secure media upload portal utilizing Pillow, django-storages, and Amazon Web Services S3. A dynamic dashboard will also be implemented with real-time filtering and tracking of contract and payment status using Django ORM, PostgreSQL, and interactive frontend behavior powered by HTMX. To ensure a maintainable and scalable system, the project will adopt containerized development with Docker and maintain robust test coverage using pytest-django and coverage.py. The result will be a highly functional and production-ready platform that streamlines sponsorship operations and improves transparency across teams.
The goal of this project is to develop a multi-modal and open-source benchmark with which to evaluate Gemini 2.0. Open-source benchmarks are an unbiased way to test the ability of LLMs in different modalities. Current LLM benchmarks are mostly based on reasoning tasks and maths. However, there does not exist a gold standard LLM benchmark to assess creative thinking. This is a critical gap since creative thinking is essential for progress toward artificial general intelligence (AGI). To solve this, the project aims to extend current creative thinking LLM benchmarks and create a gold standard benchmark across four different modalities (text, image, video, and audio). Upon the project’s completion, a thorough multi-modal open-source benchmark for creative thinking and creative divergence will be created. This will be accompanied by the evaluation metrics of different models (including Gemini 2.0), along with documentation and custom evaluation scripts. Finally, an educational video explanation of the benchmark will be shared on my YouTube channel (https://www.youtube.com/@Green-Code/), which will serve as an introduction to developers and newcomers to the LLM field.
This proposal aims to develop an advanced hexahedral grid refinement framework (Owen et al. 2017), supporting single-threaded and multi-threaded environments. In the previous project, the generation of an initial hexahedral grid and grid refinement using the prepared templates were implemented. In this project, we will integrate novel features such as mesh smoothing specialized to the mesh after it and improved thread assignment mechanisms for robust multi-threaded processing. The deliverables include a complete implementation, extensive documentation via Doxygen, and unit tests using ctest.
This proposal aims to enhance Liquid Haskell’s name resolution mechanism by enabling qualified imports for both (logic) type and predicate aliases. Currently, ambiguities arise when identical aliases are exported from multiple modules, adversely affecting both user experience and internal processing. The proposed solution will modify the internal alias representation and update all relevant use sites to construct fully qualified names, thereby allowing users to disambiguate identical aliases. Additionally, the project will conduct a detailed study of predicate alias use cases to evaluate the potential deprecation of these aliases in favor of the overlapping functionality provided by inline annotations. The primary deliverables include merged pull requests implementing qualified import support for type and predicate aliases, comprehensive documentation, and a blog post detailing design decisions, implementation processes, and the outcomes of the predicate alias study.
The swift-java interoperability library provides the jextract-swift tool, which extracts Java sources that are used to call Swift code from Java. However, the tool uses the Foreign Function and Memory API (FFM), which requires JDK 22+, making it unavailable on platforms such as Android. The goal of this proposal is to extend the jextract-swift tool, such that it is able to generate Java sources using JNI instead of FFM and thereby allowing more platforms to utilize Swift/Java interoperability. The solution will modify the code generation to support multiple modes through a protocol. Thereby, allowing us to generate JNI Java wrappers that that utilize the JNI functionality already defined in the library. We will modify the current Arena implementations to support memory management for JNI as well, through calls to the Swift runtime. The library will also generate Swift thunks that implement the native methods defined in Java and handle JNI/Swift conversion and object initialization. The project will achieve feature parity with the current FFM mode and explore more complex language features, if time permits.
This proposal aims to improve Wagtail's Content Security Policy (CSP) compliance by organizing existing efforts, refactoring code, and creating/enhancing developer tools. It addresses scattered issues and a lack of clear guidance by consolidating discussions, completing pending code changes for style-src, script-src, and img-src compliance, and providing documentation and possibly automated testing. The project also includes collaboration with Django-CSP to improve its core functionality, which would result in a more secure and developer-friendly Wagtail release.