Explore Projects

This project aims to implement the udmabuf (User DMA Buffer) driver on FreeBSD, a crucial mechanism for zero-copy memory sharing between userspace applications and kernel subsystems. The absence of udmabuf currently limits FreeBSD's capability to efficiently support modern graphics and virtualization stacks, particularly preventing tools like QEMU from utilizing virtio-gpu with blob resources. The proposed solution involves developing a loadable kernel module that acts as a dma_buf exporter, deeply integrating with FreeBSD's virtual memory subsystem and extending the linuxkpi compatibility layer. Key deliverables include a fully functional udmabuf module implementing the complete set of dma_buf_ops, necessary linuxkpi API extensions for DRM compatibility, end-to-end integration patches for QEMU, and comprehensive ATF test cases accompanied by thorough documentation.

There is a RISC-V Vector backend in OpenCV universal intrinsic, but the performance is very poor and only supported fixed vector size with 128 bit. The reason for the performance issue is speculated to be redundant instructions introduced by the wrapper class. And the fundamental problem is that the current design of Universal Intrinsic may not suitable for variable-size(size-less) architecture. So it would be nice to modify the API and implementation of universal intrinsics forvariable-size architectures. And the goal of this project is to optimize the current Universal Intrinsic for RVV, mainly including the following two points. 1. Reduce the overhead of using wrapper class and 2. Support for multiple VLENs The expected outcomes of this project is mainly including 1. a new Universal Intrinsic backend for RVV to opencv_core module 2. a new test cases (modify or add) and make it pass on QEMU

This project aims to integrate the official GHC/WebAssembly backend into xeus-haskell, a Jupyter kernel for Haskell. Currently, the kernel relies on MicroHs, which, while lightweight, lacks support for the vast majority of the Hackage ecosystem. I will implement a dual-backend architecture by introducing a new C++ bridge and a reactor-model Wasm REPL module based on the GHC API. Key deliverables include: GhcRepl: A GHC-based WebAssembly REPL module maintaining persistent session state. C++ Bridge: A new interface (ghc_repl.cpp) to communicate with the GHC/Wasm runtime via the Wasm C API. Backend Abstraction: A unified virtual interface to allow seamless switching between MicroHs and GHC/Wasm. WASI Integration: A configured browser shim to handle I/O and package database access within JupyterLite

This project aims to port the vc4 graphics driver to NetBSD, which drives the VideoCore GPU available on the Raspberry Pi. It will allow for a Raspberry Pi running NetBSD to take advantage of the dedicated graphics processor, which could be useful for other programs which currently use software rasterization to utilize OpenGL ES. Specifically, the project will be compatible with Mesa as-is, allowing existing programs which depend on Mesa for graphics API support to be able to support the Raspberry Pi's GPU under NetBSD. This will be solved by porting the existing driver to be managed inside a NetBSD loadable kernel module, which can be loaded at runtime when needed. When complete, this will allow for OpenGL ES programs which have been ported to NetBSD from Linux, and already utilize the GPU under Linux to similarly use the GPU under NetBSD, such as programs which can render a triangle, a teapot, and some games.

Inspektor Gadget is an eBPF tool and systems inspection framework for Kubernetes, containers and Linux hosts. A Gadget is an OCI image that includes one or more eBPF programs, metadata YAML file, and optionally, WASM modules for post processing. As OCI images, they use the same tooling as containers: building, pushing/pulling from OCI Registries. But today, Inspektor Gadget does not have good tooling for inspecting a gadget: the ig image inspect command just gives the gadget name, digest and creation date without further details. Expected Outcome: the ig image inspect command tells the architectures supported by the gadget, the layers included in the OCI image, the data sources with their fields, the eBPF parameters. Additionally, inspecting the eBPF module can provide the ELF sections, the eBPF maps and the disassembled eBPF bytecode annotated with the source when available.

<p>Currently, LibreOffice does not support styles for charts that can help to quickly insert formatted charts following a certain theme throughout the sheet. Competitions like MS Office since the 2013 version and also statistical software like Stata support chart styles. Right now a lot of productivity is lost on manually adjusting the chart properties for each chart or using the awkward copy and paste hack ( with changing the data linked to the new chart ). With this feature implemented the user can focus on the data rather than how the data looks.</p> <p>Currently the plan is to first implement styles at a logical level in the chart2 module, followed by allowing import and export of chart style into and from a locally saved file. Also, a prototype chart style selection list is to be made in the Chart Deck of the sidebar.</p>

Codeuino is a volunteer-driven, open-source, social networking software development organization that desires the potential to change the way other communities and individuals use and create open-source social-environment tools to better align with end-user expectations, giving prospectus to various other organizations, users and activists to use the social environments built within Codeuino in a custom way. Donut is an open-source, feature-rich, highly flexible and privacy-friendly, social networking platform built for community-oriented collaboration in a customized way. It has been built on the Node.js framework allowing an essential impetus to provide custom and friendly rich widgets and an expansive library of modules to make communication and collaboration easy and successful. With a powerful module system, you can customize this platform by using third party tools, writing your own, or integrating other software.

The proposed project aims to enhance the ns3-ai module, which provides interfaces between ns-3 and Python-based ML frameworks using shared memory, with a focus on performance optimization and expanding the range of supported data structures. To achieve this, the project will introduce APIs for additional data structures like vector and string in shared memory IPC to reduce the interaction between C++ and Python. Additionally, the project will provide examples demonstrating how to implement ML algorithms within ns-3 using C++ and open-source frameworks such as TensorFlow and PyTorch. The project will also improve the current examples and documentation and integrate new examples, such as LTE handover. Overall, the project aims to expand and accelerate the capabilities of the ns3-ai module, enabling users to simulate and analyze large-scale networks with greater efficiency and flexibility.

This project focuses on integrating a Ternary Content Addressable Memory (TCAM) module into the Chipyard SoC framework to enable high-speed parallel matching operations crucial for domains like networking and pattern recognition—functionality not natively supported in Chipyard. The integration employs a dual approach: first, incorporating the Verilog-based TCAM IP (generated via OPENTCAM) as a memory-mapped I/O (MMIO) peripheral by wrapping it in a Chisel BlackBox, connecting it to the subsystem using TileLink, and exposing TCAM operations like write and search through memory-mapped registers accessible from software; and second, integrating the TCAM as a RoCC accelerator by reusing the BlackBox within a custom LazyRoCC module, mapping Rocket’s RoCC interface to TCAM operations via funct fields of custom instructions, and enabling instantiation through a dedicated WithTCAMRoCC configuration in the Rocket tile.

<p>Epoptes, a computer lab management and monitoring tool, has been undermaintained for the last couple of years. It’s currently powered by Python 2 and GTK 2, while unfortunately a number of bugs have crept in due to major updates in Linux distribution packages (systemd, consolekit, VNC…). This project aims at reviving Epoptes with Python 3 and GTK 3 support, while also addressing several outstanding issues. More specifically:</p> <ul> <li>Make Epoptes run properly in Ubuntu 18.04 and in Debian Buster.</li> <li>Rewrite Epoptes with Python 3 support.</li> <li>Use Gtk3 with GObject Introspection instead of pygtk2.</li> <li>Improvements in the code structure (Break existing code into python modules/packages).</li> <li>Make the newer version available for Ubuntu 18.04 in a PPA.</li> </ul>

<p>The goal of this project is to design and implement a Nextcloud module and replace the existing transfer of the files from the client applications via Hypertext Transfer Protocol (HTTP) and Secure File Transfer Protocol (SFTP) with the APIs of this module. The existing protocols to transfer the uploaded files via client application window differ from each other and run in different ways to establish the connection and transfer the files. The existing mechanisms involve the HTTP and SFTP in order to transfer the files from the client window. To effectively enable the unified mechanism and collaboration of the files with the quick and reliable way we plan to implement the file upload using Nextcloud API. The APIs of the Nextcloud will be targeted in order to transfer the files from the client window and save the files to the Nextcloud. The Nextcloud enables the developers to reliably establish and support an unified mechanism to transfer the files from different clients running on the different platforms.</p>

The holidays library currently embeds translated holiday names directly within country-specific Python modules, causing significant data redundancy and high barriers for non-developer translators. This project introduces a centralized, Gettext-based architecture that extracts these strings into dedicated .po files one per language loaded lazily at runtime. How I plan to solve it Develop an AST-powered extraction script to identify all self.tr() calls across 100+ country modules. Implement a LocaleRegistry class to manage lazy loading and en_US fallback logic. Migrate the existing codebase to this decoupled architecture to enable easier integration with tools like Weblate. Key Deliverables: A Python CLI utility for automated string extraction. A centralized /holidays/locale/ directory structure. A fully integrated LocaleRegistry with backward compatibility support. A "Translation Contributor’s Guide" for future community volunteers.

<p>The ScholarLY 'annotate' module is a new tool, currently in a workable preliminary state, which extends the LilyPond music engraving software to add various implementations of textual annotations for collaborative workflows and the creation of critical editions. This project aims to improve functionality of the module within the LilyPond environment, and to extend the various outputs of those annotations. As such, the primary target features include triggering of score items from within annotations, ability to render score snippets in annotations, addition of new output file types of annotation logs (it currently supports plaintext and tex), ability to handle and export latex-ready footnotes, and the creation of a versatile LaTeX package (which does not exist yet in any state) for compiling the annotations (from the previously exported log) in LaTeX with customizable options for styling and distribution. Ultimately, 'annotate' offers a comprehensive functionality that hasn't yet been achieved in traditional/commercial softwares, and which will benefit a range of engravers from amateurs and individuals to professionals and group settings.</p>

The project aims to improve the quantum circuit visualization capabilities of QuTiP-QIP by introducing a new framework for circuit rendering that doesn't rely on external dependencies. Presently, circuit visualization relies on LaTeX and ImageMagick, which can be problematic for users. This solution plans to create two rendering modules: one utilizing matplotlib for visually appealing and precise quantum circuit diagrams, and another ASCII text-based rendering. The matplotlib renderer will also support generating circuit visualizations within IPython environments like Jupyter Notebook, while the text-based renderer will cater to command-line interactions. Apart from the rendering modules a Circuit Renderer Selector will also be included in the project deliverables, enabling users to easily choose their preferred rendering method among LaTeX, Matplotlib, or Text-Based options. These tools will enable users to visualize quantum circuits more efficiently and effectively, making it easier to work with QuTiP.

<p>Improve FHIR Search</p> <p>FHIR has a detailed API for searching any kind of medical information. But the API as implemented by the FHIR module provides a very minimal search functionality for most of the resources where you can search by either only one or a few search parameters. There is no search functionality using advanced parameters like _include, _sort, _summary etc. Moreover, there are Lucene indices available for some FHIR resources and the search API for FHIR module doesn’t exploit these indices to provide a quicker search.</p> <p>This project is aimed at improving the search API and implementing/providing support for more complex search operations. It takes into account implementing the search parameters which have already not been implemented for each of the core resources. It would make use of the Lucene index for resources where it is available. Currently, all the search results are returned by the server corresponding to the set of search parameters specified by the user. But this is not always desirable and it is more efficient to return only the top most useful results at a go and hence, this forms an important part of this project by implementing paging for the resources.</p>

The enviroCar Android app provides capabilities for visualizing user related tracks within a map. For this feature, the app makes use of several libraries of the Mapbox mapping framework. However, recent changes in the terms-of-use of Mapbox as well as their switch to a non open-source license makes it problematic to continue relying on Mapbox. MapLibre Native library for Android is an open-source alternative to Mapbox mapping framework. Migrating to MapLibre will ensure the project's adherence to open-source principles & long-term sustainability. Mapbox's current issues are preventing many developers in the open-source community from participating in the further development of the enviroCar app. Thus, this project aims to add support for multiple map providers (primarily MapLibre) into the enviroCar Android application. This will be done by introducing a new extensible and independent map module into the project's source-code. This map module will allow the users to select the preferred map provider/library based on their requirements, both during compile-time and run-time of the application.

<p>One of the main challenges when creating custom Linux Kernel images is choosing the adequate drivers composing it, respectively to the target machine. We want all needed hardware functionalities to be enabled in software but also, either from performance of security reasons, the number of unnecessary modules to be minimal. The configuration system provides several methods of achieving this goal either by generating a default configuration or by letting the user select the needed drivers but, by far the most interesting solution is the automated disabling of unused modules with localmodconfig configuration.</p> <p>Linux Kernel backports are a solution to provide drivers released on newer kernels to be available for usage on older kernels. APIs and data structures change over time but drivers should provide functionality in any case.</p> <p>This project aims to add support for Linux Kernel backports in already existing configuration option, localmodconfig. The goal is to automatically determine the available functionalities not only from the drivers provided by the current kernel version but also from all the backported ones. Extensions of this project could fill some gaps in upstream Linux.</p>

SymPy currently lacks an efficient backend for dense and sparse multivariate polynomials over ℤ and ℚ, leading to performance bottlenecks in many core functions such as solve, linsolve, simplify, cancel, and polynomial GCD computations. This project aims to address this by integrating FLINT’s highly optimized multivariate polynomial arithmetic into SymPy via python-flint. To achieve this, we will implement: FLINT-backed Sparse Polynomial Support – FlintPolyRing (FLINT-backed equivalent of PolyRing), FlintPolyElement (FLINT-backed equivalent of PolyElement), comprehensive tests and documentation. FLINT-backed Dense Polynomial Support – DMP_Flint (FLINT-backed dense multivariate polynomial class), comprehensive tests and documentation. Performance Analysis and Optimization – Benchmarking against SymPy’s existing implementations, optimizing operations. This is a high-priority task in SymPy's development roadmap, and achieving this can make SymPy reach "state-of-the-art" levels of speed and performance. Since multivariate polynomial operations are involved across various modules in SymPy, this project significantly strengthens the library.

OpenMRS currently utilizes Hibernate Envers to track database changes, offering robust audit capabilities. However, the system lacks a user-friendly way for administrators to view, filter, and interact with audit logs. This project proposes building a backend module that exposes audit log data in a meaningful way through a legacy UI-based audit log viewer, REST endpoints for external access, and an extension that tracks read operations on selected entities—something Envers does not support out-of-the-box. The solution will include: 1. Audit log retrieval and visualization within the legacy UI 2. Custom tracking of read operations using Hibernate event listeners or an alternative approach 3. Filtering capabilities (by user, date, and entity) 4. RESTful APIs for external access to audit data 5. A well-documented architecture, extensible to other OpenMRS modules By the end of this project, OpenMRS administrators will have a comprehensive and usable interface to audit system activity, improving transparency, traceability, and compliance with healthcare data standards.

This LFX Term 3 project will transform the KubeStellar Design System foundations (created in Term 2) into a production-ready implementation using Next.js (Nextra or Mintlify) and deploy it on Oracle Cloud Infrastructure. The project will deliver a unified design language across all KubeStellar interfaces, featuring immersive animations and interactive components that enhance UX while maintaining performance and accessibility. Expected Outcome: 1. Implement the complete KubeStellar Design System as a production-ready component library. 2. Build an interactive documentation site using Nextra or Mintlify. 3. Develop advanced 3D visualizations and micro-interactions using Three.js and animation libraries. 4. Deploy the design system and documentation to Oracle Cloud with enterprise-grade reliability. 5. Establish automated CI/CD pipelines for continuous deployment and semantic versioning. 6. Provide seamless integration paths for all KubeStellar interfaces (web UI, docs, CLI tools). 7. Ensure accessibility compliance while delivering visually engaging experiences.

This project aims to transform the CircuitVerse mobile application into a fully functional, stable, and production-ready platform that matches the capabilities of its web counterpart. Currently, gaps in core features, inconsistent user experience, and technical instability limit the app’s effectiveness as a learning tool. By addressing these challenges, the project focuses on implementing missing web features, stabilizing authentication, and restoring key modules such as the interactive book to ensure a seamless and engaging learning experience on mobile devices. In addition to feature parity, the project emphasizes improving performance, fixing critical bugs, and enhancing UI consistency and accessibility. A scalable and maintainable architecture will be established to support long-term growth and easier development. Special attention will also be given to localization and multilingual support, making the platform more inclusive and accessible to a global audience. Overall, this initiative is important for CircuitVerse as it enables broader reach, improves usability for mobile users, and ensures that students worldwide can reliably access interactive digital circuit learning resources anytime, anywhere.

<p>A recent addition to the local statistical models in PySAL is the implementation of Multiscale Geographically Weighted Regression (MGWR) model, a multiscale extension to the widely used approach for modeling process spatial heterogeneity - Geographically Weighted Regression (GWR). The GWR model in PySAL can currently estimate Gaussian, Poisson and Logistic models though the MGWR model is currently limited to only Gaussian models. This project aims to expand the MGWR model to nonlinear local spatial regression modeling techniques where the response outcomes may be discrete (following a Poisson distribution) or binary (Logistic models). Subsequently, to support efficient testing for different model implementations, a simulated data generator module will be implemented to supply test datasets following unique model variable distribution needs. This will also provide a foundation for possible expansion to test other local model implementations in PySAL. Additionally, since the functionality to predict the dependent variable at unsampled locations is not supported for the MGWR model in PySAL, this project also aims to enable predictions for MGWR.</p>

I will improve a SMART on FHIR patient-facing app to make it more accessible, user-friendly, and efficient. This includes simplifying menus and buttons, ensuring strong screen-reader support, and optimizing loading times. My plan involves: Research & Analysis Review the current user interface and identify usability issues. Conduct user interviews to pinpoint major pain points (e.g., confusing navigation, slow pages). Redesign & Development Rebuild the interface using React.js with clear, accessible design. Enhance features like keyboard navigation, text sizing, and screen-reader compatibility. User Testing & Feedback Invite patients to test the updated interface. Collect feedback and fix any bugs before final deployment. Documentation & Handoff Provide a developer guide and post the code on GitHub. Ensure future teams can easily maintain and update the app. Key Deliverables A revamped, accessible React.js interface. Improved user workflows and faster load times. A documented codebase on GitHub. A clear style guide and developer documentation.