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.
<p>Shaka Streamer is a tool that simplifies media transcoding and packaging by utilizing FFmpeg and Shaka Packager and managing the command line arguments that should be fed to them using simple and reusable configuration files.</p> <h3>The two features concerning this project:</h3> <ul> <li>Adding a <strong><code>PeriodConcat</code></strong> node that will make Shaka Streamer capable of producing multi-period DASH manifests using the single-period manifests outputted by Shaka Packager(which yet doesn't support multi-period DASH). A workaround can be done for HLS since it doesn't support periods, by using <strong><code>#EXT-X-DISCONTINUITY</code></strong> tag as a separator between different periods.</li> <li>Bundling hermetic copies of FFmpeg and Shaka Packager and allowing the user to specify whether Shaka Streamer should use the hermetic versions or the system-wide versions instead.</li> </ul>
Currently, SourceKit-LSP only shows the first line of the documentation for code completion items. Furthermore, it doesn’t support the Language Server Protocol’s (LSP) signature help request which provides information about the function or subscript being completed like alternative signatures, documentation, parameter list, and parameter-specific documentation. The goal of this project is to enhance how SourceKit-LSP displays documentation for code completion items by: 1. Providing the full documentation for code completion items rather than the first line only. 2. Implementing LSP’s signature help request to provide richer guidance for completing function/subscript signatures. The implementation will require changes in SourceKit-LSP and sourcekitd in the Swift compiler codebase. This will enhance the developer experience for Swift developers using SourceKit-LSP on editors like Visual Studio Code and Neovim aligning with Swift’s vision of cross-platform support.
<p>Godot's high-level multiplayer approach makes it uniquely easy to create client-host and true peer-to-peer (P2P) models of multiplayer gaming. However, outside of local area networks Godot struggles to actually create these multiplayer models because it lacks any sort of NAT traversal. I plan to implement WebRTC. The WebRTC standard will be able to provide support to Godot's existing multiplayer in making these sorts of peer-to-peer games.</p> <p>It will also make multiplayer viable in the HTML5 target platform, and allow for easy interfacing with non-Godot peers that use WebRTC. Additionally, the support I build for WebRTC will make it easy to later add WebRTC MediaStreams, allowing for in-game voice chat. (However, building MediaStream is less-often needed for games so is considered to be low priority and non-essential in my project. See project proposal for details.)</p>
<p>The UI testing in LibreOffice is based on introspection code in c++ interacting with a testing framework in python through a simple UNO interface. To identify objects we use the ids that we introduced for loading dialogs from UI files. We still have unsupported items in LibreOffice UITesting Framework. Also We have a domain specific language that we used to log the events in its syntax. Also we have Logger that supports the UI elements of Visual Component Library and some application-specific events can also logged. So The project mainly goals is to Extend the ability of the existing UI testing framework to support the unsupported items that exist now. Then to Increase the ability of the DSL that used for testing by Be able to log more complex events and the events of the new added items that were unsupported before. Also Be able to generate more meaningful test cases with the DSL not just replaying the user action from the Logger. Finally to Add new generic methods for writing test cases for new bugs.</p>
<p>GrimoireLab is a powerful open-source platform that provides support for monitoring and in-depth analysis of software projects. It produces a rich set of dashboards, which can be easily inspected by decision-makers to help them understand the evolution and health of their projects. Despite the large set of dashboards available in GrimoireLab, comparing projects between each other is not straightforward since it requires navigating and drilling down the data in different dashboards.</p> <p>Prosoul is a web application that empowers decision-makers with the means to create and manage their own quality models, which are useful means to evaluate and compare software projects. This project idea is about supporting the definition of Quality Models using GrimoireLab data and Prosoul.</p> <p>The main aim of the project is to design an approach to shape the GrimoireLab data in a format that can easily be consumed by Prosoul and implement it on the data obtained from a few data sources like git, github and mailing list repositories to obtain simple quality models.</p>
Meshery UI lacks a permissions framework. The existing internal implementation is simple, fragile and must be completely rewritten. The approach to implemention a permmissions framework includes using React.js and CASL.js. Meshery UI's approach needs to be extensible given that this framework will be an extension point for Remote Providers to supply their own permissions. - Expected outcome: Definition of permissions and their enforcement in Meshery with an aim for deep granularity and extensibility with each user interface input component carrying a unique permission key id. Each key is then put into a group of keys in a keychain, keychains assigned to user roles, in turn, roles assigned to users. With users having the ability to create own custom roles, the framework will be dynamic based on the associated server-side permissions for the currently auth’ed user. - Upstream Issue (URL): https://github.com/meshery/meshery/issues/7436, https://github.com/meshery/meshery/issues/7382
<p>The WARP-V is an open-source and highly configurable, adaptable, and flexible Core generator. It supports various ISA like MIPS, Open-Source RISC-V, and can even be configured with custom ISA. It is designed using emerging “Transaction-Level” modeling that takes advantage of advanced digital design features, timing-abstract nature of language features provided by TL-Verilog. My Project Proposal to harness its advantages and develop support for the multicore NoC design creating a custom kernel interface and deploying it on the cloud via the already existing 1st CLaaS framework. This project will not only lead to a highly configurable many-core hardware accelerator but it will also serve to motivate the industry toward FPGA-accelerated web applications and FPGA-accelerated cloud computing and also to demonstrate the flexibility of TL-Verilog and WARP-V to motivate the industry toward better design methodology.</p>
<p>ROOT is the data processing framework created at CERN - at the heart of the research on high-energy physics. Every day, thousands of physicists use ROOT applications to analyze their data or to perform simulations. The ROOT software framework is foundational for the HEP ecosystem, providing capabilities such as IO, a C++ interpreter, GUI, and math libraries. It uses object-oriented concepts and build-time modules to layer between components. This project aims to provide additional functionality using a package manager over the minimal base install of core features. It involves defining ROOT modules, packages and package manager, mainly to scale the large codebase of the project. The current development involves creating a modular version of ROOT that provides a minimal base install of core features, then later adding functionality using the package manager. This requires introducing new layering mechanisms and extending the functionality of the existing ROOT package manager prototype.</p>
<p>This project will focus on solving several of the high priority issues related to the general user experience of Zulip. This would involve improving the user interface in some areas, adding requested features in some places, as well as fixing some areas where the behavior is not as expected. All of this, in the hopes that it would improve the feel of Zulip for existing users and make it easier for new users to adopt.</p> <p>Though it was not intentional, several of the issues to be tackled here are requests made by large communities as their major blockers to switching over to Zulip. This project consists of work that goes over a few areas, broadly, these could be clumped together as the following goals:</p> <ul> <li>Info density enhancement requests.</li> <li>Public streams and guest user support.</li> <li>Better support for appearance and interaction of muted streams.</li> <li>Misc UI improvements.</li> <li>markdown processing improvements.</li> <li>search behavior improvements.</li> </ul>
<p>ELI5 is a Python library for explaining and debugging machine learning (ML) models. Currently ELI5 supports scikit-learn, xgboost, and other ML libraries, taking in estimators such as linear classifiers and decision trees. However, explanations for neural networks are yet to be added. Thus, in this project I propose to add support for three popular deep learning libraries: Keras, Tensorflow, and PyTorch. I will explain the models from these libraries using an implementation of Grad-CAM (<a href="https://arxiv.org/abs/1610.02391" target="_blank">https://arxiv.org/abs/1610.02391</a>), a widely applicable and robust approach for highlighting what contributed to a prediction. In the case of image-based networks, a heat map will be created indicating where the network looked to make a prediction, of which there are many examples online. Less commonly done, in this project I will also explain text-based models via text highlighting.</p>
Prometheus remote write allows users to send their metrics to other time series databases. Though the Prombench tool has existed for a number of years, it has never been extended to support performance testing of Remote Write in a realistic production like environment. With the upcomming Remote Write 2.0 changes to both the underlying implementation as well as the wire format, the need for benchmarking of remote write beyond static Go bechmark tests has increased. Expected Outcome: Build additional (or extends existing) tooling, similar to Prombench’s load-generator and avalanche, to support scenarios under which remote write should be performance tested. For example; allowing gradual increases/decreases in # of active series, sudden spikes in active series, various amounts of latency in the server receiving the remote write data, etc. Time permitted, extend Prombench's test suite to include a set of Remote Write tests that can be run via a new command.
The way humans interact with each other occurs in multimodality. We not only articulate words but also, show them. Expressing different concepts such as time, place, and emotion comes with speech and some movements called body gestures. The aim of this project is to detect these commonly occurring phrase and gesture combinations to get meaningful patterns and insights. For this, I propose a multi-modal multi-phase pipeline that captures different patterns of body gestures and speech phrases aligned with an articulated time. The three-stage pipeline begins with pose feature extraction in which both supervised and unsupervised approaches shall be incorporated to classify and cluster various gesture classes. In the next stage phrase features are extracted. These extracted features are then passed through the next stage. This stage will produce a synchronized dataset by aligning extracted features in time by applying late fusion. Lastly, Apriori Algorithm is applied to identify the frequent phrase and gesture combinations. Further, the project can be merged into production in a Red Hen pipeline.
<p>CGAL currently supports the decimation of triangular meshes using two distinct strategies: Lindstrom-Turk and Garland-Heckbert. These strategies assign a cost to each edge collapse so that edges can be iteratively collapsed in order of least cost until a condition is met.</p> <p>Our focus is on the latter of the two strategies, which uses quadrics at each vertex to calculate a cost. The paper <a href="https://www.graphics.rwth-aachen.de/publication/03308/" target="_blank">Fast and Robust QEF Minimization using Probabilistic Quadrics</a> explores the use of probabilistic - as opposed to classic - quadrics and shows that in many use cases, including but not limited to mesh decimation, probabilistic quadrics give better results, are more robust and about as efficient as classical quadrics.</p> <p>The aim of this project is to introduce support for probabilistic quadrics in the context of mesh decimation in CGAL, which would improve the library's capability to quickly generate highly desirable mesh simplifications.</p>
Until today, playing games has become an activity loved by many, mainly due to the fun and competitiveness offered to those who play them. In Liquid Galaxy, a few games were developed that are supported by the cluster system, such as the Galaxy Pong, Galaxy Snake and more, in which lots of them were based on old famous games. One of the first major hits of arcade games was Asteroids, released in November 1979 by Atari, Inc. The player controls a spaceship in an asteroid field and the objective of the game is to increase the score by shooting and destroying the asteroids and saucers, while not colliding with either or being hit by the saucers' shot. The game gets harder as new asteroids spawn. Following this logic, the project's idea is to remake the original Asteroids game, with a modern design and new features, such as the multiplayer mode. It would be really nostalgic and fun to be able to play it again, especially for those who played it back in the 80's and 90's. Moreover, due to its complexity, uniqueness and system support, the project may be a part of the Liquid Galaxy demonstration, bringing more emphasis to the lab.
Apache Fineract’s current command processing system relies on a centralized service and untyped JSON payloads, which limits type safety and causes errors to surface only at runtime. In a financial system, such issues can disrupt critical operations and reduce reliability. This project proposes to migrate selected modules to the new CQRS-based fineract-command architecture, which introduces typed commands, structured handler dispatch, and extensible processing hooks. The migration will cover the full request lifecycle—from REST APIs to business logic—while strictly preserving backward compatibility through unchanged integration tests. Key deliverables include migrating open and unassigned modules to the new architecture, introducing type-safe DTOs with validation, replacing legacy JAX-RS endpoints with Spring Web MVC controllers, integrating the CommandPipeline with typed handlers, removing obsolete legacy components, and producing a comprehensive migration guide to enable future contributions.
<p>This proposal aims to make histogram calculation a built-in feature of Boost.GIL. The proposal also adds histogram related image processing algorithms to Boost.GIL like histogram equalization, histogram matching, CLAHE, etc. Apart from that, for the purposes of visualizations of the plots, a new extension will be provided for 3D histograms. The existing code in GIL will be updated with the new features implemented.</p> <p>All the code provided will be completely generic such that it works with any container type and any image type supported by GIL. It will also extend support for using Boost.Histogram as a container class. Apart from the histogram related contrast enhancement algorithms implemented, tutorials will also be provided for other contrast enhancement algorithms using GIL features to complete the contrast enhancement suite in GIL. The proposal also aims to add benchmark tools to perform quality tests of the available image processing algorithms.</p>
KomaMRI.jl is a high-performance Julia package for MRI simulation and differentiable workflows, but its use is currently limited to the Julia ecosystem, creating a barrier for the broader Python-based scientific computing and machine learning community. This project introduces komamripy, a lightweight Python wrapper that exposes KomaMRI’s core simulation and differentiable capabilities through a minimal, intuitive API. The approach leverages Julia–Python interoperability to map data structures between environments, incorporates Julia-side precompilation to reduce first-use latency, and enables flexible GPU backend support across CUDA, AMDGPU, Metal, and oneAPI. The project will deliver a pip-installable Python package with CI-tested builds and automated releases, precompiled simulation and autodiff workflows, cross-platform GPU backend selection, and a validated end-to-end example demonstrating differentiable RF pulse optimization using JAX, along with supporting documentation and example scripts.
This mentorship focuses on extending the NucleusRV Core, a fully parameterized RV32IMFC core written in CHISEL, by implementing RVV v1.0 Floating Point Vector instructions. The core currently features partial RVV v1.0 support through its co-processor, Vaquita, which handles vectorized operations. This project presents a unique opportunity to dive deep into RISC-V vector extension, hardware designing with abstractions using CHISEL, and contribute to a cutting-edge open-source initiative. Problem/Opportunity Modern workloads increasingly demand efficient handling of vectorized floating-point computations, especially in domains like AI/ML, graphics, and scientific simulations. While Vaquita implements basic RVV functionalities, the absence of comprehensive floating-point vector support limits its applicability in these advanced use cases. Adding this capability will make the NucleusRV Core a more versatile and competitive RISC-V implementation, aligning with emerging industry needs.
Apache Fory's compiler can generate type bindings for seven languages, but neither Swift nor Dart have gRPC service generation support. The generate_services() extension point exists in BaseGenerator and is wired into the CLI, but no language implements it yet. This project adds that support for both: Dart will get a new compiler generator (dart.py) covering messages, enums, and unions alongside gRPC stub generation, while Swift will extend the existing SwiftGenerator with generate_services(). Both will emit typed service interfaces and transport bindings using Fory's serialize/deserialize APIs as the codec, covering all four RPC streaming modes with a zero-copy decode path where possible, without introducing any gRPC dependency into the Fory runtimes. Deliverables include the Dart compiler generator, gRPC stubs with golden tests for both languages, runnable server and client examples, cross-language round-trip tests against a Java server, and compiler documentation for the --grpc flag.
LibreOffice has Python scripting support via its UNO API but does not have adequate IDE support because it doesn't have static type information. This project suggests developing a new tool named pythonmaker using C++ in LibreOffice's codemaker framework to create Python stub files (.pyi) based on UNO's IDL definitions. Such stubs will contain correct type hints according to PEP 484/561 guidelines so that features such as autocompletion, static analysis, and improved navigation can be provided in Python IDEs. pythonmaker will make use of existing infrastructure such as codemaker::TypeManager and convert UNO interfaces, structs, enums, and constants into their Python counterparts. The output files will be structured by UNO namespaces, e.g., com/sun/star/. The project also features comprehensive testing using CppUnit, MyPy, Pyright, and actual IDE validation—to provide quality and usability. Overall, this will dramatically enhance the Python development experience within LibreOffice.
Drawy's current text tool is limited to plain text with no per-character formatting, no undo/redo, no support for non-Latin input methods, and performance issues on large text. The goal of this project is to refactor and extend the text tool into a rich text editor. The implementation will begin by splitting the existing code into three classes (TextItem, TextCursor, TextTool) and replacing the manual rendering logic with QTextLayout, which natively handles BiDi, line breaking, and cursor positioning. On top of this foundation, the project will deliver per-range character formatting, text alignment, word wrapping, spell checking via KDE Sonnet, and a formatting toolbar for the user to control fonts, styles, and alignment. Undo/redo will be integrated. Save/load will be extended to support rich text while remaining backward compatible with existing documents. Finally, the backing data structure will be replaced with a Gap Buffer for O(1) insertions and deletions.
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.
Gigaflow is an innovative solution to accelerate network processing in large-scale data centers by leveraging flow locality and pipeline-aware caching, offloading processing to SmartNICs. Currently, it supports only Alveo U250 FPGAs, limiting its versatility. This proposal aims to extend Gigaflow’s backend support by developing new APIs for flow integration, enabling compatibility with Pensando DPUs. Additionally, the current implementation of Sub-Treversal Partitioning (STP) incurs high CPU overhead during startup, minimizing the system's performance benefits. This project will optimize STP to reduce CPU usage and improve startup efficiency. Finally, Gigaflow’s newness requires further optimization in the compilation, LTM, and driver pipeline, alongside additional testing for alternative strategies for priority selection and rule deletion. The proposal will address these challenges. By achieving these goals, the project will streamline Gigaflow caches in the OVS backend, facilitating more efficient and flexible solutions for modern data centers.
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.