Explore Projects

<p>The aim of the project is to develop a <strong>language independent</strong> analyzing routine that will find all <strong>documentation strings</strong> in a file, parse them into <strong>specific groups</strong> and checks them against a <strong>specified documentation style</strong> given by the user. The functionality can be extended to providing a patch that <strong>re-formats</strong> the documentation correctly and checks for <strong>grammatical errors</strong> and performs other <strong>aesthetical fixes</strong>.</p>

This proposal aims to develop a feature-rich programming environment for writing Faust programs in VS Code by providing powerful Language Server Protocol(LSP) features such as code completion, diagnostics checking, definition lookup, etc. and any other features commonly supported by other mature programming language projects. The goal is to enhance and optimize the current Faust programming experience, making Faust development smoother for developers and allowing Faust programming to be more accessible for beginners to the Faust ecosystem.

The current proposal deals with the task of document similarity utilizing dense text representations. Furthermore, it leverages topic modelling to investigate potential non-informative sets of words which could be removed in the preprocessing phase. The latter step will improve training time and hopefully will increase performance on the document similarity task. The task occurred from the need of matching Github issues with the relevant Jenkins logs in order to correlate ci pipeline errors with prior identified issues.

<p>Implementing a vision based terrain traversability estimator for planetary rovers and astronauts to eliminate heavy hardware used in current techniques. Some of the rovers predict the slip from Wheel odometry but it would be more efficient to be able to predict it in advance if a terrain might be slippery, so as to make more intelligent path planning decisions and to reduce the hardware needed. Classified view of the terrain in front based on their traversability proves to be useful for the rover to take an optimum path and for an astronaut being a helping hand to suggest safest path that could be taken.</p>

<p>Netlink is a network protocol that is used to communicate between the kernel and the userspace. For example, iproute use netlink in order to configure the network stack (interfaces, addresses, routes, etc). It is also used by the kernel to report hotplug events to the userland. The goal here is to add support in strace to decode netlink packet structures in order to be able to debug and discover netlink messages.</p> <p>In 2016, the base ground work was done, now it can be extended to support more netlink family protocols.</p>

This project aims to significantly enhance Graphite's rendering performance and capabilities by implementing GPU-accelerated graphics rendering using Vello as a rendering backend, optimizing the existing node graph execution system, and improving the overall editor performance. Key objectives involve improving the speed and ergonomics of the internal compiler infrastructure and laying the groundwork for future raster editing features. My focus is removing rough edges around the adaptive resolution system for users in the node graph and for developers writing efficient nodes.

LuaRocks is the package manager for the Lua language. It is written in pure Lua, making use of several optional libraries. The goal of this project is to port the LuaRocks source code to Teal, a statically typed language that compiles to Lua (Teal is to Lua somewhat like TypeScript is to JavaScript). Porting LuaRocks to Teal comprises essentially of writing type annotations to its source code, but will also allow for many opportunities for refactoring and improving its codebase, understanding and reporting on limitations of the Teal language and possibly inform or contribute to its development.

The project aims to significantly enhance the user interface of the Mission Support System (MSS) - MSUI - by implementing a comprehensive set of usability and functionality improvements, tailored to streamline user interaction and optimize the overall user experience. This project will focus on several areas of UI enhancement, which would include : 1. Integrating small user images for personalized login and chat experiences. 2. Implementing real-time visualization of concurrent users working on an operation. 3. Enhancing chat functionality by adding a server message channel.

The main purpose of this project is to build a C++ library that allows efficient computation of sparse matrices stored in different formats such as COO, CSR, DIA etc. The library would be able to generate code that unifies different formats and generate optimized loops to aid in computation. The library will implement 6 level formats which can be used to represent any of the common tensor storage formats. The library will also implement a code generation algorithm that will allow efficient computations between disparate formats at compile time, thereby improving performance.

LPython is a Python compiler in heavy development. It is currently in the pre-alpha stage. The project includes discussing which modules will be needed for LPython (from a scientific computing perspective, in the beginning), creating a priority list, and then implementing each module properly. The aim of this project is to make LPython work for any Python code down the road. My prime focus during the project period would be on: - Implementing priority modules needed for Lpython - Creating extensive integration tests for respective functions in modules - Zero bugs - Fix the currently identified bugs - Make the documentation more user and developer-friendly

<p><strong>Nuitka</strong> has support for many built-ins, e.g. len already, which means dedicated C code, compile-time evaluation, type shapes produced (in this case an int), but there are some notable exceptions, e.g. enumerate where we know types too, that are still missing but definitely can have high-performance impact on some loops. Not having that means that enumerate using loops are loosing out on many optimization opportunities. This project aims to identify and optimized missing built-ins to achieve complete support for ultimately all C built-ins.</p>

After Postorius and Hyperkitty call the API of Mailman Core to manage the data, they need to poll the Core to confirm that the modification has been successfully executed. This blind query mechanism will increase network and server load and be difficult to scale. This theme uses NATS's publish subscribe mechanism to optimize the steps of getting modification result. After the modification is successfully executed in Mailman Core, a message will be posted on the publish-subscribe(pub-sub) topic. Postorius and HyperKitty can obtain information about the modification result by subscribing to the pub-sub topic and then proceed to the other step.

<h4>When you think about it ccache is a simple feature, however we shouldn't underestimate it's power. This tool is very handy for improving waiting time and resource usage. Even if nowadays a lot of computational power and resources a simple tool like this can make a huge difference in big or even small projects. In my opinion this tool is a MUST in every compiler.</h4> <p>After looking at the tool that is available for C/C++ i can say for sure that we can implement this in Mono. Thanks to the deterministic inputs from Roslyn this won't be a pain in the back and we can simply port the libraries from C++ or make our own.</p>

<p>Every Project's code seems good if it is in proper style. LuaFormatter is a code formatter which helps to style a code in Lua scripts which will also help in easy integration with various code editors But currently, LuaFormatter doesn't check if the configuration values make sense before using it. For example, a clueless user could use a negative value in a field where the range expected is [0, ∞). This project is to implement a lazy configuration validator for the LuaFormatter.</p> <p>After the completion of this project, the validator will be able enough to detect this kind of error and report it to the user in a nice, helpful way.</p>

Rustfmt, the de facto standard tool for formatting Rust code, has been reported that it occasionally fails to format silently. One of the major causes is that the internal formatting mechanism loses the context when issues occur during formatting. While rustfmt heavily relies on the Rewrite trait to format various AST structures, the rewrite method, the only method that consists of the Rewrite trait, returns Option. This makes it hard to track how and why formatting failed. To improve handling of silent failures and allow rustfmt to retry formatting under more contexts, this project aims to refactor the Rewrite trait so that errors occurring in formatting can be propagated.

In atmospheric research flight planning, one task that users have to perform is retrieving a set of plots for several flights or hundreds of time-steps during post-campaign analysis or when compiling an overview over flights of a campaign during hindcasting. Another task is retrieving similar plots of the same parameters such as map section, level etc., on a daily basis. Both of these tasks cannot be accomplished in an efficient manner using the current MSS UI. In this project, a feature would be built to let users download a number of plots in Jupyter notebooks and user scripts in an automated fashion according to the given settings. A CLI tool would also be provided for the same.

<p>At the moment it’s difficult to customise webpack’s output and it requires a deep knowledge of the internal workings of webpack and webpack-cli. The reporter implementation would cover:</p> <ul> <li>Set of APIs to expose every possible reporter where it will be possible to override webpack’s output.</li> <li>A basic reporter would be a separate package (and testable), the package will have to implement some APIs that will hook to webpack internals and will log the resources emitted by the compiler.</li> <li>Ideally written in TypeScript (the basic one) so it will expose also the interfaces.</li> </ul>

<p>The Webpack Dev Server is designed to make development of Webpack projects efficient, customizable, and possible on older browsers. During this project, I will introduce native WebSockets on the client and ws on the server as the new default Dev Server implementation, while also allowing the user to provide their own client-server implementation. I will improve upon API/CLI uniformity, which has made the Dev Server difficult for users to work with in the past. Finally, I will fully implement the Dev Server into webpack-cli, and I will create core Webpack features that allow the Dev Server to more easily interact with the Webpack Compiler.</p>

The CVE Binary Tool helps the users to determine if their system includes any known vulnerabilities or not. This project idea focuses on creating a GitHub Action for cve-bin-tool which will produce CVE reports in the GitHub Security Tab and will be able to split the issues on the basis of triage. It will be smart enough to scan dependency lists of various languages and suggest version upgrades in the form of pull requests. Also it will produce reports in the form of html and pdf by default in the Security Tab. The GitHub Action will be configurable through yml config file and will be able to scan repositories and SBOMs.

This proposal seeks to enhance the d-SEAMS core engine's usability and extend its capabilities through two main initiatives: simplifying the installation process by building and distributing Python bindings via PyPI, and incorporating advanced visualization and machine learning functionalities. By leveraging tools such as PyVista for visualization and scikit-learn for data analysis, the project aims to make d-SEAMS more accessible and powerful for researchers in molecular simulations, contributing to advances in genetic disease research and understanding of ice nucleation. This comprehensive upgrade will provide an easily installable, more versatile tool for the scientific community, enhancing research workflows and outcomes.

Webpack's extensive API definitions are currently locked inside raw types.d.ts files, creating a significant manual maintenance burden to keep the public documentation synced. My proposal solves this by building an automated, version-aware CI/CD pipeline. I will extract TypeScript ASTs using TypeDoc, format them via typedoc-plugin-markdown with a custom webpack-doc-kit theme, and integrate them into @node-core/doc-kit. The final deliverable is a polished, searchable React-based UI that matches Webpack's visual identity, completely removing the manual documentation overhead from the core team.

This project will build and integrate a Python-based client for the buildingSMART Data Dictionary (bSDD) directly into FreeCAD's BIM Workbench. This integration will allow users to dynamically search and apply international classification standards from the cloud, providing context-aware suggestions based on the underlying IFC entity. To ensure a stable and non-disruptive integration, the project will implement a "dual-layer" data model. This approach will securely store the rich, web-fetched bSDD metadata while automatically populating the existing legacy string properties, guaranteeing 100% backward compatibility with FreeCAD's current stable workflows.

The end goal of this GSoC project is to design a simple and portable process for building and installing Pallene on any of the three major operating systems (Windows, macOS, and Linux). The process will not depend on any external services or system-level packages. No dependencies other than Make and a C compiler for building and installing Pallene. Deliverables: - Simplified build process. - Simplified install process. - Eliminating of dependencies on external systems for building and installing Pallene. - Updated documentation with the new steps. - Updated CI script with separate steps for building, testing, linting, and installing Pallene on all three major operating systems. - Reduced dependencies. - Removal of old build scripts.