Find open source projects actively accepting contributors. Search repositories, filter by program milestones, difficulty tags, or tech stack.
Use our Orbit AI Matcher to find out! Get instant matching scores based on your developer skills, preferred frameworks, and contribution experience.
Convert your selected open-source project into a winning GSoC, LFX, or Outreachy application using Proposal Studio.
This proposal seeks to enrich the mlpack library by incorporating advanced evolutionary strategies, specifically focusing on enhancing the Covariance Matrix Adaptation Evolution Strategy (CMA-ES) through the integration of Increasing POPulation size CMA-ES (IPOP-CMA-ES) and Self-Adaptive Surrogate-Assisted CMA-ES (saACM-ES). The core of this initiative is to tackle complex optimization problems more effectively by leveraging these sophisticated variants. CMA-ES is celebrated for its adaptability and effectiveness in dealing with real-world optimization challenges by dynamically adjusting the search distribution. To augment this capability, the IPOP-CMA-ES variant introduces a restart mechanism with an increasing population size, aimed at improving the algorithm's ability to escape local optima and discover the global optimum in multimodal functions. Further enhancing the CMA-ES framework, the saACM-ES variant employs a surrogate model to approximate the objective function's landscape, significantly reducing the computational expense of function evaluations. The project is structured around three pivotal deliverables to ensure a clear, measurable progression. Initially, by week 6, the IPOP mechanism will be fully integrated, accompanied by comprehensive tests and documentation. Following this, the saACM-ES strategy will be implemented by week 10, ensuring its reliability and efficiency through extensive testing and well-detailed documentation. The final stage, culminating in week 12, involves refining the implementations, enhancing documentation, and showcasing the new capabilities through examples. This comprehensive approach aims not only to bolster mlpack’s suite of algorithms but also to pave the way for future innovations within the library.
LabPlot is renowned for its proficient 2D visualization capabilities, encompassing diverse plots like line, scatter, and variations. However, to cater to the evolving demands of scientific research, it is imperative to extend LabPlot's visualization toolkit into 3D plotting. The rationale behind this expansion lies in the intrinsic limitations of 2D visualization when dealing with complex, multidimensional datasets. While 2D plots provide valuable insights into relationships between two variables, they often need to capture the intricate interplay among multiple dimensions in scientific data. By introducing comprehensive support for 3D plotting, LabPlot aims to overcome these limitations and empower researchers with a more immersive and insightful visualization experience.
ROCm is one of the open source alternatives and main competitor to CUDA. Currently, Debian and its derivatives supports only the core packages of ROCm like the driver, runtime and compiler. However, there still exist some peripheral tools and high level applications cannot be simply installed by users, making it still in the early stage for the Debian ecosystem. In this proposal, we are going to build, package and upload these missing softwares into Debian repositories to provide Debian users flawless experiences. We plan to initially package some simple softwares like monitoring and documenting tools, and then high level applications like PyTorch. After familiarizing the basic packaging skills, it comes to more challenging tasks like bug fixing and providing supports for wider GPU architectures. The final deliverables will be a series of ROCm packages with the community quality assurance met.
The project focuses on enhancing UV mapping workflows by introducing a user-friendly weld-seams utility for efficient UV island merging, drawing inspiration from community suggestions. It will further develop an advanced welding operation that adjusts surrounding geometry to reduce distortion, alongside exploring sophisticated fitting techniques for improved accuracy. Additionally, the initiative will broaden its toolset to include specialized welding tools for both shared vertex and arbitrary island merging, aiming to streamline and refine the UV mapping process for users.
This project aims to enhance the accessibility and usability of the ASCETIC framework, which interprets tumor evolutionary signatures crucial for patient stratification and treatment decisions. The proposal involves developing a Shiny app in R, providing an intuitive dashboard facilitating user interaction with ASCETIC. The dashboard will feature sections for uploading and analyzing data, performing inference, and visualizing survival curves. By simplifying the analysis of oncological data and translating complex molecular information into actionable insights, the project aims to empower users to make informed clinical decisions. The deliverables include a fully functional dashboard with intuitive navigation, data visualization tools, inference capabilities, and project management features such as saving and reloading projects.
The project aims to create an intuitive tool in React for browsing AiiDA graphs, replacing the outdated AiiDA Provenance Browser in Materials Cloud Explore. This tool will interface with AiiDA via REST API, enabling dynamic graph exploration, clear differentiation of input and output nodes, complete visualization of connecting nodes, and node preview without page redirection. The desired result is an AiiDA node graph viewer developed with React, potentially published as a Component on the npm repository
lpython is a statically typed compiled programming language with syntax inspired by Python programming language. lpython also aims to have first-class support to work with Python and C libraries. lpython has multiple backend targets like C, C++, and LLVM IR that can be compiled to target executables with appropriate C/C++ compiler or the LLVM compiler toolchain. As lpython is statically typed and ahead-of-time compiled it offers much better performance than cpython. The current state of lpython is not feature-complete nor bug-free. I propose to add an interactive shell for lpython, so that the developers can quickly prototype ideas, and improve the debug information generated for the LLVM backend so that users can execute a single line of code at a time and pretty print variables and complex datatypes.
This project aims to make Sugar activities more accessible to a wider audience by extending them beyond the Sugar environment. It involves maintaining existing flatpak applications and porting 12 new activities to flatpak. The selection of activities for porting is based on their usability, popularity, and impact on users.
Jitsi relies on multiple services across diverse containers, necessitating robust observability tools for effective monitoring. The Prometheus Scraping & Grafana Dashboard project for Google Summer of Code (GSoC) aims to integrate Prometheus to collect metrics from each container seamlessly. By leveraging Prometheus exporters within Jitsi's infrastructure, essential metrics such as resource utilization, network traffic, and service availability will be gathered. These metrics will then be visually represented through Grafana dashboards, providing administrators with actionable insights to enhance system performance and facilitate proactive troubleshooting. This integration promises to make stronger operational efficiency and reliability within Jitsi's infrastructure, ensuring uninterrupted video conferencing experiences for users. To further enhance monitoring capabilities, triggers will be set up to notify administrators through communication channels in the event of any issues. By empowering administrators with comprehensive monitoring capabilities, the project underscores Jitsi's dedication to delivering high-quality communication solutions. With Prometheus and Grafana at its core, this initiative not only enhances observability but also strengthens Jitsi's ability to maintain and optimize its complex environment, furthering its commitment to providing a seamless communication experience.
My proposal focuses on enhancing the Rocket.Chat platform with an AI-driven feature, "AI Query Assistant," aimed at solving the challenge of efficiently handling user queries. Leveraging a Retrieval-Augmented Generation (RAG) pipeline, the assistant will accurately interpret and respond to user requests using AI-based image recognition. This integration will significantly streamline the process of request handling, reducing response time, and improving overall user satisfaction. The project involves configuring the RAG pipeline with advanced AI components, ensuring adaptability to different service domains, such as healthcare and IT support. Key deliverables include a fully integrated AI assistant within Rocket.Chat, capable of intelligent interaction, alongside comprehensive documentation for ease of use and future scalability. The successful implementation of this project will result in a more intuitive, efficient, and user-friendly query resolution mechanism within the Rocket.Chat environment.
This project proposal aims to implement a cluster of priority features in zulip/zulip related to the settings system and write API documentation for various endpoints.
This project aims to allow using dynamically loaded Clang plugins on windows by adding support for building LLVM and Clang as shared libraries on Windows with all the public c++ API exported and dynamically linking to them. Part of the process will be automated with a tool built using the Clang tooling API to automatically add export macros on the appropriate class and functions declarations in llvm public headers. Deliverables: End users can use custom clang plugins with official windows build of Clang. The llvm windows binary install size can be greatly decreased by dynamically linking llvm tools to the LLVM and Clang shared libraries.
Developing a native Swift-etcd client aims to seamlessly integrate etcd, a distributed Swift key-value store into Swift applications. This project aims to enable developers to have efficient communication with etcd servers via gRPC API, by targeting authentication, key-value operations, watch operations, and lease management.
In evanix we explored making the scheduling of Nix builds more controllable. in particular, we look into implementing constraints such as –max-builds and –max-build-time, which ensure that build operations remain within manageable limits while maximizing throughput. Here the scheduling problem is framed as a mixed integer linear programming(MILP) problem. The input is a graph G=(V,E), where each vertex v represents a Nix package with a cost w(v) and a value p(v). packages that are classified as transitive dependencies—those required solely for other packages carry a value of 0. In contrast, packages that are requested for direct building are assigned a value of 1. This value structure reflects the prioritization of building requested packages over their dependencies. Our approach aims to identify a set of vertices or packages following the precedence constraints that maximizes the value or the number of packages built with value 1. It is crucial that a vertex or package can only be selected if all of its dependencies are also selected. An edge in the graph represents a dependency, with the indegree of a vertex denoting the number of packages that depend on it and the outdegree representing the number of dependencies of the package. We also developed a linear regression model to predict build times based on input derivations, enabling us to incorporate this information into our solver when it’s unavailable in Hydra. This predictive modeling greatly enhances our ability to estimate build durations for packages not built by Hydra, particularly those outside of Nixpkgs. By integrating these predictive insights with our MILP-based scheduling strategy, we aim to create a more robust nix build scheduler.
The Audio Overlay Filter aims to provide the functionality of replacing specified sections of an audio stream with other input audio streams. I will be designing and implementing the filter along with the necessary documentation for it to become a part of FFmpeg's libavfilter library.
The problem here is to migrate from gitbook to some other tool which provides us with the feature of generating website from some easy to use markup language like markdown in which the current gitbook is hosted. So, I propose to solve this using antora for website and using asciidoc as markup language for it as it fulfills the main requirments of having a website and ebook(epub). It also have option to customise the UI which could be used to make antora website look more attracting and I have listed why I used this in my proposal.
This project integrates mfsBSD into the FreeBSD release tool set, creating an additional target of mfsBSD images (.img for disc and .iso for optical images) into the `/usr/src/release/Makefile`. Until now, mfsBSD only existed outside the FreeBSD release tool chain, and only the -release versions have been produced. With this project, mfsBSD images are now available at the official FreeBSD release page, and you can also build mfsBSD yourself by invoking `cd /usr/src/release && make release WITH_MFSBSD=1`, which will then create `mfsbsd-se.img` and `mfsbsd-se.iso` at `/usr/obj/usr/src/${ARCH}/release/`.
ENIGMA currently lacks third-party integration with various digital distribution platforms such as Steam, Xbox, or Origin. First-class support for these services would make it easier for Indie developers to publish ENIGMA-created games. Developers would like for it to be easier to monetize their games and enable them to release bigger and better updates to their users. An integrated architectural layer will be created between Steamworks ENIGMA's extension APIs and Steamworks SDK. ENIGMA's Asynchronous system will be updated. Currently, ENIGMA's Networking system is not stable so Steam Networking features will be postponed for later for now I will add support to these APIs: Management, General, Overlay, Leaderboards, Achievements, Cloud, and Social.
Pylops has been developed to solve large-scale inverse problems. Keeping in mind the memory size of a single machine, there is a need to perform the operations in a distributed fashion. The main goal of this project is to use the mpi4py package to exchange messages between different processes across distributed memory. The main outcomes of this project are to develop a DistributedArray class using mpi4py to broadcast or scatter numpy/cupy arrays and perform basic operations like sum, product, dot-product, element-wise product, etc in a distributed fashion. Additionally, MPI functionality will be added to BlockDiag, VStack, and HStack, and the code for forward, centered, and backward finite difference stencils will be updated using Distributed Arrays. Lastly, at least one of the CG, CGLS, and LSQR solvers will be modified to use Distributed Arrays. This will benefit the Pylops Codebase as integrating mpi4py into the codebase will enhance the operators' performance and prevent exceeding memory on a single machine.
The goal of this project is to develop a deep learning model that can accurately recognize various categories of objects in digital photos, and generate corresponding keywords that can be automatically assigned and stored in digiKam's database for each photo. This will improve the efficiency of organizing and searching for photos based on their content. In addition, the facial recognition engine will be improved to increase its accuracy and reduce its inference time. The results of this work will be merged into the master branch, allowing for more reliable and effective facial recognition capabilities in the digiKam application
Overview: In the current scenario, the Knative Eventing Kafka Broker's data-plane communication with Apache Kafka for consuming and producing records is done via the Vert.x-Kafka-client library which is basically a wrapper for communications with Apache Kafka inside the Vert.x threading model. Objictive: This project idea aims to implement the Knative Kafka Broker data-plane communication with the native Apache-kafka-client library working on Java 19 and evaluate OpenJDK 19's Project Loom and leverage its virtual threads for efficient and concurrent communication with the Apache Kafka cluster.
Java Pathfinder (JPF) is a Java virtual machine that can run compiled Java programs as well as model checking it. It is also an extensible software analysis framework for Java bytecode. As it has been created for about two decades, supporting new Java language features is of vital importance for its wide adoption. JPF community has taken steps to add Java 11 support, but there are still some unsolved issues. In this project, I plan to add better Java 11 support for JPF. This includes more comprehensive Java bytecode support, especially for invokedynamic, more JDK API support, and some bug fixes. It will fix all 13 failing tests JPF faces now on Java 11 and enable more programs to run on JPF.
The goal of the proposed project is to extend the existing remeshing functionality in the polygon mesh processing (PMP) package with the adaptive remeshing based on the work by Dunyach et al. (2013). The existing implementation isotropically remshes surfaces in three steps: first, edge splitting or collapsing depending on their length relative to the target edge length; second, edge flipping to improve vertex valence; third, tangential relaxation to improve the vertex distribution. The planned extension with the adaptive remeshing involves expanding the edge splitting and collapsing rules, and introducing a new formulation of the tangential relaxation; in addition, feature edges must be addressed. Apart from implementing those three necessary functionalities in CGAL, the contribution to the project would include creating tests, examples, and documentation.
Shardingsphere federated query engine provides support for SQL statements. In the GSoc period, I have to add support for more MySQL SELECT statements so that more SQL statements can be converted into SQLNode. This can be achieved by: 1- Analysing the SQL statement I have to add support of, 2-Figure out components & logic required , 3- Make changes in SQL federation engine optimizer files , 4- Optimize parser files , 5- Make changes in TEST files to ensure test is passing successfully. After the support for More SELECT statements queries is added, The users & developers will be benefitted by utilising more SELECT queries for MySQL .