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 provides a master interface that showcases a dashboard of expansive forests around the globe and allows users to explore them. Its primary aim is to create an interactive and immersive geospatial visualization system that allows users to explore in-depth major forested land masses affected by recent environmental changes. The application exploits the Liquid Galaxy rig to achieve its visualization while gliding through a smooth user experience.
KDE’s painting application Krita does not have a floating action bar for selection tools. When users work with selections on a layer in Krita, there is no UI to display common selection actions. This makes it difficult for non-keyboard users to switch between modes and is not intuitive for new or experienced user interaction. The idea is to create a toggleable floating toolbar that will allow users to switch between commonly used actions without having to read deep into user manuals or require a keyboard shortcut. This feature would improve accessibility and the overall experience of users by introducing an ‘on-screen’ toggleable shortcut for common selection actions. My goal is to develop the UI, test rigorously, join the community, get user feedback, and create documentation through user guides and tutorials.
This project aims to create a ROS2 package that automatically converts C/C++ structs into ROS2 messages and generates the corresponding TypeAdapters. This removes the need for developers to manually define message files or boilerplate conversion logic, making it easier to use C/C++ structures directly in ROS2. The package uses castxml to generate an abstract syntax tree, parse it with pygccxml, and extract c/c++ structs definations. Then, Jinja templates are used to generate ROS2 msg files and the corresponding Type Adapter from the parsed data. For opaque or external library types (e.g., Eigen), the system will support a mechanism to register custom TypeAdapters, allowing users to define conversion logic manually that can be included by other ROS2 packages. Deliverables: - Parser using castxml + pygccxml to extract struct definitions and a Jinja-based generator to produce ROS2 Message files and Type Adapters. - CMake macros/functions that can be used in ROS2 packages to register generated msg files to rosidl and install the type adapters. - Examples demonstrating usage of CMake functions/macros, auto-generated messages and type adapters in other packages.
LLM4S aims to establish Scala as a premier language for building multimodal Large Language Model applications. This project extends the toolkit's capabilities beyond text processing to support image generation, speech-to-text, text-to-speech, and multimodal embeddings. By leveraging Scala's type safety and functional programming paradigms, we will create APIs that enable seamless integration of visual, auditory, and textual modalities while maintaining enterprise-grade reliability. The implementation will bridge Python-centric AI ecosystems with Scala's performance advantages, offering developers a robust alternative for building complex multimodal AI systems.
This project aims to extend AsyncAPI suite of community maintained, production ready templates by developing and maintaining a new Java + Quarkus template for generating asynchronous applications using AsyncAPI’s generator repository. Quarkus, a Kubernetes-native Java stack , is an ideal framework for building modern event-driven microservices. This project aims to simplify the development of asynchronous services in Java by generating code and documentation for developers looking to use EDAs in a cloud-native application. Furthermore, this template will be one of the first templates developed inside the AsyncAPI’s generator repository. Allowing developers to test changes locally in the generator repository, making the development easier and reducing the number of workarounds in the template codes. This project will start the improved way of developing and maintaining templates for the AsyncAPI initiative. Key deliverables include: dynamic code generation from AsyncAPI specs using the React engine with integrated WebSocket support, extensions support for Kafka protocol, and a Kubernetes CRD integration.
Despite `tests/ui`'s usefulness to maintainers, it acts as a barrier to new contributors - with how expansive it is, major pull requests can break tiny, unexpected checks among the thousands of tests. The process of finding which part of your PR is breaking the test written 10 years ago with no documentation is commonly known as "very fun". This project will reorganize the UI directory with measures such as metadata tagging by category, identification of duplicate tests, as well as detection of tests which do not do anything or do not test what they are trying to.
This proposal aims to improve the testing framework for SW360’s REST API endpoints by addressing limited test coverage, insufficient integration tests, and outdated testing workflows. The project will focus on writing comprehensive unit tests for CRUD operations and edge cases, developing integration tests for multi-endpoint workflows, and creating reusable utilities for database mocking and error simulation. Additionally, CI/CD pipelines will be automated with tools like JaCoCo for test coverage tracking and regression prevention. Deliverables include a robust test suite, enhanced testing infrastructure, automated pipelines, and detailed documentation to simplify onboarding and contributions. These improvements will make SW360's APIs more reliable, scalable, and maintainable for the developer community.
LibreOffice (Writer and Calc) currently allows users to apply predefined table styles via the “AutoFormat Styles” dialog and add new styles based on manually formatted tables. The current implementation applies direct formatting to the existing table instead of styles, which means it needs to be reapplied every time the table is modified. This proposal aims to implement a new dialog, based on the UX teams’s design proposal, that allows users to comprehensively edit all aspects of a table style using ODF specification along side with WYSIWYG preview, and ensures consistent behavior across Writer, Calc and Impress.
This project aims to enhance Salsa CI, a key tool in Debian's package workflow that ensures smooth transitions from unstable to testing release via automated builds and checks. While it already catches issues early, there's room to improve usability and performance. The work will focus on fixing bugs, adding features based on community feedback, and improving documentation for better usability. All changes will be developed collaboratively to ensure long-term impact. Deliverables include resolved issues with documented discussions and new features aligned with project goals.
This project aims to enhance the general network visualization capabilities in OpenWISP by introducing a unified and interactive new map page for both geographic and indoor device layouts. The current view is limited to the dashboard with constrained space and lacks features such as real-time updates, indoor floorplan support, and deep-linking to specific devices or views. To address these gaps, a new dedicated page will be developed to display all network devices with a clean, full-screen interface. Devices located indoors will be visualized on floor plans, with support for multiple floors within the same view. A working prototype demonstrating floorplan overlays on top of geographic layouts has already been implemented and deployed. The project will also introduce dynamic URLs, allowing users to bookmark or share direct views of specific devices, links, or positions. Additionally, new buttons will be added to the device detail and floorplan pages to help users quickly navigate to their focused views on the map.
Rocket.Chat users across multiple time zones need a way to schedule messages for optimal delivery, enhancing global collaboration. This project will implement a native message scheduling feature by integrating a scheduling UI, a cron job to send messages at the designated time, and a contextual bar UI to view and cancel scheduled messages. It will also support scheduling in threads, improve error handling, and include comprehensive documentation and unit tests. The deliverables include a MongoDB collection for scheduled messages, APIs (chat.scheduleMessage, chat.getScheduledMessages, chat.cancelScheduledMessage), a cron job (sendScheduledMessages), scheduling and viewing/canceling UIs, thread support, error handling, documentation, and tests
The aim of this project is to provide an API in libVLC so users can embed the media player in their programs. Although there’s already a support for x11 and Windows API, wayland doesn’t work in the same way. In this project, I implemented a native wayland back-end enabling integration of VLC’s rendering capabilities into wayland-based applications. I wrote a simple demo that explains how this backend can be used and tested it on different wayland compositors.
This project aims to improve the robustness and flexibility of topic modeling in the CHAOSS Augur platform by enhancing its clustering_worker component. Currently, Augur relies on a static number of LDA topics, lacks model versioning, and does not support retraining based on data drift. To address these issues, this project will: Introduce dynamic topic number estimation via Gensim’s HDP model. Implement model versioning with model_id and timestamp support. Record model metadata including hyperparameters and coherence scores. Add automatic parameter tuning using coherence-based grid search. Detect data drift and trigger model retraining accordingly. Export rich visual outputs such as pyLDAvis and wordcloud images. Deliverables include upgraded database schema, a refactored topic modeling pipeline, metadata tables, Jupyter demo notebooks, and HTML visualizations for CHAOSS dashboards. These changes will make Augur’s insight engine more adaptive, interpretable, and future-proof.
Demucs v4 is a state-of-the-art open-source music source separation model developed by Antoine Défossez. While it provides exceptional quality in separating audio into stems, it is currently implemented in PyTorch and therefore cannot be used directly in C++ applications or run efficiently on hardware accelerators through ONNX Runtime. This project aims to bridge that gap. Exporting the model to ONNX will allow Mixxx to integrate stem separation directly into its platform, opening up use cases like live stem manipulation, AI-assisted mixing, and educational visualization tools. Moreover, embedding the model in a minimal C++ command-line application will serve as a reference for further integration into audio applications.
This project proposes the development of a foundational model for symbolic regression tailored to high energy physics (HEP). Symbolic regression can be used to rapidly provide solutions to scientific problems with high computational complexity or even intractable tasks, discovering symbolic expressions that describe underlying physical laws. While many approaches have been explored, this project focuses on building a foundation model which incorporates knowledge about the task of symbolic regression and common data representations for physical systems. The model will target accurate and interpretable prediction of squared amplitudes and cross sections—two core quantities in particle physics. Leveraging physics‑informed representations, symbolic machine learning, and simulation data, the project will explore how to integrate domain knowledge into learning algorithms to enhance scientific validity. Over 28 weeks, the project will progress through phases of theoretical investigation, foundation model design, simulation‑based data generation, model development, and integration. Deliverables will include a curated dataset, pre‑trained foundation model, symbolic models, and a final report, with broader goals of improving interpretability and reliability in physics‑informed AI.
The goal of this project is to introduce new tooling modes and new tools to improve the vector editing experience in the Graphite editor. Addition of point / Segment and Region editing modes (with their combinations) in the path tool which will allow users to have more control over selection and editing experience. Existing vector tools and their features in graphite don’t work very well with “vector meshes” as they are supposed to work with vector paths only, this project aims to refactor those features. Additionally, I will implement new features for existing tools to streamline the vector editing workflow. These enhancements will give users finer control over their vector artwork while making the editor more versatile for both simple and complex vector editing tasks.
The proposal aims to integrate the Julia package Agents.jl (for agent-based modeling) with ReinforcementLearning.jl or Crux.jl, enabling intelligent agents in simulations to learn optimal policies via reinforcement learning. The integration will allow for dynamic, reward-based behaviors rather than static rule-based actions. The project involves updating the chosen RL library for compatibility with the latest Julia version, building a lightweight interface (ABMEnv) to connect it with Agents.jl, and showcasing the integration through example applications like herding, civil violence, and predator-prey models. This work will expand the capabilities of Julia’s ecosystem for researchers in fields such as economics, social sciences, and robotics, while offering a standardized and accessible way to combine RL and ABM.
Libraries worldwide face challenges in adopting digital lending due to restrictive licenses and costly, vendor-locked systems that limit independence. Lenny is an open-source, self-hosted lending system inspired by the Internet Archive and Koha. Its mission is to give libraries ownership of their digital collections while offering a flexible and cost-effective alternative to proprietary platforms. At its core, Lenny based on python features a FastAPI backend that handles borrowing, returning, and waitlists, with support for Readable, Borrowable, and Print-Disabled books. Security and compliance are provided through LCP DRM and Geo-IP restrictions, while PostgreSQL triggers automate loan expirations. An OPDS feed enables integration with Open Library, Thorium, and other reading systems. Deployment is simple with Docker (Alpine + Nginx), and a React dashboard allows librarians to set lending rules like loan durations and waitlists. To improve accessibility, the companion Lenny-app (TurboRepo monorepo) includes: 1. A sandbox demo preloaded with 500+ e-books to showcase the system in action powered by Lenny. 2. A documentation site that supports integration, open-source contributions, and extensions. Built with TypeScript, React, Next.js, Node.js, and Express.js, Lenny-app is production-ready yet flexible for experimentation. Together, Lenny + Lenny-app deliver both the backend infrastructure and the user interface needed to power community-driven digital lending. By combining secure architecture, a ready-to-use demo, and developer-focused documentation, Lenny provides libraries with a scalable and future-proof solution to manage digital lending independently and expand access for their patrons.
Embedding p5.js sketches on different platforms can be tricky because some sites block scripts, remove iframes, or require a specific format. This project will create an easy-to-use embed generator that lets users customize their embeds without writing any code. It will support both Global and Instance Mode, making it flexible for different coding styles. Users can adjust the size, background color, playback options, and whether the code is editable or locked, all through a simple interface. To make things even easier, the tool will include smart platform presets, so users can generate the right embed code for platforms like WordPress, Medium, Notion, and static site builders. A live preview will show exactly how the embed will look before copying the code. This project will remove technical barriers, making it simple for teachers, artists, and developers to share p5.js sketches anywhere.
The current Vitess RAG chatbot which uses documentation, Slack discussions, and GitHub issues data, has low accuracy. This project aims to improve the accuracy and security of the system by; Enhancing retrieval with techniques like query expansion, re-ranking, metadata filtering, inclusion of image data, and summarizing chunks using LLMs before embedding using tools like Langchain; Automating the embedding of updated documentation into the vector database using Kestra pipelines; Better benchmarking with tools like Giskard and RAGAS; Using user feedback to improve relevance; Content filtering using LLMs safety settings; Implementing caching for faster responses and lower costs, along with rate limiting for infrastructure stability
This project aims to extend the capabilities of the ONNX-to-mlpack converter by adding support for more advanced and diverse model architectures. The focus will be on enabling the translation of complex ONNX computational graphs, including LSTM-based models and Directed Acyclic Graph (DAG) structures. Additionally, the project will introduce support for NLP models and incorporate foundational NLP components such as Word2Vec-based tokenizers, encoders and decoders in mlpack.
PyLops is a Python package with a simple yet flexible interface for solving linear inverse problems. Previous GSoC-sponsored projects laid the foundation for PyLops-MPI. The current missing piece is the support of high-bandwidth communication in the multi-GPUs environment. This project aims to do just that. Specifically, this project will extend the current PyLops-MPI with NVIDIA’s NCCL API to optimize collective communication speed - a bottleneck in many applications. The project consists of four parts: NCCL integration, correctness tests, performance benchmark, and comprehensive tutorials.
This project addresses the critical challenge of GPU resource management in ML/AI research environments where researchers often face delays due to inefficient resource allocation. I'll develop a comprehensive CPU-based control plane that efficiently orchestrates GPU resources through four key components: an advanced job scheduler with priority management and preemption capabilities, a comprehensive observability platform with real-time dashboards, a streamlined model deployment pipeline with CI/CD integration, and robust infrastructure automation. By implementing technologies like Slurm for scheduling, Prometheus/Grafana for monitoring, Terraform/Ansible for infrastructure automation, and integrating ML-specific tools like MLflow and NVIDIA Triton, the system will deliver significant benefits to researchers: reduced wait times for GPU access, transparent visibility into resource availability, priority access for time-sensitive research, and a seamless deployment pipeline from training to serving. Deliverables include a functioning scheduler with priority queue support, a comprehensive monitoring system with custom dashboards, infrastructure-as-code modules, a model deployment pipeline with CI/CD integration, and an intelligent alerting system. The complete solution will serve as a reference implementation for academic GPU cluster management, providing reusable components and best practices for similar infrastructure requirements in the ML research community.
In particle physics, a cross section is a measure of the likelihood that particles will interact or scatter with one another when they collide. It is a fundamental quantity and its computation can become time intensive. This project aims to apply state-of-the-art machine learning techniques, particularly transformer-based models, for the generation of symbolic representations of the squared amplitudes in HEP. The proposed sequence-to-sequence system aims to improve upon the existing time-intensive processes of calculations of the squared amplitude . This project builds upon the previous work which includes vanilla models, and extends it further to advanced transformer models.