Explore Projects

Better support for dictionaries, sets, lists and tuples is required, especially for combinations nested in each other. There are many incomplete features, bugs, and missing methods. I plan to fix as many bugs as possible, implement all methods and benchmark these data structures against their C++ counterparts.

<p>The aim of this project is to create a module to import geometric data acquired from terrestrial laser scanners. It will focus on developing a method to directly model real objects and topographies without entering their geometries manually. The information gathered by the laser scanner in the form of ‘Point Cloud Data’ will be used to create a full 3D model of the object. The data from the 3D model is required to be mapped/converted/translated onto the Finite-Difference Time-Domain (FDTD) grid upon which gprMax is based.</p>

<p>StarFix is a cross-platform client-side application that would let you open a file in the Editor of your choice (vscode, eclipse, intellij, emacs, vi, etc.) and other commands locally directly from the browser or file system. This will enable an option to “Open in IDE” through browser extension on various websites like Github, Gitlab, etc similar to the one you see in this demo below. This season we aim to improve the existing tool by resolving the existing issues and adding new features that the user may need .</p>

This proposal focuses mainly on two points of the `libc` issue tracking the `1.0` release. The first of these addresses the presence of 64-bit and 32-bit wide variants of time- and file offset-related functionality for which it has been stated that only a single, 64-bit type should exist. This should also solve the concern about which of the bit-width variants should `libc` offer, as briefly discussed in the latter comments of https://github.com/rust-lang/libc/pull/5010#issuecomment-4060131422. This proposal also attempts to deprecate a set of constants which, as described in https://github.com/rust-lang/libc/issues/3131, are prone to bugs, but most importantly, require a large amount of manual effort to deprecate in whole. The goal here would be to come up with a solution that, while still manual, would allow bulk deprecation of these symbols throughout the codebase.

This project aims to utilize LLMs to make the library more accessible to the community. There will be a Discord, GitHub and X (previously Twitter) Integration. By reducing the barrier of entry, we aim to bring more people into using scientific visualization libraries.

<p>Adding support in Kubernetes Client for several types of Resources: ServiceCatalog TemplateInstance VolumeAttachment CertificateSigningRequest SelfSubjectAccessReview SelfSubjectRulesReview TokenReview ControllerRevision UserInfo AdmissionConfiguration</p> <p>Providing test coverage for the following resources: Endpoints PersistentVolumeClaim PersistentVolumes SubjectAccessReview PodPreset HorizontalPodAutoscaler Namespace ResourceQuota</p>

MNE-Python’s documentation is extensive but primarily static, requiring local installation for users to explore data. This project aims to integrate JupyterLite into the sphinx-gallery build, enabling a "Try in Browser" feature for core tutorials. Key challenges include managing large neuroimaging datasets in a WebAssembly environment and maintaining 3D interactivity (PyVista/Trame). I will deliver a production-ready CI/CD pipeline for JupyterLite builds, a prioritized set of interactive lightweight examples, and a library of ipywidgets for real-time parameter tuning (e.g., filtering, scaling) directly in the documentation.

<p>Knative is a Kubernetes-based platform to deploy and manage serverless workloads. Eventing is a key feature for Serverless Computing. They deliver their information to a specified target to make a whole system interactive. The problem is that every kind of event cannot be treated as the same one in the Knative ecosystem because the shape of each event depends on its sources. Knative Eventing is designed to be consistent with the CloudEvents definition to keep interoperability. To make this happen, the Knative Eventing community already has several kinds of event type definitions such as GitHub, AWS S3, GCP Pub/Sub, etc.<br> This project aims to add two event types:</p> <ul> <li>an event source that is able to generate CloudEvents when a new container image is uploaded to Docker Hub.</li> <li>another event source that is able to generate CloudEvents on success/failure of Task/Pipeline and every step of a Pipeline created by Tekton CI/CD.</li> </ul> <p>Both components would help application developers focus on developing applications itself and make Serverless Computing more diverse.</p>

This project aims to enhance the DrTest tool in Pharo by improving its usability, functionality, and performance. DrTest is a critical resource for developers to test and analyze code coverage, but there is room for improvement, particularly in the areas of user experience, compatibility, and fault location. Through this project, I will implement a range of improvements, including enhancements to the code coverage and test comment visualization, optimizations to the performance plugin, and the development of a new fault location plugin. By the end of this project, the DrTest tool will be more user-friendly, compatible with the latest version of Pharo, and capable of providing more accurate and detailed test results, benefiting developers and contributing to the Pharo open-source community.

Implement a Keyframe animation system for FURY with public API that has the following functionalities: Play, pause, rewind, and reverse play the timeline. Add or remove keyframes at any specific time. Interpolate position, scale, rotation (using SLERP), and opacity for the animated actors or camera using linear and non-linear methods. Visualize the motion path of the translation.

<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>

This proposal addresses the lack of debugging tools for pocketpy, a lightweight Python interpreter for game scripting. It will develop a VSCode debugging extension along with Debug Adapter Protocol (DAP) support. The solution includes a debugger core that integrates with pocketpy's interfaces to support breakpoints, variable inspection, and call stack visualization, paired with a VSCode extension providing an intuitive debugging interface. Deliverables include a DAP-compatible debugger core, a VSCode extension with debugging configuration capabilities, and APIs for runtime inspection of variables and stack frames.

<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>

<p>Memory access is one of the most important operation done in modern processors thus it plays an important role in implementation of trusted execution environment. Recent secure processors and trusted environment encrypt memory contents to protect those important memory operations. However, sometimes just encrypting data is not enough since there are intelligent attackers who can see where the memory access goes to and infer where the real important data lies in. Those important data includes the private data, key, or OS fingerprint and else. These kind of attacks lead to concept of “memory obliviousness” to secure memory address itself. ORAM refers to Oblivious memory which can leverage obliviousness using specialized data structures and obfuscate memory access so even an attacker see or probe the memory access itself, he never learns about where important data lies on or even where the memory requests are headed to. Initially proposed by Goldreich and Ostrovsky, ORAM obfuscates memory access using random permutation, shuffling and encryption of contents. In this proposal, I’ll implement ORAM interface to support obliviousness on RISC-V’s trusted execution environment.</p>

Enhance the C++ LSP server to support parallel file re-indexing during live editor typing in large monorepos.

<p>Panda3D is an open source framework for 3D rendering and games. It combines the speed of C++ with the ease of use of Python in order to provide users a fast rate of development without sacrificing on performance. The project I wish to work upon is Integration of Navigation-mesh Toolset for Games in Panda3D. Recast and Detour are tools/libraries for building navigation meshes and performing pathfinding. Once these tools/libraries are successfully integrated with Panda3D, it would be possible for a Panda3D actor to move from the source to the destination avoiding collisions with the walls and inappropriate paths.</p>

Modern cloud environments frequently rely on oversubscription to maximize resource utilization, which introduces significant performance challenges for OpenMP applications running inside virtual machines. In such environments, a semantic gap exists between the guest scheduler (which assumes full CPU availability) and the host scheduler (which may preempt virtual CPUs). This project proposes a set of optimizations to the GNU OpenMP runtime (libgomp) that leverage host-side scheduling information to guide execution decisions inside the guest. The core idea is to bridge the host–guest semantic gap using a low-latency shared-memory communication mechanism based \section*{Project Summary}on eBPF and ivshmem, enabling real-time propagation of scheduling metrics without incurring VM-exit overhead. A key component of the project is the implementation of a Phantom Tracker using eBPF, which monitors virtual CPU states on the host and computes a phantom average metric representing scheduling contention. This information is communicated to the guest and used to dynamically adapt two critical aspects of OpenMP execution: the Degree of Parallelism (DoP) and barrier synchronization behavior. To integrate these optimizations, the project extends libgomp with two new environment variables: GOMP_DYNAMIC_POLICY for scheduler-guided parallelism adaptation, and GOMP_WAIT_POLICY for adaptive spin–block synchronization. These enhancements allow OpenMP applications to respond to real-time host conditions, improving performance and resource efficiency under oversubscribed workloads.

<p>I will implement ARM CMSIS library on PULPino using proposed priority, then i will port the implementation to its DSP core and compare results.</p>

<p>Lua is a tiny language that can do a lot. As a scripting language, it can be embedded into larger projects, used in IoT devices for its lightweight nature and implemented as a user-friendly way to get help from a wide variety of coders thanks to its simple interface and flexible design. It can support both functional and object-oriented approaches, but the amount of support it can supply is limited. Lua has no built-in support for advanced file manipulation, directory traversal, process creation or piping. The goal of Apolo, and my Google Summer of Code project is to build a library that adds these core functions to lua.</p> <p>The major goals of this project are:</p> <ul> <li>To broaden Apolo's current library of commands</li> <li>To add piping and IO redirecting to Apolo</li> <li>To include flexible management of background processes</li> <li>To build a wide variety of tests to ensure that all of lua's functions work as intended</li> </ul>

<p>This project is to Implement work-stealing scheduling into the GCC implementation of the OpenMP standard. Task parallelism often yields highly imbalanced tasks. Work-stealing is a scheduling methods widely used to tackle this issue. Implementing work-stealing is essential to staying competitive with other task parallelism frameworks.</p>

<p>OpenLex is a legal management system developed in web2py this system has the advantage that it can be run on any operating system thanks to the fact that it is a web browser application, however, for this reason it represents mistrust among users due to ignorance about the security and system integrity because this is used by a browser and not as a desktop application. In order to satisfy these users, the development of the installer in the different versions of linux, windows and apple is proposed in the project issues.</p>

This project will significantly enhance the PyLadiesCon Sponsorship Portal, a Django-based Python web application, by introducing advanced backend and frontend capabilities to better support sponsor engagement, tracking, and design team collaboration. Key features include an admin sponsorship review workflow with role-based access control, an automated notification system using Django signals and SendGrid, and a secure media upload portal utilizing Pillow, django-storages, and Amazon Web Services S3. A dynamic dashboard will also be implemented with real-time filtering and tracking of contract and payment status using Django ORM, PostgreSQL, and interactive frontend behavior powered by HTMX. To ensure a maintainable and scalable system, the project will adopt containerized development with Docker and maintain robust test coverage using pytest-django and coverage.py. The result will be a highly functional and production-ready platform that streamlines sponsorship operations and improves transparency across teams.

gccrs still lacks support for Rust’s Drop trait, which is a core part of Rust’s resource management model. Without it, values that require cleanup cannot be handled correctly at scope exit, which makes gccrs incomplete with respect to important Rust semantics. This project proposes an incremental implementation of Drop support in gccrs, starting from a narrow and testable subset rather than attempting full drop elaboration at once. The first stage focuses on scope-exit destructor insertion for simple non-generic local variables using existing backend cleanup machinery. From there, the implementation will be extended to support multiple locals, correct reverse drop order (LIFO), and, if feasible, initial nested-scope cleanup. More advanced cases such as moved values, temporaries, partially initialized values, and generic Drop will be treated as later-stage or stretch work. The main deliverables are: an initial implementation of scope-exit Drop support for a restricted subset of local variables, support for correct LIFO drop ordering, regression tests covering the supported behavior, and documentation describing the implementation approach, supported subset, and current limitations.