Explore Projects

<p>In this project, File API and related functionalities will be completely implemented in the <a href="https://github.com/servo/servo" target="_blank">Servo browser engine</a>. With these features landed, the end users can upload files through form submission and interact with the local file content directly in browser; the developer will be endowed the ability to read local file content programmatically in either sync or async way, create Blob URL and use them in a very flexible way. In addition, a dialog UI will be integrated to support file picking.</p> <p>For more information, see <a href="https://github.com/izgzhen/gsoc-file-support" target="_blank">the meta-tracker of this project</a>.</p>

<p>Pallene is a statically typed sister of the Lua programming language. This proposal aims to add support for Closures in Pallene.</p> <p>Closures are functions that are capable of capturing variables from outer scopes and retain references to them even after their scope has been exited. The addition of closures and higher order functions will allow programmers to take a functional approach when authoring libraries and scripts.</p>

This project aims to create a robust, high-performance parser combined with an easy-to-use macro system for the Teal programming language. Leveraging a bicameral macro model, the project clearly distinguishes the parsing and macro expansion phases whilst still keeping the syntax streamlined. This enables flexible, powerful compile-time code transformations while maintaining clarity and efficiency in compiler design and performance.

<p>This project seeks to design and implement a class system for Typed Lua which will replace its current class definition style. It should feel like a cohesive component of the language, rather than a layer on top of Lua's meta-programming primitives. Because Typed Lua compiles to Lua and is designed to interact with regular Lua code, its code generator should support user-defined plug-ins for compiling Typed Lua class definitions into a specific untyped Lua class system.</p>

<p>The main goal of the project is, which the title says, to port Terra to Android devices. Once I already have Terra ported to android, my intention is to build an interface between Terra and the android API, that way I am sure Terra will support a lot of features common smartphones have as well as be able to use this features in different devices that have Android on it. This way, by the end of the project, we will not only have ported Terra to android but also develop an interface in which developers can easily access hardware sensors and functionalities to build their own applications.</p>

<p>The goal is to build a <strong>parser generator</strong> on top of the library <em>LPegLabel</em> that will automatically support error recovery and (optionally) white spaces around lexical symbols and terminal symbols. We are going to use a conservative algorithm for error labels insertion, hence avoiding insertion on wrong places and no manual intervention from the programmer is needed. If there is enough time, in the end we will improve the number of insertions using information about unique syntactical non-terminal symbols and unique paths to a lexical symbol. During the coding period, some parsers will be generated with the tool as tests and as examples.</p>

<p>I want to extend the tutorial offered by LabLua for the Ceu language. As it is, when you write code on their website and press submit, the code is sent to their server, compiled and the result is sent back. The problem with this, is that it doesn't show the entire capabilities of the language. For instance if you write a program that prints a message every second for 10 seconds, it will return that message printed ten times in an instant. What I want to do by using Emscripten is to have a real time tutorial, so that after the server sends back the result, it will actually print the message every one second, for ten seconds. I will also want to create a second tutorial that implements SDL as well. SDL is a language that can create shapes and interacts with keyboard inputs and the mouse. There already is compatibility between Ceu and SDL and there is also compatibility between SDL and Emscripten. The challenge is to create a synergy with all three languages. I believe this to be feasible, because you can transform a Ceu program into a C program that can then be compiled with Emscripten.</p>

<p>Pallene is a statically typed, ahead-of-time-compiled sister language to Lua, with a focus on performance. Programmers can use Pallene instead of C modules and LuaJIT to improve and gain a predictable run-time performance. Pallene achieves this by translating a statically typed compilation unit into a C source file, which is implicitly compiled in the background.</p> <p>However, there are situations where removal of type annotations are useful.</p> <ul> <li>The main premise of Pallene is that it is compatible with Lua. This compatibility is defined as removing type annotations from a Pallene program results in transforming it into a Lua program. A Pallene to Lua translator will allow us to check whether this property is still valid. </li> <li>Provides greater portability, interoperability and integration with existing Lua codebase and tools.</li> <li>The Pallene developers could check if the unit tests are obeying the "gradual guarantee".</li> <li>In the benchmarks that do not use LuaJIT features, we could generate the Lua version of the code from the Pallene version.</li> </ul> <p>With the help of the Pallene to Lua translator, users can remove Pallene type annotations to generate plain Lua.</p>

<h5>The project consists of developing an interface, in Lua, for the set of Cloud IoT Core APIs, through two REST resources:</h5> <ul> <li>cloudiot methods, to facilitate device manager tasks</li> <li>cloudiotdevice methods, to facilitate device communication over the HTTP bridge </li> </ul> <h5>The Proof of Concept</h5> <ul> <li>Another task is to provide a Proof of Concept by using a real world device such as NodeMCU/Raspberry Pi interfaced with temperature sensor to send the temperature data over to the Google Cloud IoT Core. </li> <li>Doing the reverse, sending the data to the device using the Google Cloud IoT Core. We expect this data to be a Code Snippet, which would run dynamically on the device every time it is interrupted by the new code received.</li> </ul> <h5>Development of a software interface with REST support in Lua</h5> <ul> <li>With a minimal GUI this application will make the life of a person using Lua REST APIs easier by providing a simple interface to send and receive data from an endpoint.</li> <li>Testing would be done using the Proof of Concept developed above.</li> </ul>

The proposal aims to expand upon the advancements made in the 2023 project, which focused on introducing 8-bit model quantization to OpenCV-zoo. Building upon this foundation, I added Block-wise quantization APIs to further enhance the capabilities of the framework. The primary objective of this project is to develop a comprehensive command line tool within OpenCV-zoo and add inference support to blockwise quantization operations in OpenCV. This tool will facilitate block-wise quantization of ONNX models, offering users a robust and efficient method to optimize their models for deployment across various platforms.

<p>This project goal is to make Linkerd officially support ARM architecture</p>

<p>The aim of this project is to add support for HEIF/HEIC files in FFmpeg. High Efficiency Image File Format (HEIF) specifies the storage of individual images, image sequences and their metadata into a container file conforming to the ISO Base Media File Format (ISOBMFF). This format has increasing usage in mobile devices.</p>

KubeArmor is a cloud-native runtime security enforcement system that restricts the behavior (such as process execution, file access, and networking operation) of containers and nodes (VMs) at the system level. This project aims to support KubeArmor on OpenShift. The work will include compatibility analysis of KubeArmor on OpenShift, finding limitations (if any), and eventually testing it on OpenShift.

This project aims to improve INT8 inference performance for quantized YOLO26 models on ARM devices using OpenVINO. Currently, several transformation gaps prevent convolution layers from being executed in INT8, forcing fallback to FP16 kernels and increasing latency. Two key issues were identified. First, patterns such as Conv → Multiply → Add → Swish → FakeQuantize prevent convolution post-op fusion. During the optimization pipeline, the Snippets pass collapses this chain into a subgraph before the graph optimizer can fuse Swish and FakeQuantize into the convolution, preventing INT8 execution. Second, activation zero-points represented as Subtract operations are not correctly folded into quantization parameters, which disrupts precision alignment and contributes to FP16 fallback. This project proposes to address these issues by enabling fusion of Swish and FakeQuantize as sequential convolution post-operations and by refining transformation handling of activation zero-points. Additionally, the optimization pipeline will be adjusted to prevent premature subgraph formation for quantized patterns, allowing graph optimizations to correctly fuse operations. The goal is to maximize INT8 convolution coverage on ARM while preserving numerical correctness.

Unikraft is a unikernel capable to boot in various environments and through quite a few boot protocols. From supporting the first version of Multiboot, being able to boot through the Linux Boot Protocol on ARM64 and having its own UEFI stub enabling the Operating System to load without a Bootloader, Unikraft has still a lot to learn with respect to the booting environments it knows. One such booting protocol that would be very useful is Multiboot2. This protocol represents a significant improvement over Multiboot version 1, providing improved flexibility in the realm of bootloaders. A notable improvement is the extended information provided by Multiboot2, which provides detailed and accurate communication between the bootloader and the operating system kernel during the bootstrapping process. In addition, Multiboot2 comes with a standardized tag system, enabling easier data and system configuration parsing between the bootloader and the kernel and allowing greater interoperability and better integration of boot modules. The introduction of optional commandline further enhances the flexibility of the boot process. Together, these enhancements contribute to a more robust and scalable bootstrapping mechanism, making Multiboot2 a better choice than Multiboot version 1. Concretely speaking, it would allow us to boot directly in 64-bit mode, while having access to pointers to the UEFI tables as well as the ACPI tables, unlike Multiboot 1, offering us access to more modern firmware interfaces. The task at hand involves integrating the Multiboot2 definitions as well as its corresponding bootstrapping code into Unikraft. Auxiliary scripts may be implemented to allow the automatic creation of Multiboot2-based Unikraft bootable images.

<p>Elasticsearch is very good and scalable search engine. It provides a REST API accessed through JSON format. My project aims to improve the existing elasticsearch-lua client by adding extensive tests and documentation, thereby targeting a stable release.</p>

The project aims to adapt the LuaSQL drivers, which provide an interface between Lua and various database management systems (DBMS), to work seamlessly with the latest version of Lua, 5.4. LuaSQL offers a common API for interacting with different DBMS, including ODBC, ADO, Oracle, MySQL, SQLite, Firebird, and PostgreSQL. However, the last version of LuaSQL was tested only against Lua 5.3, and it's essential to ensure compatibility with Lua 5.4 and potentially leverage new features introduced in this version. The primary focus will be on revising the Lua C API part of the code while ensuring minimal disruption to the existing functionality. Project Objectives - Compatibility Update: Ensure LuaSQL drivers are compatible with Lua 5.4. Code Revision: Review and revise existing Lua C API code for each driver to incorporate any necessary changes considering the new features and changes introduced in Lua 5.4. Potential Enhancements: Taking Advantage of any new features that could enhance performance, readability, or maintainability of the codebase. Documentation Update: Update documentation to reflect changes made to adapt Lua 5.4 and provide clear guidance for users. Testing: Conduct comprehensive testing to verify functionality across different DBMS. Distribution: Package the updated LuaSQL drivers for distribution to users.

<p>Enable users to attach a script or Lua function to a watchpoint and execute it when the program flow hits it in LLDB and improve the whole documentation for Lua scripting in LLDB.</p>

<p>The project consists of developing new interrupt-based drivers for microcontrollers, e.g.: ADC SPI and I2C buses EEPROM Real-time clock Some libraries built on top of these drivers (e.g., RF transceiver, ultrasonic sensor, accelerometer).</p>

<p>The goal of this project is to provide typed API for LuaRocks modules, specified using Teal, a typed dialect of Lua, which allows for typed definition files to be written for untyped Lua modules. Our goal here is not to port all of LuaRocks to Teal, but to provide typed interfaces for Teal or Lua applications, so that users of these interfaces can have a stable contract of the API's inputs and outputs.</p>

This proposal introduces myself and outlines the work I will be doing during the Google Summer of Code 2025. My proposal aims to implement a HID driver framework for Lunatik, a module that provides a way to binding HID devices using Lua script.

<p>Developing interrupt-based drivers and libraries for Arduino chips and peripherals for the Céu-Arduino language, in order to replace current functions and libraries which freeze the application while executing.</p> <p>This project will make an overall contribution not only to the development of the Céu language but to the Arduino and Embedded Systems community as well.</p>

<p>In this project we focus on package manager for Lua modules, LuaRocks. Our main goal is to increase quality of test suite, because it's implemented as a big shell script that only does black-box testing. So we write new test suite with Lua unit testing framework busted.This will allow us to extend the test suite by writing smarter tests that check its behavior, write white-box tests of the internals, and also port the test suite to other platforms. Next step is to improve code coverage, by adding white-box tests for parts that are hard-to reach via black-box testing. Make tests cross-platform could be a challenge for Windows operating system. At the end we integrated code coverage results, merging the Linux and Windows runs.</p>