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.
OSS-Fuzz-Gen, a framework using LLMs for fuzz target generation and evaluation by Google, currently has a basic experiment report UI alongside a manual CI workflow requiring significant oversight. This proposal introduces an improved report interface amongst other features to improve usability and data presentation. Concurrently, the project will streamline the experiment execution workflow for developers and security researchers by introducing more automation into the CI pipeline.
The Mifos Mobile Wallet is a powerful reference application aimed at accelerating financial inclusion. However, to be effectively used in real-world deployments especially for Government-to-Person (G2P) disbursements and merchant transactions it requires further enhancements. This project will make the mobile wallet production-ready by addressing technical gaps and extending its capabilities. Key goals include integrating the latest version of the Mifos Payment Hub EE for seamless payments, implementing support for Request-to-Pay (R2P) using the Mifos notification framework, strengthening security, and updating the wallet to use the latest fineract-client-kmp-sdk. To support scale and usability, CI/CD pipelines will be added for automating iOS and desktop app deployments using GitHub Actions and Fastlane. The final deliverable will be a robust, secure, and cross-platform wallet ready for real-life G2P and merchant use cases, aligned with open digital finance standards like those championed by the Open Wallet Foundation.
Ell-ena is a smart, AI-powered productivity assistant that helps individuals and teams manage tasks effortlessly through natural language. Just say things like “Create a dark mode ticket” or “Add math assignment for tomorrow,” and Ell-ena takes care of the rest. Ell-ena uses function-calling APIs to understand your commands and a Graph-based RAG system to intelligently link tasks, projects, and deadlines. Its AI-powered bot can join meetings, transcribe conversations in real time, and extract actionable insights for the team. With Supabase handling data storage and real-time syncing, along with multiple views like calendar and Kanban boards, Ell-ena keeps tasks organized and collaboration smooth across all your teammates.
In the Python Spatial Analysis Library (pysal), the spopt package is concerned with the formulation and solving of various spatial optimization problems, particularly regionalization and location-based problems. This project proposes to enhance the spopt package with a route module, which will function as an API to set up and solve vehicle routing problems (VRP), including parameterizing vehicles, depots, and routes in various VRP setups.
The OWASP Bug Logging Tool (BLT) is adopting a gamified, AI-powered blockchain rewards system to incentivize open-source security contributions. This project will integrate BACON tokens deployed on Bitcoin Ordinals and Solana, enabling developers to earn rewards for bug reporting, issue resolution, and community engagement. AI-driven scoring will assess the quality of blog posts, issues, and suggestions, ensuring high-value contributions. The initiative also includes staking mechanisms, automated token distribution, and a non-custodial wallet system, fostering transparency, participation, and decentralized rewards within OWASP BLT.
In this project, I am going to add improvements to FOSSology by making the Scancode integration faster and more stable using multithreading. I will also add a feature on the upload page that lets users select reports from OSSelot to reuse during analysis.Using the current spasht implementation to fetch the details of the folder from OSSelot. I will enhance the functionality of the existing Import Dump and Export Dump features to support reuse based on reports. Additionally, I will create a new page where users can easily contribute their FOSSology-generated reports back to the OSSelot project as GitHub pull requests. I will also write test cases to ensure the reliability of import/export functionality.
Abstract: This proposal outlines a plan to enhance Meshery's relationship evaluation capabilities by implementing client-side policy evaluation using WebAssembly. By integrating OPA's WebAssembly compilation capabilities into Meshery's UI, I aim to enable real-time evaluation of complex Rego policies, providing users with immediate feedback on configuration changes and policy compliance. This enhancement will significantly improve the user experience when designing their designs and will make the policy evaluation distributed hence reducing load on a meshery server Problem Statement Meshery currently doesn't support evaluating policies in real-time on the client side. The existing approach ( relying on the rest api interface exposed by meshery-server) introduce s latency when policy evaluation occurs server-side, limiting the responsiveness of the UI when users make configuration changes. Additionally, as policies become more complex and numerous, the ability to quickly validate configurations against these policies becomes increasingly important for a smooth user experience. Proposed Solution: Use opas capibilty to compile rego policies directly into wasm plans and then integrate the evaluation process in ui using OPA's JavaScript SDK, which provides a simpler way to load and evaluate Rego policies compiled to WebAssembly. This approach is more lightweight and performant . Deliverables : - Real time evaluation of policies in ui - Keeping the support for both targets of evaluation backend or realtime on frontend - Making the evaluation responsive and performant by implementing webworkers , caching
This project extends GNOME Crosswords' existing rendering facility to support printable puzzles with clues, and integrates printing support with crossword-specific options. It also has stretch goals, including broader puzzle support and an `ipuz2pdf` export utility.
The project's main target is to start using fwupd plugins to manage and handle the firmware updates, for touch controllers in ChromeOS. Currently, the way that these firmware updates are handled are using shell scripts that manage the firmware updates, and makes use of external open-source updaters utilities to handle the updates. This project aims to build out a handful of fwupd plugins for touch controllers through the fwupd repo, which will then be integrated into ChromeOS. The touch controllers workflow will also be updated accordingly to make use of the newly integrated plugins, and replacing the old touch controllers firmware updaters.
This project aims to enhance the reliability of ChromeOS input devices by improving kernel-level logging and using automated tests to validate firmware behavior and verify upgrade/downgrade procedures. Key objectives include developing better error logging during device probe failures, creating automated tests to verify firmware versions, and ensuring smooth firmware updates. Non-goals include altering the firmware itself or implementing hardware changes. The project focuses solely on refining testing and logging to reduce failures and improve maintainability.
Refactor the messaging and notification features of the Talawa Admin code base to reduce technical debt, enhance security, and introduce new features related to notifications. Focus on improving the features and related UI/UX while ensuring the code meets modern best practices.
This proposal aims to enhance the visualization system of Mesa, an agent-based modeling (ABM) framework in python, to make it more modular, user-friendly, and feature-rich. The project addresses two key issues in the current visualization system: clumped API design and difficulties in model sharing. The implementation plan is divided into two phases: 1) Phase 1 focuses on creating a more modular API for space drawing by developing AgentPortrayalStyle and PropertyLayerStyle components, separating agent drawing from grid drawing with a CoordinateMapper, and creating a unified SpaceRenderer class. 2) Phase 2 implements model sharing through links, upgrades the Altair visualization backend to match matplotlib capabilities and improves documentation. Deliverables include: a separate and intuitive visualization API, easy model sharing functionality, an improved Altair backend and comprehensive documentation. This upgrade will significantly improve the user experience for Mesa users.
This project proposes the development of an R data package designed to support teaching and exploration of data visualization through the lens of ecotourism in Australia. The package will integrate wildlife sighting records, domestic tourism data, and weather information into well-documented, tidy datasets. These datasets will enable users to practice map-based plotting, time series analysis, and spatial joins in R. Inspired by packages like nycflights13 and palmerpenguins, this project emphasizes real-world applications and reproducibility. The final product will be CRAN-ready and accompanied by a detailed vignette.
The state of Julia GPU support ranges from “very good” (CUDA.jl) to “on the way” (Metal.jl). Recently, the shared high-level interface GPUArrays.jl added support for KernelAbstractions.jl, which defines a common interface that can be used to write optimized kernel implementations once for all the downstream vendor-specific GPU packages such as CUDA.jl, AMDGPU.jl, Metal.jl, and oneAPI.jl. However, most optimized kernel implementations still live in the vendor-specific package they were written for, leaving the other packages to either reimplement their own version, use the current unoptimized fallback implementation from GPUArrays.jl, or in many cases, the operation is not supported. This project aims to rewrite these optimized operations in GPUArrays.jl using the KernelAbstractions interface to improve performance and functionality for all GPU backends at once. The end result being that users of the less mature backends will benefit from more functionality, as well as increasing the impact of future contributions for all users of the JuliaGPU ecosystem.
This project will deliver a performant integrated Raster Brush Tool alongside a basic Brush Profile Editor. The core implementation uses a real-time overlay preview for smooth interaction and a robust atomic command structure enabling multiple user-selectable undo modes. Key deliverables include the core draw/erase tool, the editor for viewing/modifying key brush parameters , support for standard brush presets and parameters , reliable undo functionality across implemented modes, and fully animatable raster output integrated into synfig.
Multimodal Embedding Explorer (MMEE) is an interactive platform for exploring, cleaning, and validating large-scale multimodal datasets combining images and text. It unifies data inspection, embedding visualization, and quality diagnostics into a single interface, reducing manual effort and tool fragmentation. MMEE allows users to generate and visualize joint embeddings using transformer-based models like CLIP, revealing semantic inconsistencies and annotation noise. Key modules include data ingestion, embedding computation, 2D/3D projection (PCA, UMAP, t-SNE), and interactive validation through image–caption inspection and anomaly detection—empowering faster, more reliable multimodal AI development.
It focuses on maintaining and improving the AsyncAPI VS Code extension to ensure stability, better usability, and full support for the latest AsyncAPI specifications. The work includes modernizing the codebase, adding real-time linting and validation, improving the document preview experience, automating release workflows, and enhancing contributor documentation. The goal is to deliver a well-documented, user-friendly, and production-ready extension that improves the overall developer experience.
This project aims to extend the ArduPilot Software-In-The-Loop (SITL) environment to support episodic reinforcement learning (RL). Rather than simply applying RL algorithms such as Q-learning, SARSA, or actor–critic, the primary goal is to develop and integrate an episodic framework that enables: • Monitoring and controlling simulation time; • Programmatically resetting the UAV state (position, velocity, attitude, etc.); • Capturing and replaying states for analysis. This framework, implemented primarily in Lua (with potential Python support for data processing and visualization), will establish a robust cycle where each episode is initiated, executed for a predetermined duration, and then restarted. By focusing on a reliable reset mechanism to return the UAV to a consistent starting state, the project creates a solid foundation for the eventual application of RL algorithms within the constraints of the SITL environment.
Contemporary developments of Machine Learning Applications in real-time Networks to classify traffic for better security and performance are examples of cutting-edge research happening. This growing idea begs for an efficient framework of ML Models to adapt to needs and match the expected output, more like making a General ML Model into a Network domain-specific ML one. This project aims to adapt the SpliDT Framework, a partition-based approach for implementing decision tree inference directly in the data plane using P4. It will be optimized through TensorFlow, and HyperMapper and using Python libraries like scikit-learn.
OpenTRIM is a C++ Monte Carlo simulation framework that models the interaction of ions with matter, tracking energy deposition and defect creation. Currently, it includes a fixed tallying system for recording standard outputs, such as energy lost to ionization or defects. This project aims to extend OpenTRIM's capabilities by implementing a flexible, user-customizable tally system. The new tally system will allow users to define, via JSON configuration, what simulation events to track (e.g., ion stopping, vacancy creation), how to bin data (e.g., in cylindrical or Cartesian coordinates), and what physical quantities to record (e.g., ion depth, deposited energy). It will be implemented as a new class hierarchy in C++, inheriting from the existing tally class, and will make use of the ArrayND data structure for multidimensional data storage. Deliverables include: a) A customizable tally class with support for user-defined event handling b)JSON-configurable tally setup (geometry, energy bins, spatial bins, etc.) c) Sample tally implementations (e.g., ion range profiling) d) Unit tests, documentation, and tutorials for extending the system This work will empower researchers and developers to tailor OpenTRIM output to their specific simulation needs, improving its usability and scientific value.
Chainvoice is a decentralized invoicing platform that simplifies the crypto billing process by automating invoice creation, tracking, and payments on-chain. This project aims to enhance the system by introducing features such as multi-token payment support, batch invoice creation, privacy enhancements, and overdue invoice detection with reminder automation. These improvements will streamline the invoicing process for individuals and businesses, making Web3 financial workflows more user-friendly, secure, and efficient.
Devr.AI is an AI-powered Developer Relations (DevRel) assistant designed to seamlessly integrate with open-source communities across platforms like Discord, Slack, GitHub, and Discourse. It acts as a virtual DevRel advocate, helping maintainers engage with contributors, onboard new developers, and provide real-time project updates. By leveraging LLMs, knowledge retrieval, and workflow automation all aligned using an event driven system, enhances community engagement, simplifies contributor onboarding, and ensures open-source projects remain active and well-supported.
One of the most important physical quantities in particle physics is the cross section, or a probability that a particular process takes place in the interaction of elementary particles. Its measure provides a testable link between theory and experiment. It is obtained theoretically mainly by calculating the squared amplitude. While the calculation of amplitudes for a particular expression is trivial, mapping it to a squared amplitude is computationally expensive. Previous works demonstrated that transformer-based (vanilla and KAN-infused) models can map amplitudes to squared amplitudes substantially faster and with high accuracy. However, transformers suffer from quadratic complexity due to self-attention, making them less efficient when handling extremely long sequences. Additionally, they may struggle with structured, hierarchical dependencies that naturally arise in amplitude computations. Inspired by Classical State Space theory, State Space Sequence Models (SSMs) emerged as a promising class of architectures for sequence modelling. These models can be interpreted as a combination of RNNs and CNNs. These models have near-linear scaling with sequence length, making them effective for long-range dependencies. This project will explore using SSMs for squared amplitude calculations. There are 2 major aims of this project 1. To develop novel hybrid models that combine state-space models (SSMs) with attention mechanisms for squared amplitude calculations. 2. A systematic evaluation of already existing models and SSMs on feynman interaction datasets and their scalability with respect to dataset size, maximum sequence length etc.
This project aims to develop a GNOME Shell extension that provides a user-friendly graphical interface for managing the OpenAFS client on Linux desktops. OpenAFS, a distributed file system widely used in academic and research environments, currently relies on command-line tools, which can be intimidating for users accustomed to graphical interfaces. The extension will integrate into the GNOME Shell top bar, offering a dropdown menu to start/stop the OpenAFS client, acquire and manage authentication tokens, and display key status information such as token expiration and cell connectivity. Deliverables include a fully functional extension with client control, token management, status indicators, and notifications, all developed using GJS and GNOME Shell APIs. The project will be completed over 12 weeks, with iterative development and testing to ensure a polished, user-friendly tool.