Explore Projects

<p>Mypyc now employs an IR that is tightly bound to C, which makes potential experiments with new backends impractical and also breaks the layering abstraction principle. In this project, we are designing new IR elements that provide cleaner abstraction and make future non-C backends possible and easy-to-implement.</p>

<p>QEMU supports exposing block devices to the guest OS over the virtio-scsi protocol. Currently, this is implemented using C code running in the main QEMU process. There is also support for using an external backend over vhost-user-scsi, but the existing backend is implemented in C, and is fairly limited, only supporting iSCSI.</p> <p>The goal of this project is to implement an alternate vhost-user-scsi backend in Rust. This would provide benefits to security, reusability, and performance.</p>

<p>Currently, mypy and mypyc are unable to recognize uses of the singledispatch decorator, making mypy generate false positives and mypyc generate incorrect or slow code when it is used. This project would improve both of these problems by adding special support for singledispatch in mypy and mypyc.</p>

Upgrade the offline indexing and multi-lingual layout algorithms for high-throughput developer documentation portals.

This project aims to extend the support for aarch64 on rust-vmm/vmm-reference. rust-vmm enables the community to build custom VMM solutions. It currently supports booting up a dummy VM with no devices. The purpose of this project is to extend the existing functionality getting it closer to what is already available on x86_64.

FS2 is a key part of the Typelevel ecosystem for streaming I/O operations in Scala, offering powerful APIs that provide a wide range of functionality for different use cases. However, its use in smaller scripts often introduces unnecessary complexity and boilerplate, hindering productivity and accessibility. This project proposes the development of Fs2 OS, a fluid and intuitive library designed to revolutionise the way developers interact with files and processes.

<p>During the winter break I decided to give back to the Scala community. I re-built the entire documentation website and implemented a new search functionality for browsing the Scala library code. This introduced me to members of the LAMP and Scala team.</p> <p>This summer I'd like to continue along this path by helping to implement dottydoc.</p>

<p>This project targets at enabling the current RoboSherlock to work in form of parallel pipeline, which also includes merging results of different camera configurations. In this proposal, I present my plan, methods, timeline and some related experience.</p>

<p>This proposal aims primarily to fuzz test qemu-img from QEMU project in order to discover the potential security bugs and write bug fixes for them. The second goal will be to extend qemu-img to support a new subcommand dd.</p>

Doodle is a generative art library. Using it, programmers can create artwork, statistical model visualizations, or other graphics. These graphics are generally parameterized by variables such as line width or color. The goal of Explore is to provide an eDSL for describing parameters and their constraints such that a UI for exploring the parameter space can be generated.

<p>One of the most important steps in tuning an emulator performance is to identify which are the hot regions and to measure their translation quality. However, in QEMU, there is no easy way to identify hot TBs. Therefore, we propose in this project the enhance of QEMU log system to add these capabilities. Our plan is to add three new capabilities to QEMU: (1) to profile and list hot emulated blocks, (2) to calculate global and per block translation quality statistics, and (3) to allow all these inspections to be done in an interactive mode in the monitor tool.</p>

<p>Scala Native provides bindings for several C and POSIX APIs out of the box. To help complete and maintain the list of supported APIs as well as seamlessly use 3rd party native libraries support for automatically generating bindings is needed. The goal is to create a tool that parses C header files using LibTooling and generates a Scala Native API as well as an sbt plugin to use the binding generator in a project.</p>

This project extends QEMU FUSE export with support for FUSE-over-io_uring, a modern Linux interface that enables asynchronous, high-performance communication between FUSE daemons and the kernel. Unlike the traditional /dev/fuse path, io_uring reduces system calls, supports batching, and lowers CPU overhead. This project will integrate FUSE-over-io_uring into QEMU as an optional mode, enabling more efficient access to disk image contents through the FUSE export. The work includes implementing queue setup and negotiation with the kernel, supporting multiple inflight FUSE requests, enabling multi I/OThreads, and benchmarking performance using fio. Deliverables include: FUSE-over-io_uring support in QEMU Multi-inflight and multi-IOThread support Performance benchmarks Documentation

<p>This project revolves around designing a reusable framework for mocking the driver side of a VirtQueue operation. It would allow rust-vmm crates and other projects to use it and would provide a cleaner alternative to mocking code already found in vm-virtio.</p> <p>The framework would at first provide users with more granular control over mocking what the driver will place in the queue and will later support mocking more advanced features such as notification suppression, indirect descriptors and other device specific features.</p>

This project aims to migrate the existing Scala documentation website from Jekyll to Scaladoc. This migration will provide a more streamlined, modern, and easily maintainable documentation experience that is tightly integrated within the Scala ecosystem. I will focus on replicating key Jekyll features, such as the "include" mechanism and custom tabs, using the "liqp" library within the Scaladoc framework. Existing content (Markdown, HTML, CSS) will be carefully adapted, and styling will be applied to match the look and feel of the current website. If time permits, I will explore additional customizations to Scaladoc's default output for greater layout flexibility. The key deliverables of this project include a functional MVP website, replicated Jekyll functionality, and comprehensive documentation of all implemented features.

<p>Watercolor is one of the most complex tools for imitation. The painting, painted with watercolors, depends to a large extent on the motion of the pigment solution, on the paper worn. This process is rather difficult to model, because, depending on the environment, the system will continue to change for some time after the artist finished painting.</p>

<p>3D acceleration is non-existent on Windows guests. The goal for this project is to bring a support for OpenGL. For the host part, we will use Virgl, but on the guest side, we must provide a complete user and kernel OpenGL driver.</p>

<p>Live Migration is a process of moving a running virtual machine from one physical system to another. There are usually two ways, precopy and postcopy. Postcopy migration is used for virtual machines which have a high memory dirtying rate, (higher than the bandwidth of the network that will be used to perform migration). The disadvantage of postcopy migration is, if there is a network failure then we are left with an inconsistent vm at both the source and the destination side. The aim of this project is to recover from the network failure, and complete the migration process. The project will include completing the process of sending the leftover memory pages. Project would start by making sure that the threads do not fail at both the source and destination end. This would be followed by re-establishing the network connection between the source and the destination. After this is done, the migration process is restarted. The vCPUs on the destination side were suspended due to page faults, so these pages are transferred first. Followed by the rest of the leftover pages on the source side.</p>

Cyfra is a GPU runtime and DSL that simplifies GPU programming in Scala by abstracting Vulkan. This project will build a real-time rendering pipeline with outputs to a window, data stream, and file. Deliverables include high-level GPU APIs, GLFW integration, efficient swap chain/synchronization, and clear documentation with examples—making high-performance graphics more accessible to Scala developers.

<p>Since cache performance is one of the essential metrics that may bottle-neck the overall performance of the system, monitoring it and identifying points of weakness (and resolving them) may drastically improve the performance of the system.</p> <p>In this project, a cache modelling QEMU TCG-plugin is proposed and implemented, with simplicity rather than intricacy in mind, that models the behavior of caches when given the working set proposed by a program, or system-wide working set, report the cache performance, and identify the frequently cache-missing instructions.</p>

<p>Nowadays QEMU doesn't have any PCIE-PCI bridge except DMI-PCI i82801b11 bridge, but as DMI is a proprietary Intel bus, it can be used only on x86 targets, besides, it isn't hotpluggable. That is why the goal of this project is to create generic PCIExpress-PCI bridge, which will be able to be used by different target architectures and OSes and the bridge will be natively (in terms of PCIExpress) hotpluggable, which involves SHPC usage. As a result , after finishing PCIE-PCI bridge device QEMU PCI subsystem can be moved to QOM model.</p>

<p>This project aims to realize a vhost-user-vsock application that will leverage the vhost-user protocol to emulate a virtio-vsock device in an external process. It will additionally provide the hybrid vsock over AF_UNIX interface, that was introduced by firecracker. Kata containers rely on virtio-vsock to create a communications channel between the runtime in the host and the agent in the guest. The vhost-user-vsock application, developed during the course of this program, would then be integrated into kata containers, who prefer that devices be emulated in an external userspace process to reduce the attack surface.</p>

<p>The idea of the project is to add support for macOS’s native hypervisor through the Hypervisor.framework API. This API exposes to user applications the processor's Virtual-Machine Extensions (VMX), which allows fast and transparent virtualization in user space by allowing guest software to execute directly and unmodified on the processor, avoiding costly and complicated emulation. Hypervisor.framework is part of Mac OS frameworks since OS X Yosemite (version 10.10).</p>