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.
The aim of this project is to refactor ALTQ to use improvements in both the API and implementation. ALTQ was written a long time ago and suffers a lot of code duplication, dangerous code practices both in the API and implementation and could use these improvements by Handling duplications, Introducing good design patterns, and Making code more maintainable. ALTQ will also be optimized for large networks as well. After these issues are addressed, ALTQ will be configured to be integrated with npf which is the NetBSD packet filter which focuses on high performance design and large volume client handling since ALTQ is also currently integrated with pf packet filter which is obsolete. In ALTQ configuration with npf, npf will be configured to use ALTQ by creating a new /etc/npf.conf where all the ALTQ queuing and policies to apply to different types of traffic and filtering rules will be defined and integrated.
This project aims to deliver a Rocket.Chat App that uses generative AI to summarize any conversations across threads, channels, and DMs. For example, a user can say, "summarize my unread messages yesterday in the #engineering channel". The users can ask AI any questions regarding the messages, and subscribe to personal digests that summarize selected channels on a recurring schedule. The AI summarizer will boost the productivity of Rocket.Chat users with faster information digest, and improve community engagement by keeping everyone on the same page.
As Generative AI technology is improving and being implemented in various applications, I am interested in using it in Rocket.Chat. While we already have a Giphy App that can fetch GIFs from Giphy, I propose to create an RC app that can generate GIFs based on user prompts. The RC app will allow users to enter their prompts, wait for the generation process, and then use the generated GIF seamlessly anywhere. We will be using an open-source & self-deployed model to generate the GIF. To ensure the app can serve multiple users in parallel, we will use the concept of databases as Task Queues, to store the status of multiple GIF generations in parallel. Excited to see what people generate using this feature.✨🚀
This Google Summer of Code (GSOC) project aims to improve the performance of the libc string manipulation function of the FreeBSD operating system on ARM-based systems (aarch64 architecture). The focus is on porting existing SIMD (Single Instruction Multiple Data) optimizations from the amd64 libc library to arm64, enabling FreeBSD to take full advantage of the NEON instruction set and laying the groundwork for future SVE support. This work builds upon previous SIMD enhancements done by Robert Clausecker <fuz@FreeBSD.org> for amd64. Deliverables include: Introduce a new ARCHLEVEL flag for the aarch64 architecture, allowing selection between base, NEON, and SVE instruction set extensions. This will involve creating an `aarch64_archlevel.h' header file to manage the different levels of architectural support. Update the `simd(7)' manual page to document the new SIMD-accelerated string functions for aarch64, including details on the ARCHLEVEL flag and its usage. And port the functions with already existing SIMD implementations for amd64 to aarch64. A full list of those functions are available at /src/lib/libc/amd64/string
The massively parallel nature of many real-world computations has led to the development of specialized massively parallel hardware such as GPUs, TPUs and FPGAs. Many closely-related programming models exist such as CUDA and OpenCL. OpenCL is a popular framework for writing massively parallel code given its broader ecosystem and supported platforms. GIMP is a popular free open-source image manipulation tool often shipped as the default tool in many Unix-based distributions. GIMP uses GEGL internally for accelerating various image processing tasks. GEGL comes with OpenCL implementations for many operations. However, the OpenCL backend in GEGL was often slower than the baselines and resulted in incorrect outputs (and crashed sometimes). The goal of this project is to enumerate all the existing OpenCL implementations in GEGL, write a thorough suite of tests for them, and fix as many implementations as possible. If time permits and once correctness is established via tests, the project adds new faster implementations for popular operations. A successful completion of the project would allow the OpenCL backend to be enabled by default and allow the end-users to take advantage of hardware acceleration on their devices automatically.
This project would improve the workflow of editing of geometry of paths. Combining strengths of Pen tool and Node tool with modifiers and new behaviors. Deliverables for the project are listed in the following repository along with the proposal: https://gitlab.com/SK1PPR/inkscape-gsoc-proposal
The openSUSE project is a worldwide effort that promotes the use of Linux everywhere and creates one of the world's best Linux distributions. Analytics Edge Ecosystem Workloads (AEEW) is one of its open source projects to provide an open source deployment of well trained, tested, and functional AI/ML or Generative AI workload on the Edge for the business verticals such as Retail, Healthcare, Finance, etc. leveraging Kubernetes and containerization technologies for efficient deployment and management using Rancher by SUSE, while openSUSE Leap will serve as a base layer for both Kubernetes host and containerized workloads. In this GSoC project, we look forward to developing workload focusing towards the Retail sector to address the needs of businesses operating within this industry. Given the challenges faced by retailers in adopting AI/ML or Generative AI technologies due to computational costs and data privacy concerns. The solution will offer a seamless deployment and management of these workloads at the Edge.
Neural networks are descendants of McCulloch & Pitts' threshold-based mathematical model of a binary neuron, but there is ample evidence that unicellular organisms are capable of relatively complex maze navigation and other cognitive tasks, indicating information-processing capabilities in cellular subsystems. The task is to develop a computational model of elementary processing of analog information using Schrödinger's wave equation and Pilot Wave theory, leveraging the fact that a quantum wave function has multiple valid solutions and only one of them manifests. In Bohm & Hiley's elaboration of Pilot Wave theory, the Quantum Hamilton-Jacobi Equation can be decomposed into a classical component and a quantum component, the quantum potential. Most of the energy is in the classical component, but a small part of it is in the quantum potential. As the energy in the quantum potential is informed by and responds to the shape of the quantum wave, the process creates new information, expressed in the trajectory of the particle. The trajectory will help us take decisions. We propose two techniques, Statistical approach and Instantaneous approach. Both of the approaches use Pilot Wave theory since it is causal. For Statistical approach we will model the double slit experiment with Bohmian mechanics. The slits shape will depend on the input. We will pass many particles through the slit and take decision based on the interference pattern produced and the trajectory of the particles. In the second approach we will model the FMO complex in Green Sulphur Bacteria. Our model of the FMO complex will be used for Binary classification. There will be multiple slits in this and we will use AI to find the dimensions and location of the slits. Based on the trajectory we will take decision.
Project Description: The existing completion functionality for cargo commands is achieved through the maintenance of a completion script. This script is difficult to maintain and cannot be easily ported across different shells, with each shell requiring its own specific completion script. How to solve: This project aims for the completion script to call an external completion program, thereby realizing the implementation of the completion functionality in Rust language, instead of shell completion scripts. Rust will bring various advantages such as safety, testability, portability, and ease of extension. Deliverables: 1. Implement a stable and easy-to-use dynamic auto-completion script generation module for the clap project. 2. Implementation of cargo dynamic completion feature. 3. Testing the cargo dynamic completion feature
ArviZ is a package for the exploratory analysis of bayesian inference models. The current Python release of ArviZ involves three major modules that also encapsulate its core functionalities- data, plots, and stats. These are planned to be split into packages of their own, like arviz-plots, arviz-base, and arviz-stats. Development work involving the creation of these is being undertaken, with some key refactoring changes especially planned for the arviz-plots based plotting functionality, which is what this project is based on. The current plots that Arviz supports were added incrementally to the package over time, including in past GSoC projects, resulting in some redundancy and complicated to extend code. Plans and brainstorming for refactoring this have been around for a while. Work done so far on ArviZ-Plots has included a new class, PlotCollection, an improved backend interface and backend system, and 4 “batteries-included” plots at least partially adapted for this new backend. For my role in the course of this project, I will be using the PlotCollection class to implement some other plots from old ArviZ and add modular backend functions and visual elements (an intermediate layer for atomic visual elements used across plot types) required for these as appropriate. I will also be working on creating documentation and tests for these new plots added to ArviZ-plots as well as the PlotCollection class used to do these. For users, the refactored changes aim to provide improved visual aesthetics, an abstraction of aesthetics mapping to subplots and a more compact, flexible API overall. For developers, easier writing of new plotting functionality, extensibility and maintainability are the goals.
I propose to solve some existing problems, improving the current User Flow and introduce a few new innovative features I plan to deliver the following 1. Dummy Backend Environment Script: Develop a script to set up a dummy backend environment mirroring the main instance. This allows new contributors to explore and contribute to backend logic effectively. 2. Chat/Comments Integration: Enhance user experience by integrating text-based communication into Rooms and Discussions. This facilitates communication between creators and subscribers, improving consistency. 3. Improved Pair Chat Experience: Enhance the pair chat by displaying the number of users in the lobby, providing transparency and estimated wait time. Implement a user-friendly interface to access this feature and introduce features like rating and following. 4. Friends Feature: Implement a Friends feature to enable direct voice and text communication between known users, fostering social connections and group interactions within Resonate. 5. Stories/Podcast: Introduce a platform for users to share voice content, including features like follow, community formation, and search functionality for categories and specific content. 6. Enhance App Colour Functionality and Bug Fixes: Improve App Colour functionality, ensuring consistent changes across images and widgets. Address bugs and refine the app for production-level quality. 7. Push to App Store and PlayStore: Finalize development and publish the application to App Store and PlayStore, making it accessible to a wider audience and marking the completion of the GSOC contribution.
Our final goal of this project is to obtain missing scores for Symbolic PathFinder(SPF) in SV-COMP. There are two main reasons why SPF is losing many points. First, there are too many unconfirmed results. Even though we provided correct results, we’re losing points because these results cannot be verified by witness validators. To address this, we should support generation of violation witness in a format that witness validators can verify. Second, there are incorrect results. To deal with this problem, we will analyze why SPF outputs wrong answers for certain task and repair SPF to work correctly. In addition, we will categorize why SPF outputs some incorrect results.
The builder tooling of JupyterLab is directly integrated in the core codebase. This causes maintenance to become a burden for both core developers and extension creators. Reusability of the builder’s functionality is also constrained. To tackle this problem I propose to extract and refactor the builder tooling into a separate well defined package. Thus a new command line interface will be created with a wide range of features and functionalities, apart from its primitive purpose.
To be able to easily and continuously scan packages with fossology checks in CI pipelines, a docker image (fossology/fossology:scanner) capable of running license checks (using nomos or ojo) and keyword and copyright scans is available. The motivation for this proposal is to improve the CI Scanner Image in various aspects and numerous quality of life improvements, like highlighting the exact location of violation, ability to customize the keywords used by the scanner, and improving user experience – allow whitelisting from a custom location and ability to download and scan dependencies. The major goals of the project are: 1. Ability to highlight the exact location (line number) of a violation during reporting 2. Allow users to customize keyword scanning using their own keyword.conf 3. Allow users to store allowlist.json file elsewhere (currently, it is required to be present at the root of the project) 4. Allow users to download and scan dependencies by providing a path at CI/CD pipeline trigger.
Deliver an automated method for Debian maintainers to test selected numerical Debian packages for their parallel performance in clusters, in particular to catch performance regressions from updates, and to verify expected performance gains, such as Amdahl’s and Gustafson’s law, from increased cluster resources. A number of numerical packages (typically, software libraries) available from the Debian repositories are designed to make use of parallelism. I will identify key functions to benchmark for, and key parameters to benchmark with. Those parameters may be: function input, such as benchmarking for nontrivial data, or for the cluster environment, such as the number of nodes, or implementations of the dependencies (e.g. BLAS), or the allowed deviation from expected benchmark metric (e.g. running time) before a regression is said to occur. Cluster tests will be configured for execution on the Grid5000 network (https://www.grid5000.fr/) in partnership with project mentor and Debian developer Prof. Drew Parsons. The FEniCS suite of packages for finite element computation will be used as a target case study to develop test protocols. The protocols will then be applied to a selection of other parallelised packages. Finally I will report the information in web pages for ease of consumption. To enable more exhaustive testing of Debian parallel packages, I will conduct an audit of the official Debian repository (and online) for keywords that will bring up numerical packages that use parallelism, beyond the set identified above. I will read their documentation and research the problems involved to find the right functions and data to test for, and I will use the initial data gathered during my benchmarks to establish a baseline for which the regression tests will test against in the future. I will consult references for benchmarking numerical packages to make sure my metrics are meaningful. I will use Plotly to produce graphs for the metrics shown in the web page.
Project Summary: The project aims to enhance Kubernetes container checkpoint management through advanced garbage collection policies. These policies will enable users to efficiently manage checkpoint resources, preventing operational challenges and resource exhaustion. Problem Statement: Current container checkpoint management lacks advanced and flexible garbage collection policies. This results in operational inefficiencies and resource wastage. Proposed Solution: Enhance the existing Kubernetes operator with advanced garbage collection policies. These policies will empower users to define how checkpoints are managed at different levels (global, per-namespace, per-pod, per-container), ensuring efficient resource utilization and preventing operational challenges. Key Deliverables: Garbage Collection Policies: 1. Implement dynamic checkpoint threshold policy for fine-grained control over checkpoint management. 2. Introduce orphaned checkpoint cleanup policy to remove obsolete checkpoints. 3. Implement time-based checkpoint retention policy for automatic deletion of outdated checkpoints. Automated Checkpoint Management (Optional): 1. Automate checkpoint lifecycle management, including creation, replacement, and deletion. 2. Enforce storage quotas and monitor storage utilization. 3. Collect metrics, enable alerting, and implement event logging for proactive management. Impact: The implementation of these garbage collection policies will enable users to manage different container's(pod's, namespace's) checkpoint with different garbage collection policies. It will optimize resource utilization, and enhance operational efficiency. Note: Optional functionalities such as automated checkpoint management will be considered based on available time and project priorities.
Add experimental support to rustc for building and running procedural macros as WebAssembly. Procedural Macro crates can opt in for being compiled to WebAssembly. This wasm-proc-macro will be a wasm blob sandboxed using WASM. It will interact with the compiler only through a stream of token and no ability to interact with the outside world.
The main goal of this project, is to implement in a sofware-defined GNSS receiver (GNSS SDR), EGNOS/WAAS signals. They are both satellite-based augmentation systems (SBAS) that enhance the accuracy and reliability of GNSS. One of the main advantage is the improvement of vertical and horizontal accuracy. By developing acquisition and tracking blocks to capture these signals, precise positioning and advanced research on the ionosphere could be enhanced. As a user with a year of experience using GNSS-SDR and GNURadio, the process of developing the required solution will be carry out in a better way. The expected time to complete the project is 350h, which can be splitted in these deliverable groups: 1.- 50h: acquiring information about the problem and studying the way acquisition and tracking blocks work in GNSS-SDR. The type of signals, the way to decode messages and their structure, should be well understood before starting coding the solution. The proposed deliverable is a short presentation, in order to show this information to the mentors and after that, proceed with the coding. 2.- 250h: the main block of the project. During this period, the solution has to be created in C++. The different processing blocks (acquisition, tracking, observables and PVT) must work at the end of the period for SBAS signals. The proposed deliverables are tracking and acquisition blocks working after the first 150h, and then the integration with the observables and PVT has to be demonstrated. 3.- To conclude, the last 50h of project are dedicated to develop tests to demonstrate the robustness of the solution and to implement the code for real-time signals.
The project aims to address a critical accessibility issue by implementing a feature that automatically generates titles and descriptions for images or files uploaded via the website's image block or bulk upload feature. Presently, users lack the ability to input metadata during these processes, resulting in content without essential titles or descriptions, which is detrimental to ADA compliance. Goals and Deliverables: Create a tool that adds titles and descriptions to images and files uploaded on the website automatically. Use ChatGPT API/token to generate metadata for uploaded content, making it more accessible and ADA compliant. Ensure accuracy and reliability in generating metadata for uploaded items. Test the tool thoroughly to fix any issues and ensure it works well with different types of uploads. Ensure the tool works seamlessly with existing features on the website.
Print Dialogs are vital components for many users, facilitating their printing tasks efficiently. It's crucial that these dialogs remain updated with current print technologies, such as CUPS, and possess the flexibility to swiftly adopt emerging technologies. The Common Print Dialog Backends (CPDB) were introduced as an attempt at de-coupling the print technology (CUPS, print-to-file, that time also Google Cloud Print) from the GUI. The projects have to adopt the CPDB support only once and then OpenPrinting (or any upcoming cloud printing projects) takes care of the CPDB backend for the print technologies to be up-to-date with any changes. The task is to integrate CPDB with the LibreOffice print dialog.
The goal of this proposal is to address the issue of how difficult it can be to package and reuse computational workflows and analyses in genomics and health research since diverse data and workflow standards don't always work together seamlessly. By creating a Python library and related command-line tool that enable bidirectional conversion between RO-Crates (with pertinent computational workload profiles) and GA4GH WES/TES payloads, the RO-GA4GH Bridge project seeks to address this issue.
Lately various AI driven algorithms have been published that are able to extract single instrument recordings (STEM) from an audio track file. Native Instruments has introduced an open definition for stem files STEMS to store these extracts. A Stem file contains the original a stereo track and four additional channel with the musical elements: A drums stem, a bassline stem, a melody stem and a vocal stem, in a m4a container. Currently Mixxx is only capable of playing the stereo track. The goal of this project is to extract all channels and allow the user to mix them individually. In a fist version the Stem mixer can replace the equalizer in the Mixxx GUI. In an advanced version an integration with effects system is desired.
This project aims to create a brand new de-facto Liquid Galaxy Controller that will master all the previous controller apps made for Liquid Galaxy. It aims to create an ultimate umbrella controller application for the Liquid Galaxy Rig, which gives access to all the features of the different controllers that have been developed over time with significant improvements to their features. Some of the features implemented include: Easy POI visualization, Generation and playing of Voice Excerpts, Educational GeoQuest game, Smart-tour planning and visualization, Context-aware recommendation of nearby POIs, Touchless controllers like Face detection, Hand gestures and Voice commands, etc. The ultimate objective of this application is to make the usage of Liquid Galaxy simple, convenient, and enjoyable for all different types of users. The application shall encompass every requirement needed from a Liquid Galaxy rig with a professional, elegant, and tasteful interface.
"Blockchain Crypto Development and Wielding the Power of AI" is a Google Summer of Code 2024 project with OWASP-Foundations that aims to integrate blockchain technology and AI-powered bots. The project focuses on creating a custom blockchain to support a new cryptocurrency, 'BLT Bacon,' and enhancing a Slack bot with AI capabilities. The goal is to leverage AI to automate bug report labeling, provide weekly contribution reports, and enhance user interactions. This project combines cutting-edge technologies to create a robust and innovative platform for the open-source community.