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>A Module System for C++ is on its way to the C++ standard.</p> <p>The current state of the Module System, although fairly stable, it has a few bugs for C++ support. The most common reason for the bugs is the semantic merging of C++ entities. Currently, the method for ensuring no regressions is a buildbot for libc++, which builds llvm in modules self-hosted mode. Its main purpose is to find bugs in clang’s implementation and ensure no regression for the ongoing development.</p> <p>Since the Module Systems is meant to be generic, the project aims to improve the stability and coverage of the Module System by finding as many issues as possible. One approach is to add a buildbot for libstdc++, because this would change the merging model for the modules, and in this way, it will point out different issues which would not be observed by using libc++. The choice for libstdc++ is motivated by its wider use in Unix and, more importantly, the benefits it will bring to supporting modules for third party projects that rely on libstdc++.</p>
<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>
Supervised learning might be challenging in cases where there are extremely few known instances in a given category. This is a common occurrence in the case of Strong gravitational lensing images when samples from one or more classes are scarcer than others. On the other hand, when there are few data labels available for supervision, Self-Supervised Learning (SSL) has been shown to perform better than conventional supervised learning. SSL can also create meaningful representations from very vast unlabelled datasets that would be challenging or impossible to label manually. Additionally, transformer-based architectures recently have emerged as a paradigm to solve a wide range of tasks in computer vision from image classification to object detection. They have a number of advantages over traditional methods, including dynamic weight adjustment based on input features, global context, and improved generalization. Thus, the project aims to train transformer architecture in Self-Supervised Learning fashion to learn generic features. These features could then be used in different downstream tasks such as image classification or regression.
Modern AI systems relying on Retrieval-Augmented Generation (RAG) often suffer from stale data due to batch-based updates. This project, PyDebeziumAI, aims to solve this by enabling real-time synchronization between databases and LLM pipelines using Debezium Change Data Capture (CDC). The project will extend pydbzengine to stream CDC events directly into LangChain and LangGraph by transforming database changes into semantic Document objects and updating vector stores in real time. Key deliverables include: - A Python library integrating Debezium with LangChain/LangGraph - Real-time vector store synchronization (Chroma, PGVector, Milvus) - Pluggable document transformation and ID strategies - End-to-end examples (RAG chatbot, reactive agent, dashboard) - Full documentation, testing, and PyPI release This will provide a production-ready bridge between CDC systems and AI frameworks, ensuring always up-to-date LLM context.
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.
<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>
<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><strong>Barrel</strong> is a distributed database built on top of <strong>Erlang</strong> and <strong>CouchDB</strong>. There are provisions in Barrel to extend the database with user defined modules and hooking them to database events like database creation, deletion, updates etc. Barrel now uses <strong>Hooks</strong> to let modules subscribe to the events and register a callable that can return and modify results.</p> <p>Secondary indexes can also be created using functions that accept a <strong>Doc</strong> and return a <strong>Key/Value tuple</strong>.</p> <p>Right now there is provision only for functions written in <strong>Erlang</strong> or <strong>Javscript</strong>.</p> <p>The aim of the proposal is to add <strong>Elixir</strong> to the list of languages supported by Erlang. This would allow more developers to extend barrel and also brings a whole bunch of libraries and support from the Elixir ecosystem.</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>
<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.
Regolith's Wayland session still depends on GNOME for session startup and settings plumbing. That makes the COSMIC path awkward to install and harder to maintain. I want to build regolith-session-cosmic, an experimental Regolith session that starts through cosmic-session, runs Sway, and removes GNOME from the bootstrap path wherever the packaging and runtime audit shows it can go. The project also includes packaging the required COSMIC components through Regolith's Voulage pipeline so the session can be installed without depending on Pop!_OS repositories, finishing the remaining COSMIC-to-Sway keyboard integration in cosmolith, and validating the core session behavior: display, lock and idle, OSD, and settings persistence. The main deliverables are a bootable experimental COSMIC session for Regolith, packaged COSMIC runtime components with reproducible offline builds for the supported target distros, the remaining input integration work in cosmolith, and a documented validation matrix for the supported session path.
<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>
This project adds native PEM keystore support to WildFly Elytron, enabling WildFly to load Kubernetes TLS secrets directly without any manual conversion. Kubernetes exposes TLS certificates and private keys as PEM files, typically as tls.crt and tls.key. Elytron currently requires JKS or PKCS12 keystores, which creates unnecessary friction when deploying applications in containerized environments. This project introduces a new KeyStoreSpi implementation that reads PEM-encoded certificates and private keys from separate files and exposes them as a standard keystore type (PEM). The implementation integrates seamlessly with Elytron’s existing KeyManager and TrustManager infrastructure, allowing it to be used transparently in current configurations. The main deliverables include a robust PEM parser, the PemKeyStoreSpi implementation, support for separate certificate and key files, Elytron configuration integration, comprehensive test coverage, validation using Kubernetes-style TLS secrets, and clear user documentation.
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.
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.
My proposal aims to improve the user experience and developer experience for AsyncAPI-Preview extension. The main problem being solved is the difficulty in identifying and resolving common and custom linting errors in AsyncAPI documents. By leveraging the VSCode API for providing quick/autofixes for linting errors, my proposal plans to add an "Auto Fix" feature for most common and standard Spectral linting errors in AsyncAPI documents. The proposed deliverables for this project include: -Integration of AsyncAPI-Preview and Spectral for VSCode extensions -Implementation of Code Actions for standard Spectral linting errors in AsyncAPI documents -Support for computing json-path to source code and vice versa -Investigation on loading autofix rules from external files to support custom (non-standard) Spectral linting rules Overall, this project aims to streamline the AsyncAPI-Preview process and improve the quality of AsyncAPI documents by providing developers with a more user-friendly and efficient way to identify and fix common and custom linting errors.
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.
The spinebil package provides diagnostic tools to evaluate projection pursuit (PP) index functions, which are used to discover informative low-dimensional projections of high-dimensional data. However, current tools for understanding the behavior of these indices under varying data conditions are limited. This project aims to enhance spinebil by developing diagnostics that assess how PP indices behave under noise, structure, varying sample sizes, and scale interpretation. I will implement routines to test index performance across noise-to-structure transitions, evaluate index value ranges, analyze sample size sensitivity, and apply these diagnostics to both existing and scagnostic-based indices (e.g., stringy, skinny). I will also optimize the code for performance and clarity, write detailed documentation and a vignette, and design a hex sticker for the package to support its identity on CRAN. This project will support the development of more robust, interpretable projection pursuit indices and make spinebil more accessible to researchers, educators, and developers.
We are looking for an internship for the LF internship program that can help developing the Patchwork tool which is used by the Linux Kernel Media subsystem and by many other open source projects. We're aiming to add an audit trail on patchwork that will allow to identify the events that triggers patch status changes, like: - when a new patch is added to Patchwork; - when a patch status changed and by whom; - when a patch is delegated and by whom. As a secondary goal, identify missing features that exists on patchwork forks (in particular, the one used by Freedesktop) and porting them to upstream. Technical qualifications: - Capable of developing high quality programs in python3; - Knowledge on Python Django framework; - Some experience with Patchwork is desired (https://github.com/getpatchwork/patchwork) At the end of the project, the mentee will learn how to develop high quality Python and submit them using procedures similar to the Linux Kernel submissions. After the end of the project, the applicant will have developed high quality Python and understand the submission process to an upstream open sourc project.