Explore Projects

When you design a digital circuit, you want to make sure that all timings are correct, even post-layout. Therefore, the gate level netlist is annotated with delays extracted from the layout. The file format that contains these delay and timing information is called Standard Delay Format (SDF). Icarus Verilogs' SDF implementation has shortcomings in the following categories: 1. Wire / Interconnect delays 2. Conditional path delays 3. Timing checks Work needs to be done on these categories, all while supporting related bugs as we more completely test gate level simulations. With the work proposed here, I would like to improve Icarus' SDF support to simulate SDF back-annotated timing simulations for the open SKY130 PDK. The deliverables for this project are: 1. Implementing the SDF `INTERCONNECT` feature 2. Writing tests for the regression suite 3. Example of a SDF back-annotated timing simulation using the SKY130 PDK

One of the most requested features for GIMP is support for CMYK and desktop publishing - there's even an FAQ entry on their site specifically for it! While GIMP is primarily focused on digital editing, their backend systems and libraries are more than capable of CMYK workflows. The goal of this project is to enable users to begin using GIMP for creating images for print. A basic implementation consists of three milestones: 1) Allowing users to import and export the most common "print" file formats (.tiff, .pdf/.eps/.ai, .psd) with CMYK profiles. 2) Developing a Dockable Dialogue to simplify the process of changing profiles, enabling soft-proofing, and other related tools. 3) Identifying and improving existing issues with Color Management as part of GIMP's Color Space Invasion initiative. While this basic implementation would not fully implement the "High-end CMYK support" goal in GIMP's roadmap, it would be a step in that direction, and could encourage users and developers to contribute further to that effort.

Pgexporter provides Prometheus metrics for PostgreSQL servers which include some core metrics, as well as custom metrics provided by users. The custom metrics are SQL queries that are run by the various servers, which subsequently may have a variety of PostgreSQL versions. If a query has parts of it not supported by a particular such server, then the whole query gets rejected. This proposal aims to solve this issue by enabling users to provide alternatives of the query of a metric along with the minimum PostgreSQL version on which each alternative query’s supported. Thus, whenever a particular server will need to be queried with a custom query, then based on the PostgreSQL version of the server, the corresponding query will be sent to the server, and the response will be formatted in the form of Prometheus metrics. This will greatly benefit both the users, as well as developers, to provide an out-of-the-box solution and would neither require the updation of codebases to cater to new PostgreSQL major version releases, nor would require the users to adapt to that change.

This project involves working with Capa, a tool which detects capabilities in executable files. The rationale behind the project is that, current static analysis tools often struggle with scripting languages because of its reliance on fragile regular expressions that can be easily evaded . So, this project aims to extend the capa engine to natively support the static analysis of scripting languages using Tree-sitter. I plan to solve it by working towards the merging the tree-sitter implementation pull request. Once it is merged, I plan to extend the tree-sitter to support more languages of which Bash and Powershell are in my priority list. Then, I will extend the feature extraction of the tree-sitter to have more detailed analysis. Next, I plan to write the capa rules which would verify the integration. Also, I will add relevant documentation for ease of developers and contributors. I plan to deliver all the goals mentioned above within the 12 weeks timeline. Beyond GSoC, I plan to stay involved by contributing code, reviewing pull requests and participating in community discussions.

The Raspberry Pi OS Bullseye released with a new open camera stack libcamera, while VideoCapture did not integrate with the new camera backend in time. Given libcamera blocked the access from OpenCV to legacy camera backend V4L2, VideoCapture have to implement support for libcamera backend. A proper approach is to wrap libcamera's APIs in VideoCapture.

<p>JabRef currently only has limited support to interact with pdfs. It can only read XMP metadata and cannot write metadata at all. Since pdfs are a common format to share scientific papers, this should be improved. With the help of the GROBID deep-learning library we want to extract the complete set of bibliographic data from pdfs and use it in JabRef!</p>

<p>MetaCall Core is an open-source software that brings the polyglot programming experience to Developers. With MetaCall, developers can embed different programming languages through an easy-to-use high-level API. Jupyter Notebook is an interactive environment that allows scientists, researchers, developers and engineers to perform analysis, scientific computing, code prototyping and more. These notebooks provide a feature-rich interface where they can capitalize on visualizations, figures, plots and user-interface elements to prototype the code they are writing and working on.</p> <p>This project aims to create a kernel where the MetaCall Core can be loaded and launched through a Jupyter Notebook interface. With this Notebook, the users can try out writing and embedding code in different programming languages. It would also make it possible to use the MetaCall API and achieve the goal of bringing a unified interface for developers to try out and leverage MetaCall. The Kernel would allow developers to load the MetaCall API to execute code in different programming languages by mixing code amongst each other.</p>

<h5>The primary goals are :</h5> <ul> <li>Improved UI Design</li> <li>Multilingual Support</li> <li>Dark Theme Support</li> </ul> <p>Talawa needs both UI and UX Improvements. The current UX is different from what is stated in <a href="https://palisadoesfoundation.github.io/talawa-docs/docs/" target="_blank">Official docs</a>. The color scheme is not pleasing and also a dark theme is needed. As stated on the ideas page, people of different age groups and backgrounds will use Talawa and so the App’s UI needs to fit the requirements of the majority of people. For this, the App’s UI and UX needs to be designed in such a way that people find it easy to use. Currently, for new users, it’s difficult to understand the ideas behind certain UI elements as well as the motivation behind App’s features. The UX should be seamless and people should quickly get habituated to use the app. UI should convey more information pictorially through a combination of colors, Icons, and Text.</p>

The proposed project aims to implement import support for the afdesign format. This new functionality will make Inkscape more versatile and accessible to a wider range of users, particularly users who utilize Affinity Designer in their workflows. The goal is to develop a robust import extension that will enable seamless exchange of design files between Affinity Designer and Inkscape.

<p>Ceph is coded mostly in C++, however many of its high-level parts are written in Python. Currently they support only Python 2.6 and 2.7.</p> <p>The purpose of this project is to port Ceph and its additional components to Python 3.x, which is the current version of the language, while keeping compatibility with the previous versions.</p>

<p>Tree ensembles are arguably the best class of machine learning algorithms out there. They regularly win competitive data science competitions.</p> <p>This project aims to implement the XGBoost algorithm to improve mlpack's tree ensemble support. XGBoost uses decision tree regressors and mlpack didn't have them, so it was also implemented as part of this project.</p>

<p>This project aims to take a step towards a solution, which could make LibreOffice able to handle proper table styles. Implementing table styles in Writer is an ongoing effort for a long time now. However, some major steps are already done, like implementing the table style support in the Writer model, or implementing the ODF import and export filters, there is still a lot of work to be done. This project would aim to do the DOCX import part of it.</p> <p>The problem with the current import is that table styles found in DOCX documents are converted into direct formatting at the level of Writer core. This temporarly solution works fine until someone wants to edit the table, which can cause loss of formatting now. Furthermore, doing this conversion upon opening a DOCX document is very slow.</p> <p>The aim of my project would be implementing the DOCX import of table styles and removing the current style-based formatting conversion to direct formatting. This task may cause the need of extending the existing table style features in Writer. For example, an important, not yet supported property is style inheritance.</p>

clusterProfiler is an efficient package that provides a universal interface for gene functional annotation from a variety of resources and is extremely helpful in data manipulation and its visualization. The idea of integrating Pathway Commons, which is an aggregated database of molecular interactions of approximately 20 databases, brings in scope to analyze data and obtain better results. However, the data lies in GMT format due to which it requires additional functions to bind pathways with their name and gene. It is then saved in RDS format to feed the enricher() function to obtain an enrichResult object. We perform ORA and GSEA using some functions defined in R script on Pathway Commons data to support it in clusterProfiler. With the advent of a new technique ssGSEA (single sample Gene Set Enrichment Analysis) used to quantify the activity of a specific pathway or gene set in individual sample,for example, analyzing heterogeneous samples (tumor samples), integration of ssGSEA with clusterProfiler will help in better medical analyses. Thus, using packages like GSVA(Gene set variation analysis) and GenePattern we can calculate enrichment scores in permutations and support ssGSEA in clusterProfiler.

<p>This project proposed implementation of P frames with motion compensation and motion estimation support for FFv1 FFmpeg codec and its fine-tuning until the best compression rate is achieved. It is important to provide common use lossless FFmpeg codec with ability to work with P frames, so it would be more effective and it would make FFv1 competitive with existing I+P frame lossless codecs.</p>

<p>This project aims to implement <strong>multiple translation formats</strong> inside the <strong>intl_translation</strong> dart package. The main goals are to support the most used formats in mobile development and to allow developers to add new formats through their own packages. If you are interested in this project, check the <a href="https://github.com/jamesblasco/intl_translation_format" target="_blank">project proposal</a> and give some feedback</p>

The following points will be completed by the end of the projects: ● Data collection. ● Data preprocessing ● Choosing and implementing an AI solution and training the AI model on the preprocessed data ● Testing and iterative refinement of the model ● Integration and deployment of the AI system (e.g., Slack channel, website chatbot) ● Documentation and user guidance The final product will be an AI-powered support system for the Mifos/Fineract community

One of the most important features of WasmEdge is its support for non-blocking network sockets. However, the current WasmEdge API for async networking is still cumbersome. Rust developers would prefer to use a Tokio-like async / await API for such tasks. But Tokio is multi-threaded and cannot run correctly in standard single-threaded WebAssembly. Yet, it is possible to provide a single-threaded Tokio runtime. Our goal is to create a WebAssembly compatible Tokio scheduler.

Miri is a testing tool to check undefined behaviour in unsafe Rust. Currently, a significant portion of Tokio async program still cannot be effectively tested with Miri due to unhandled system calls. This project aims to rectify this limitation by offering support for Tokio async in Miri through a complete implementation of epoll shim. By doing so, it will open up a whole new part of the async ecosystem to be tested with Miri, ensuring greater reliability and stability in Rust ecosystem.

Clang includes libInterpreter, a framework for incrementally JIT compiling and executing C++ code. The goal of the project is to port this to WebAssembly and run inside a Javascript engine in a browser. This would involve modification to libInterpreter to run in WASM and produce WASM JIT code. These separate WASM modules need to be linked together and executed in the JS engine. If possible, the final goal is to integrate this with JupyterLite, a version of Jupyter that runs WASM kernels entirely on the client side.

<p>This proposal aims to bring scripting support to SwiftPM. The goal for GSoC is some kind of proof-of-concept and is expected to be the foundation of a full implementation of this feature. The outcome is expected to be a prototype of the new <code>swift-script</code> tool, which has a limited set of basic operations implemented like <code>run</code> and <code>reset</code>. There will also be a new flag for Swift Driver which enables a shortcut to the feature through <code>swift</code> command.</p>

<p>Videos in Kdenlive are edited by applying filters or effects, however, the application is largely limited in its ability to customize and edit subtitles. At present, subtitles are added as an effect, namely using the Subtitle effect. The effect uses an FFmpeg filter to burn the subtitle file onto the respective video.</p> <p>Basic Subtitling Support in Kdenlive can be achieved by extending the functionality of the existing “Subtitle” filter thereby giving users more choices over subtitle customization.</p>

This project aims to expand support for serious games within the Cormas platform, enabling easier interaction between players and environment, and autonomous agents. By extending Cormas with “playable” components the project will contribute to the development of a generic solution for designing, playing, and analyzing serious games. The planned development includes three phases, covering initial implementation, testing, and system optimization, with the ultimate goal of creating a first working prototype with a user interface accessible via a smartphone.

QuantumClifford.jl is a package designed for simulating Quantum Clifford circuits, circuits that consist of Clifford gates. QuantumClifford.jl can be highly useful for designing Quantum error-correcting codes. Since applying Clifford gates to Stabilizer states is mathematically similar to Linear Algebraic operations, we can utilize GPU to parallelize the process and make it significantly faster. This Summer of Code project consists of implementing the aforementioned Clifford gate operations in GPU kernels, and then seamlessly integrating them into the rest of the QuantumClifford library.