Explore Projects

To achieve real-time execution in Concore, one approach is to optimize the existing codebase. However, implementing the system with straightforward C++ implementations may offer even better results in terms of efficiency and speed, due to the language's closer proximity to hardware. As Concore involves multiple processes, an IPC mechanism should be developed to replace the current file-sharing communication method, in order to enable efficient data transfer. Finally, it's necessary to ensure that Concore with optimized C++ programs can run on an affordable hardware device that supports real-time computation.

This proposal focuses on enhancing the Surfer waveform viewer by adding support for memory and wide array visualization. Current waveform views are effective for scalar signals but become inefficient when dealing with large arrays or memory structures. This project introduces a structured table based visualization for memory contents along with intelligent change highlighting across timestamps. The implementation will improve debugging efficiency by allowing users to inspect memory elements individually rather than scanning entire waveforms. The solution integrates seamlessly with Surfer existing architecture and maintains performance for large datasets.

Text-to-speech is a critical accessibility feature that is currently not present in many ScummVM engines. Adding text-to-speech to more engines can assist language learners and those with visual impairments, as well as standardize implementation of text-to-speech across engines. In this project, text-to-speech is implemented on an engine-by-engine basis by defining GUI options for text-to-speech; identifying procedures that display text, which may include objects, menus, dialogue, and other forms of text; cleaning up the text, if necessary; and feeding this text into text-to-speech. It aims to include full text-to-speech support for a variety of engines.

The goal of this project is to expand the Unikraft ecosystem by enabling the execution of popular applications through binary-compatibility mode. Currently, many popular applications are not supported on Unikraft, and this project will address that gap by integrating these applications into the Unikraft catalog. I will work on adding a variety of applications, such as SQLite, Mosquitto, Traefik, and others, to the Unikraft catalog. The project will also involve extending or adding new system calls to ensure proper functionality and writing automated GitHub workflow files. This project will significantly enhance Unikraft's application compatibility, making it more attractive to developers and helping grow the Unikraft community.

<p>We will bring the ScummVM Director engine up to (MacroMind) Director 2 compatibility, with progress measured by <em>Spaceship Warlock</em>. Major tasks in this project include [1] making the render pipeline sprite-based (rather than per-frame), [2] compute score frames on-the-fly instead of caching them, so delta information is properly processed, and [3] using the new approach to improve sprite position calculation. Stretch tasks include rewriting transitions to support simultaneous sprite transitions, emulating the Mac UI elements that many games use, and understanding sprites with palettes.</p>

This project aims to advance the support for _created lines, or Created Timestamps, in Prometheus. Building on the groundwork laid during GSoC 2023 by @ArthurSens, who introduced this concept, my mentorship will focus on refining the parsing of _created lines from the OpenMetrics (OM) Text format and proposing an optimized solution for their efficient processing. The initial implementation encountered issues with excessive memory usage, so this work will also involve benchmarking and optimizing the OM parser to identify and address potential inefficiencies. Additionally, there is the possibility of calculating or auto-generating created timestamps per scrape job to extend compatibility with OTLP/PRW 2.0.

PostgreSQL’s `generate_series()` is powerful for reports and time‑series work, but Django currently lacks a first‑class `ORM API` for it. I will add native support in `django.contrib.postgres` by extending the `ORM` to treat set‑returning functions as table sources using `set_returning`, a new `Relation` abstraction, and `RelationCol` references, implemented via `CROSS JOIN LATERAL`. The result will let developers use `.annotate()`, `.filter()`, `.order_by()`, `.count()`, and `.aggregate()` with generated series without raw SQL. Deliverables include the API surface, type inference for `date/time` series, and a robust test suite covering edge cases, joins, and large sequences.

<p>Collaboration is ingrained into human nature, without it we, as a species, wouldn’t be able to build astonishing buildings like we have today. Fundamental to collaboration, however, is communication, which enables the coordination of big projects. To make the work on a project easier we use tools like FreeCAD. It offers possibilities to model objects, like buildings, but not exclusively, that shall soon be built. For that purpose FreeCAD supports BIM (Building Information Modeling). This project aims to integrate the BCF (BIM Collaboration Format), which is designed to communicate issues/topics with a particular model. These issues/topic can then be directly visualized in the design tool and don’t have to be searched for in the model, based on a description in a PDF file.</p>

<p>I’d like to add a lambda support in Immediate Pad. There are roughly 2 tasks:</p> <p> Task1. Compile lambda expression locally using Roslyn API along with the current context of debuggee  Task2. Add a new wire protocol command type for bytecode for the lambda expression. The debugger agent registers the bytecode in Mono Runtime and sends back its handle to the debugger.</p> <p>We have to compile the body of a lambda expression and resolve some difficulties such as variable references and substitutions in the body. Then, compiled bytecode should be sent to the debugger agent with the protocol for lambda. A challenging thing of this project would be injecting new bytecode which either refer or change variables in the debuggee’s context.</p>

This project proposes to enhance Clad, a Clang-based automatic differentiation (AD) tool, with support for NVIDIA's Thrust library. By enabling differentiation of Thrust's GPU-parallel algorithms, Clad users will gain the ability to automatically generate gradients for CUDA-accelerated code in scientific computing and machine learning applications. The implementation will include extending Clad's source-to-source transformation engine to recognize Thrust primitives (e.g., transform, reduce), implement custom derivatives, and validate performance through real-world use cases. This work will bridge the gap between high-performance GPU computing and AD, potentially accelerating gradient-based optimization tasks by orders of magnitude.

<p>nMigen is an HDL toolkit implemented in the Python programming language. By using nMigen instead of traditional HDLs like Verilog or VHDL, gateware can be developed in less time, with less bugs, and with extremely powerful abstractions that enable code clarity and conciseness. apertus° has already developed prototype nMigen gateware for the AXIOM Micro, but wishes to extend it to support the sensor, FPGA, and HDMI interface of the AXIOM Beta. This work will develop in nMigen and demonstrate on real hardware an end-to-end imaging prototype for the AXIOM Beta: sensor control over SPI, sensor readout PHY from LVDS, pixel remapper based on existing implementation, 4K to Full HD downscaling debayerization, and final image output to HDMI.</p>

This proposal aims to enhance Java Path Finder (JPF) to seamlessly support Java 17, ensuring compatibility with the latest Java version. The project focuses on analyzing JPF's codebase, identifying areas requiring modification, and implementing necessary changes to accommodate Java 17 features and APIs. Through rigorous testing and validation, the project aims to certify JPF's compatibility with Java 17 across diverse usage scenarios. Additionally, the proposal includes comprehensive documentation updates and release management strategies to facilitate smooth adoption of the updated JPF versions by the Java development community. By bridging JPF to Java 17, this project endeavors to capabilities for bytecode analysis and verification, empowering developers to ensure the correctness and reliability of their Java applications in modern software ecosystems.

<p>AI agentic workflows (multi-agent collaboration frameworks, automated evaluation systems such as SWE-bench) frequently spawn and tear down large numbers of short-lived sandboxes (gVisor, Wasm, Kata Containers) to execute skills or tools. Current Kubernetes scheduling models are too heavy for these transient workloads, causing high latency, weak isolation, and APIServer pressure. This project will extend Koordinator to provide first-class support for AI agent scenarios by integrating sandbox runtimes with Koordinator QoS classes, implementing equivalence-class scheduling for near-identical sandbox requests, and introducing a dedicated Sandbox Pipeline that handles pre-warming, capacity reservation, and actionable scheduling feedback to enable agent self-healing.</p><p><br></p><p>Expected Outcome:</p><p>&nbsp;- Native integration of agent sandbox runtimes (gVisor/Wasm/Kata) with Koordinator QoS classes (LSR, LS, BE) and resource hardening templates</p><p>&nbsp;- Equivalence-class scheduling logic in the Koordinator scheduler that skips redundant Predicate/Priority calculations for batches of similar sandbox pods</p><p>&nbsp;- A Sandbox Pipeline mechanism with pre-warming, automated environment provisioning, and reservation hooks</p><p>&nbsp;- Annotation/Status-based scheduling diagnostics that surface actionable next-step suggestions to upstream agents</p><p>&nbsp;- End-to-end tests and benchmarks demonstrating throughput and latency improvements for high-concurrency sandbox workloads</p><p><br></p>

I will implement stream processing support for FasTensor library. Stream processing enables online processing of live data as it arrives on the File System from various data producers. Th Big Plan: 1. A directory monitoring service will monitor file addition or removals of specified pattern. 2. A dynamic stream object which provides iterators that return file in a stream in specified order and also combine multiple streams. 3. A rich set of stream handling components, each with a unique set of concerns and guarantees, that enables stream-specific functions like read and write in a fault-tolerant and robust manner. Deliverables: 1. A rich interface to compose streams from various data producers. 2. A fault-tolerant and robust mechanism to read, write, and manage streams in a big data environment.

This project aims to implement comprehensive support for correlated subqueries in Apache DataFusion by applying Hyper's 'Unnesting Arbitrary Queries' framework. With a complete solution that can transform arbitrarily nested correlated subqueries into standard join operations through a systematic approach. The implementation will include enhancing the binding phase to handle multi-level nesting, implementing the core dependent join transformation algorithm, applying operator-specific pushdown rules for all relevant operators, and optimizing redundant operations. This approach provides a general solution that works for all types of subqueries (scalar, EXISTS, IN) and handles complex cases involving aggregations and multiple levels of correlation. By adopting this proven theoretical framework, DataFusion will gain robust SQL compatibility and significantly improved analytical capabilities, enabling users to express complex data relationships efficiently.

<p>Artificial Intelligence and Deep Learning nowadays are ever growing subjects. People who research AI, are experimenting with various intelligence models in order to discover a strong intelligence model which is equally capable with the unknown human model. Prototyping of such models (as large as they may be) needs to be as fast as possible, in order to examine exhaustively many novel ideas as fast as it can be done. For this we need to be able to use with ease as many resources as we have possible. As Theano is contributing to this attempt, current GPU technologies need to be supported extensively in a transient way through its framework. This can be achieved by including optimized operations from current NVidia frameworks, as well as optimizing or designing GPU code which resides in the framework’s backend. Furthermore, analysis and optimization of multi-gpu code, in addition with a consideration of a multi-node/gpu design, would prove themselves useful for this cause.</p>

<p><code>ndcube</code> is a package that lets users combine multi-dimensional astronomical data with their corresponding real-world physical coordinates. WCS transformations are used to make this conversion. <code>ndcube</code> provides a powerful technique to couple them together so that researchers can tinker with their data while being assured that the underlying transformations remain consistent with any operations they perform.</p> <p>This project aims to add support for resampling n-dimensional data. Essentially, it means that users will be able to upsample or downsample the resolution of their data based on their specific needs. They will be able to map it on a different grid that better suits their research requirements. Just like with existing operations such as slicing, this project will ensure that resampling an <code>NDCube</code> will modify the underlying WCS transformations and other attached parameters, to make it always remain consistent with the data.</p>

<p>The Data Retriever is a package manager for publicly accessible data. The Data retriever automatically finds, downloads, and pre-processes publicly available datasets and it stores these datasets in a ready-to-analyze state. A number of data providers require the use of an account with an associated Login or API key to access data programmatically. The Data Retriever currently has support for the Kaggle API allowing users to securely use the Data Retriever to install datasets hosted by Kaggle. The goal of this project is to find sources of public Data which require a Login/API key to access the data and integrate them into Data Retriever. Two APIs (Socrata and CKAN) have been thoroughly researched and can be added. The users will place the appropriate credentials in a file in their home directory. The Data Retriever will automatically identify the required credential files and handle the login/API request to download the dataset.</p>

Currently, the static analyzer offers little dedicated support for C++. Even when projecting the most straightforward valid C test cases to C++, the checkers output incorrect diagnostics, either by their absence or imprecision. The issues this project aims to tackle are all prerequisites to further extensions of C++ support. The aim of this project is to enable the analyzer to self-analyze itself.

This project would implement the Besag, York, Mollie (BYM) model in PyMC. BYM is a highly flexible model for studying spatial data and is used widely in epidemiology, agriculture, and ecology. The strategy behind the BYM model is to treat the outcome of interest as the result of three factors: some set of predictor variables, spatial covariance between neighboring regions, and random effects that represent non-spatial heterogeneity. Although very flexible, the BYM model can be difficult to specify in a way that is simultaneously computationally efficient, interpretable, and identifiable. Recently, Morris et al (2019) demonstrated an alternative specification of the BYM model that is significantly more efficient, interpretable, and can be identified with Monte Carlo Markov Chain (MCMC) samplers. Developing an implementation in Python with PyMC would make the model more accessible to a greater variety of users. Furthermore, BYM models are only available in a Bayesian framework. As a leading Bayesian statistics package, PyMC should support this extremely useful model in spatial statistics.

<p>The Energy Hub (Ehub) Modeling Tool is a set of MATLAB scripts for writing and executing a district energy system optimization. The purpose of the tool is to aid the design of decentralized energy systems at the building and district level. It can be used for creating, executing and visualizing the results of an energy hub model for a given case study and a set of technologies. The Ehub Modeling Tool takes as input case study data and technology data in defined formats and outputs an AMS file which is executed in the optimization package Aimms. The Ehub Modeling Tool also includes R code for visualizing the results of the energy hub model.</p> <p>This project focuses on developing a Python-based visualization module for the Ehub Modeling Tool. The results from a run of the model include the optimal dispatch schedule of different technologies, the technologies to be installed and the optimal capacities of these technologies, and other data. This project involves developing a set of scripts to import and visualize the results data from a set of experiments.</p>

<p>Hypervisor (Virtual Machine Monitor) is a software that runs one or more virtual machines. Other than virtualization in cloud, they are also used in Virtual machine introspection to observe the behavior of malware from outside perspective. Traditional hypervisors like xen and kvm has a lot of features that these VMI researchers don’t need. So Bareflank aims to provide all of the scaffolding needed to rapidly prototype new a hypervisors.</p> <p>“LibVMI is a C library that makes it easy to monitor the low-level details of a running virtual machine by viewing its memory, trapping on hardware events, and accessing the vCPU registers”</p> <p>The primary goal of the project is to do Virtual machine introspection using LibVMI in Bareflank hypervisor. This will be achieved in multiple parts.</p> <ul> <li>The first part is to build a hypercall interface and so that both the Libvmi and Bareflank can talk to each other. </li> <li>The second part is to use the interface and do register and memory introspection on both the guest and host virtual machine.</li> <li>create channel for events and add support for Bareflank libvmi events.</li> </ul>

Webpack currently lacks a modern, automated documentation site. Existing documentation is manually maintained, lacks API reference generation, and has no automated pipeline to stay in sync with webpack's source code. This project aims to build a fully automated documentation system for webpack using TypeDoc and @node-core/doc-kit. The pipeline extracts API documentation directly from webpack's types.d.ts, generates structured markdown, and renders a complete website - including API reference, guides, loaders, plugins, and core pages like Home and Download. Key deliverables: • A complete TypeDoc theme producing doc-kit-compatible markdown. • Webpack-branded site using doc-kit's theming system (#theme/* components) that aligns webpack's documentation with the OpenJS Foundation's design standards. • Multi-version documentation support (v5, v6 and beyond). • Fully automated CI/CD pipeline that syncs with webpack releases. The overarching goal is zero manual documentation maintenance - every webpack release automatically triggers doc regeneration and deployment, keeping the documentation accurate and fresh without human intervention.