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>Boost is one of the most fundamental collections of C++ libraries, powering thousands of projects, but also driving the development of C++ best practices and C++ standards. Boost.Multprecision is the Boost library providing number types with precision higher than that of C++ built-in types. The library offers support for integer, floating-point and rational data types at compile-time fixed, arbitrary and variable precision.</p> <p>Currently, many operations are already supported for arbitrary precision, but tests exist only for up to 1024 bits. The purpose of this project is to 1) extend testing for precision of thousands of bits and 2) add arbitrary-precision support for more complicated functions and constants. This includes adding tests for arithmetic operations of higher precision, extending tests for simple functions, extending special functions to higher precision, adding support for higher precision constants (and adaptive precision algorithms) and optimising several of the operations (see Milestones for details).</p>
<p>Computational models of biological systems play an important role in advancing science as they give insights about the biology without the need for performing real experiments. A significant challenge in the systems biology field is the reproducibility and reusability of such models and making these accessible to the broader biology community. To address this issue, computer-readable formats and tools for modeling complex biological systems have been developed. Standards such as Simulation Experiment Description Markup Language (SED-ML) and tools like Systems Biology Simulation Core Library (SBSCL) can represent such complex biological models and numerically simulate them. But until now only a subset of these standards have been implemented in SBSCL. Essential features that will catalyze reproducibility, exchangeability, and reusability are lacking so far. Namely, i) implementation of full support for simulation experiments; ii) plots and visualization of simulation studies; iii) support for standard archive formats; iv) support for Open Source solvers, and v) support for hierarchical models.</p>
This proposal is based on the LLVM project for GSoC 2026 with the same title, from Tue Ly, Nicolas Celik and Krishna Pandey. Discourse: https://discourse.llvm.org/t/gsoc-2026-libc-enable-float80-and-float128-math-support-on-unsupported-targets-for-llvm-libc/89647. Float80 (x87 80-bit extended precision) and Float128 (IEEE 754 binary128 quad precision) are high-precision floating-point formats critical for correctly rounded math implementations. However, not all compilers or architectures support these types natively which prevents LLVM libc from building and testing its high-precision math routines on these platforms. The goal of this project is to implement software support for these types in LLVM libc in a compiler and architecture agnostic way. Deliverables: - Implement float80 and float128 in a compiler and architecture agnostic way. Implement generic basic arithmetic operations that work on all supported architectures. - Demonstrate compiling and passing tests on unsupported targets (float80 on Mac ARM64, float128 on MSVC).
<p>With the development of software container technology, developers can manage and deploy their software effectively. The software can start up and run on the container more and more quickly. The Dockstore is a platform for users to share tools encapsulated in Docker. Furthermore, in order to share tools as seamlessly as possible, GA4GH create a set of APIs for the biology scientists. In this project, I would like to make the Dockstore support these APIs. In this way, people can create their tools based on the APIs so that their tools can be work with others’ tools seamlessly. It will absolutely help the cooperation between scientists due to they can create their tools based on or cooperate with others’ more easily. Our project has three main goals. The first is to communicate with GA4GH community so as to decide the APIs standard and their implementations. Then, I need to implement and test these APIs with java so that the Dockstore can support the APIs. The last goal is realize cross indexing of tools across all sites that support the standard. When finish cross indexing, Dockstore can search all the tools from all websites which support the standard.</p>
The Volcano Dashboard serves as the frontend for displaying Volcano resources. Currently, it supports resources like Volcano Jobs, Queues, and Pods, but editing often involves raw YAML, which is not user-friendly for modifying or creating new resources. To improve user experience, this project aims to enhance the Dashboard's interactivity and user-friendliness, as well as support the display of hierarchical Queues and HyperNode resources. Expected Outcome: 1. Improve resource display and editing interfaces by providing more user-friendly interaction methods, such as using forms or visual editors instead of direct YAML editing for creating and modifying resources. 2. Support the display of hierarchical Queues and HyperNode resources with mouse-click expand/collapse functionality to clearly visualize resource relationships. 3. Optimize the user interface design to enhance aesthetics and ease of use. 4. Refactor the backend code to improve maintainability and scalability. 5. Display both key information and full information for resources, with an option to switch between views. 6. (Optional) Support the display and management of more resource types.
<p>This project aims to extend the collection of fonts supporting Greek script in the Google Fonts Catalog. Indeed, today 35 typefaces supporting Greek script are available. Moreover, only 2 fonts are explicitly intended for display text.</p> <p>Arima Madurai is a font created by Natanael Gana and Joana Correia of NDISCOVER. It is a multiscripts display font with 8 weights from thin to black and have a strong calligraphic influence. It has a lot of personality so it can be recognisable in headlines or brand names uses. Regarding the history of Greek script, it is both interesting and challenging to design a typeface with a calligraphic feel: in terms of design but also in terms of study.</p> <p>Arima Madurai already supports Tamil, Malayalam and Latin scripts and I would like to add Greek extended script to the glyphset. The fact that the font already supports multi scripts is a real benefit to the project: Arima Madurai already acts in non latin typographic environment and therefore displays a large set of shapes that can be used to match the Greek glyphs with the other ones.</p>
Git's partial clone allows cloning repositories without downloading all objects (blobs, trees, ...). These objects are fetched on demand from the remote when needed. However, when a user needs metadata about these remote objects (size, type, hash, ...), Git has no efficient way of doing this without downloading all the object content. The server side support for `object-info` protocol was implemented by Calvin Wan in 2021. Eric Ju built the client-side `remote-object-info` for `cat-file --batch-command`. This project finishes Eric Ju's work on `remote-object-info` for `git cat-file --batch-command`, resolves the pending feedback from Junio Hamano and Jeff King, and extends support for `%(objecttype)`. The main technical fix is to replace the insufficient `strstr()` format validation with an `allow_list` to prevent crashes on unsupported placeholders, and extending the v2 protocol server and client to handle `%(objecttype)`. After the project, Git will have a working `remote-object-info` for `cat-file --batch-command` supporting `%(objectsize)`, and a v2 protocol extension adding `%(objecttype)` support on both server and client, with tests and documentation.
Rocket.Chat’s Message Composer currently displays raw Markdown syntax and emoji shortcodes while composing a message, only applying formatting after the message is sent. This impacts readability and usability, as users must interpret raw syntax instead of seeing the final formatted output. This project will introduce real-time Markdown rendering and native emoji support in the Message Composer. Users will be able to see bold, italic, and other formatted text as they type, along with correctly rendered emojis. Additionally, the project will provide a proof-of-concept for migrating from Rocket.Chat’s third-party emoji pack to native emoji support. Key Deliverables: 1. MVP implementation of real-time Markdown rendering in the Message Composer. 2. Native emoji support, replacing the existing third-party emoji pack. 3. Support for mentions with a defined style, ensuring visually distinct tags. 4. Text sanitization to maintain security and prevent unintended behavior. 5. Help tooltip for Markdown syntax, improving accessibility for new users.
<p>Knative is an extension of Kubernetes and is specifically designed for serverless workloads. Knative Serving, as one of the core components of Knative, runs scalable containers based on ingress gateway as its network layer to route traffic and control the flow of API calls. Currently, Istio is the default ingress gateway of Knative Serving. Other community-based gateway implementations such as Kong and Gloo are also supported.</p> <p>APISIX, a dynamic, real-time, and high-performance API gateway, comes with an ingress controller which can be used in Kubernetes. The ingress controller of APISIX, however, has no support for Knative. This limits its use scenarios. This project aims at providing support for APISIX for Knative. Main tasks include</p> <ol> <li>understanding the mechanism of Knative Serving and APISIX ingress controller.</li> <li>Implement support for APISIX as Knative ingress gateway</li> <li>Writing tests documentation, or articles for the newly added feature</li> </ol> <p>As a result, APISIX ingress controller will be an alternative Knative network layer to manage ingress traffic.</p>
<p>Firefox Developer Tools offers good tooling for monitoring HTTP traffic between the current page and the server. The existing Network panel allows intercepting and inspecting all data transferred over the wire including headers, GET/POST data, responses, detailed timings, etc. Unfortunately, Firefox Developer Tools doesn’t offer a way to inspect WebSocket (WS) traffic in Firefox Quantum.</p> <p>This project aims at providing support for WebSocket monitoring and inspection in Firefox Developer Tools. The feature should be built on top of the existing Network panel user interface (UI) and be responsible for visualizing data (i.e. WS frames) sent through a WebSocket connection. Users should be able to perform common tasks such as pausing/resuming monitoring, clearing frames, searching/filtering, looking at summary data etc. Light and Dark Themes should be supported.</p> <p>Furthermore, support for popular protocols such as Socket.IO, SockJS, plain JSON, and MQTT will be implemented. There is also ongoing work for supporting binary message viewer and showing WebSocket messages in HAR exports.</p>
Swarm external secrets project enables Docker Swarm services to consume secrets from external secret managers, but it still lacks several features needed for secure and production ready deployments. At present, some providers rely on older credential models, transport security can be improved, and support for newer secret backends and modern authentication workflows is limited. This project aims to close those gaps by making the plugin more secure, extensible, and operationally reliable. The proposed work will focus on adding modern identity-based authentication methods such as JWT and OIDC flows for Vault and related providers, improving TLS and mTLS support with better CA bundle handling, and strengthening secret lifecycle support such as version awareness and rotation compatibility. In parallel, the project will expand provider support by integrating additional backends such as 1Password, Doppler, and Infisical. The deliverables will include secure authentication improvements, stronger transport security, new provider implementations, improved tests and documentation, and better observability so that swarm-external-secrets becomes a more enterprise-ready secret management solution for Docker Swarm.
<p>Nowadays, Ceph supports Kafka, HTTP and AMQP(ver 0.9.1) endpoints natively from the Ceph Rados Gateway. However, to allow for a large variety of endpoint types to integrate with Ceph, we are encountered with some inconvenience on these various protocols from different service infrastructure. The workaround for the notification brings the burden of adaptor deployment, communication and translation overhead.AMQP 1.0 is the latest standard for AMQP. It focuses on core features which are necessary for interoperability at Internet scale, and it contains less explicit routing than previous versions. Even though Ceph has supported the AMQP(ver 0.9.1) natively, the gap between these two protocol specifications cannot be ignored. The next level AMQP(ver 1.0) requires a completely different client library. AMQP 1.0 brokers are supported by Apache Qpid/ActiveMQ project and Azure platform, etc. To address this problem, we should support the AMQP 1.0 natively in the Ceph Rados Gateway. This requires adding the qpid-proton client library to the Rados Gateway code base, and use it to send notifications to AMQP 1.0 compatible brokers.</p>
<p>Python 3.5 has syntax features that are unavailable in the previous versions. They grant improved support for asynchronous programming (PEP 492), matrix multiplications (PEP 465) and the unpacking operator (PEP 448). The goal of this project is to implement these features in PyPy3. This way support for Python 3 code gets improved. Implementing coroutines will be the main feature of this project, as this feature offers more new methods than the other features. PEP 465 shows that Matrix multiplication is already used more often than bitwise operations in numeric libraries. Also, having coroutines with async and await syntax as well as enhanced unpacking options, the possibility that Python 3.5 syntax will be used in upcoming code rises. Therefore, an implementation of these features in PyPy3 will definitely increase compatibility to future Python 3 programs. In order to support PyPy’s Python 3 compatibility even further, other new features of Python 3.5 and 3.4 will be implemented after finishing the three PEPs if there is enough time, starting with the enum module of 3.4 and continuing with PEP 461 to allow support of the % formatting operator to bytes and bytearrays.</p>
<p>Currently LabPlot has some support for the plotting of live data, which can be read from file/named pipe, TCP socket, UDP socket, local socket and serial port. The goal of this project is to provide support for the plotting of data received via MQTT protocol from a certain broker. LabPlot currently doesn’t provide any support for MQTT, even though it would be quite important for LabPlot to provide this kind of support, since it is a scientific data plotting software and MQTT protocol is widely used to transmit certain sensor data.</p> <p>This project would increase LabPlot’s usability regarding analyses of scientific data, monitoring data collected by sensors, that is transmitted by MQTT protocol, or even make LabPlot usable in the field of Internet of Things or Smart Home Appliances.</p> <p>The project would involve extending LiveDataSource class, ImportFileWidget, LiveDataDock and AsciiFilter in order to set up a connection with a MQTT broker based on information provided by the user. Then LabPlot could receive and handle MQTT messages, save and plot the data transmitted by them. Already existing functionality for other types of live data source will be adapted to this protocol as well.</p>
<p>In this project, my work will mainly focus on to develop new features for Amahi 12. Amahi is one of the best open-source media server software available right now and is well known for its easy to use interface and functionalities. The "Platform" is the core software of Amahi and it is in development for the last 7 years. Amahi 11 is the latest version of Amahi and it is officially released last year in 2018 and provides support for fedora 27. Amahi 12 is currently in the development phase and will be released soon with support to fedora 30.</p> <p>Main Objectives:-</p> <ul> <li>Improve Platform and implement new features for Amahi 12.</li> <li>Fix existing plugins and provide them support for the latest version of Amahi.</li> <li>Update Dockerfile and create new docker image supporting latest Amahi.</li> <li>Completely implement backend and plugin of friending feature. This will help Amahi users to share files and Shares with other Amahi users with permissions control.</li> <li>Implement let's encrypt feature for Amahi to generate certificates for establishing secure connections with yourhda.com subdomains.</li> </ul>
The GA4GH Service Info API is a required component across standards such as TES, WES, and TRS, providing essential metadata about a service. Currently, each implementation must manually develop and maintain its own /service-info endpoint, leading to duplication, inconsistent metadata, and difficulty in supporting new capabilities such as security and extensibility features. This project proposes a reusable GA4GH ServiceInfo Sidecar a lightweight proxy service that runs alongside existing GA4GH services and handles /service-info requests centrally, while forwarding all other requests transparently to the backend. The sidecar will generate standard-compliant responses using a combination of static configuration (config.yaml) and dynamic metadata collected through a plugin system, enabling seamless support for service-specific and custom extensions without modifying backend code. The project will deliver a production-ready implementation with schema validation, extensibility aligned with GA4GH specifications, and deployment support via Docker and Kubernetes. Additionally, the sidecar will support Trusted Execution Environments (TEE) by advertising attestation capabilities via the ServiceInfo API and delivering attestation reports through a dedicated endpoint, enabling verifiable trust without implementing low-level attestation logic.
<p>Soletta has its own implementation of the lightweight machine to machine (LWM2M) protocol. The LWM2M protocol is used to remotely control IoT devices, these include: Firmware updates, status reporting and etc. Although Soletta already implements the LMWM2M Server and the LWM2M Client, Soletta's implementation is lacking some main features, namely: an LWM2M Bootstrap Server, Message Encryption and Data Access Control.</p> <p>The idea is to:</p> <ul> <li>Add support to LWM2M Bootstrap Server on Soletta, as specified by OMA, enhancing IoT developers' choices on how to bootstrap their machine-to-machine devices.</li> <li>Add support to CoAP Message Encryption inside Soletta's implementation of LWM2M, giving IoT developers' an increase sense of security when using LWM2M through Soletta.</li> <li>Add support to Data Access Control, allowing a LWM2M Client to support one or more LWM2M Servers, by determining which server is authorized to perform which operation. The LWM2M specification specifies Access Control Objects to handle authorization, and they will be implemented from scratch.</li> <li>Deliverables include API Code, Internal Code Changes, Unit Tests, Doxygen Documentation and Sample Applications.</li> </ul>
Support some enhancements to Policy Exceptions. Expected Outcome: 1. Support list of PolicyException namespaces (--exceptionNamespace flag) 2. PolicyExceptions to have a status object and report readiness in printer column 3. Support imageReferences in Policy Exceptions for verify image rules
<p>Brief Explanation</p> <p>Qt is an open source cross platform framework facilitating GUI applications development, for mobile, desktop and embedded devices. Although the framework is written in C++, it brings with it a meta-language (or modelling language), QML. To accelerate UI development, QML provides the Qt Quick Controls module with ready made widget types, each supported by a C++ class, like Button or Switch, ready to be styled and modified at our project needs. The module is currently on version 2.4 but there is no support for Calendar in the latest version, to be more specific, the Calendar was lastly provided in version 1.4 of the Qt Quick Controls module that was released with the Qt 5.3 version.</p> <p>Expected Results</p> <p>The Qt Calendar widget is updated, modified accordingly and ported into Qt 5.12 and Qt Quick Controls 2 current version following the QtQC2 module standards and supporting all features like styling. The Calendar, ideally would have a Template type where from properties like background and/or contentItem can be set for style customisation & switching support. Also, it should be possible to be instantiated as a standalone QML type and be styled locally for regular usage.</p>
<p>This project will span multiple high-priority areas of Zulip, some of which include:</p> <ol> <li>Zulip has support for older versions of RHEL-based GNU/Linux distros. Moreover, CentOS is dead now. Recently I <a href="https://github.com/zulip/zulip/pull/17719" target="_blank">added support for Fedora 33</a>. I will work on adding support for newer versions of said distros and look into supporting Rocky Linux, which aims to replace CentOS.</li> <li>Zulip provides a great way to import data from other chat platforms, such as Slack. I will work on making the transition to Zulip smoother and easier.</li> <li><a href="https://github.com/zulip/docker-zulip" target="_blank">docker-zulip</a> has many production users. However, the project hasn't received the requisite attention. In this project, I will work on revamping the project and troubleshoot any issues that may arise. Zulip 4.0 will be released in a few days. I will work on having it work smoothly on docker-zulip.</li> <li>Apart from these, improving the existing developer tools, integrations to other third-party services, and testing infrastructure will also be a priority.</li> </ol>
<p>Postgresql allows developers more freedom to extend the provided capabilities in an application-specific manner compared to other popular open-source Relational Databases. One example of this is the ability to write user-defined functions in other languages besides SQL and C.</p> <p>Julia is still a new language but with a growing community and increasing popularity due to its several strong points, among which are the Python-like straightforward syntax, speed, and interoperability with other languages.</p> <p>Of course, Julia is nowhere near as established as Python (for which the PL extension is included in the standard releases of Postgresql). Still, as it becomes more widely adopted, I think that adding a more functional pl/Julia to the list of pl handlers available to developers will soon be seen as a useful contribution to the community.</p> <p>In this project I will implement the tasks defined in the project description on the wiki, some of which are also listed as open issues on GitHub, namely:</p> <p>Support triggers</p> <p>Support event triggers</p> <p>Support inline code execution, a.k.a DO statement</p> <p>Support input parameters as arrays</p> <p>Cache procedural language code instead of looking it up every time</p>
The data space approach aims at creating a data federation environment without the overhead of “enterprise” data integration. The concept of data spaces is gaining more and more importance, as this approach offers an opportunity for different stakeholders (data owners, including public bodies and municipalities, service providers offering AI-as-a-service algorithms , service consumers, regulatory bodies, etc.) to collaborate. There are several domains from eHealth to education where this kind of data/service federation is expected to have an important role in the near future. Blockchain is a natural candidate to support several aspects and steps of such collaborations. However, current initiatives do not really seem to fully exploit the possibilities of HFL (and its support for designing privacy-preserving applications with channels and Private Data Collection). The Eclipse Dataspace Connector, maintained by a coalition of European organizations, implements the International Dataspace Standard and also serves as a focal point of the Gaia-X. It is designed to connect multi-cloud environments and has an extension mechanism towards different cloud storage technologies. However, currently these extensions only support storage over designated cloud-based services, but do not offer consortial blockchain connection. The aim of the mentorship would be to develop an extension which support storing data over Hyperledger Fabric as data pane, relying on the Private Data Collection.
The `loo` package is a widely used R package in the Stan ecosystem which exposes a clean API to cross-validate (CV) Bayesian models. As new CV methods and diagnostics are created and adopted by the field, the `loo` package must be updated to support them. Currently different predictive performance measures have different APIs and varying level of supported features. This project is focused on refactoring the API to unify the support for different predictive measures to make all useful features available for all predictive measures to make it easier for the modellers to use the most appropriate measures for their applications. Key technical components will include creating a flexible object which can report multiple metrics and scores. Additionally, we need to create functions to support model comparisons for all these scores and metrics. We will also allow for measures besides log score for LOO-CV to be used under the same, unified interface as existing options and create a consistent loo object for all measures. We will further unify the interface by allowing for non-log score measures for in-sample, test data, and K-fold-CV use cases. We will also be extending the model comparison functions to carry forward information on what measure is being compared, diagnostic data, and information on how to calculate the standard error (SE) of the differences of various measures.
The write operation in flash can only change bits in a specific way and the erase operation changes all the bits of a block to 1s. So to modify any bit the whole block needs to be copied to another memory, erased on the flash, and then copied again from the other memory with the change. Due to this “erase overhead” write operations may require copying a lot of data to modify a small amount. Most flash chips support multiple erase-block sizes and flashrom keeps a list of these sizes and ranges for all supported flash chips. Currently, flashrom tries these functions one by one and uses the same function until the operation is completed or an error occurs. Usually, the first function works correctly but this function erases the smallest erase-block so flashrom would have to use it multiple times to complete the erase operation on a large region, which could have been done more efficiently using functions using larger erase-blocks, thus resulting in a transaction overhead. If a large erase-block size to erase a small region is chosen it would result in a larger erase overhead. So the erase-block size should be picked according to the size of the region left to be erased. Also checking in advance to tell if the programmer supports the given erase function and then sorting the supported functions in order of the erase-block sizes can further help the function selection.