Explore Projects

<p>This project serves as a modification to the Project “Porting MAVROS for ROS2” and instead aims to provide Ardupilot with native support for ROS2 with basic publish-subscribe features.</p> <p>The protocol that would be followed to implement the native features would be the XRCE-DDS protocol (DDS for resource-constrained environments). This project would involve the building of an XRCE-DDS client along with necessary IDL files for publishing time-critical vehicle messages across to either an :</p> <ul> <li>XRCE-Agent (for native DDS models)</li> <li>Micro-ROS Agent (for ROS2 nodes) with basic publish-subscribe functionality</li> </ul>

<p>MDanalysis (MDA) is a powerful open-source package for exploring and performing calculations on molecular dynamics trajectories. Despite MDAs broad utility, especially for biomolecular simulations, it does not implement many common operations for studying ion solvation. I propose adding a robust and cohesive set of methods for solvation analysis that would be widely useful in both biomolecular and battery electrolyte simulations. The core of the solvation module will be a cohesive set of functions for easily working with ionic solvation shells. Using that core functionality, I will implement several analysis methods for analyzing ion pairing, ion speciation, residence times, and shell association and dissociation.</p>

Description: To integrate KubeArmor with OpenTelemetry, an adapter needs to be created. OpenTelemetry is a standard for telemetry data, including distributed tracing, metrics, and logs, and has an SDK and a collector component that can run on Kubernetes. Applications can directly expose OpenTelemetry data through in-app instrumentation using the OpenTelemetry SDK. The collector can then gather data from multiple applications in a cluster and send it to various backends for storage and visualization, such as Jaeger. Expected Outcome: The mentee's task is to develop an OpenTelemetry adapter for KubeArmor that can receive logs, alerts, and telemetry from the kubearmor-relay-service and convert it into the OpenTelemetry format. They are also expected to create documentation and usage guides that describe how to set up and use the adapter, as well as demonstrate the integration with a backend that supports OpenTelemetry.

This project aims to build a reliable OpenSCAD to JavaScript compiler using ManifoldCAD, making it possible to run existing OpenSCAD code in a modern JavaScript environment. The main challenge is that OpenSCAD works in its own ecosystem, while ManifoldCAD cannot directly execute OpenSCAD programs. Current tools are limited and often don’t handle modern features or correct semantics. To solve this, I will develop a proper compiler that accurately models OpenSCAD behavior instead of relying on JavaScript shortcuts. Building on my existing prototype, I will design a structured pipeline with parsing, semantic analysis, and an intermediate representation (IR) to ensure correctness. Key areas include handling modules vs functions, children(), special variables, and improving debugging through source mapping. The final result will be a robust, production-ready compiler integrated into the Manifold ecosystem, enabling developers to reuse OpenSCAD libraries with confidence.

The zlib is required for compiling and running many existing C / C++ / Rust apps in Wasm. Most noticeably, it is [needed in the Python port to Wasm](https://github.com/python/cpython/issues/93819). The VMWare Wasm Labs team is using a zlib port from [Singlestore](https://github.com/singlestore-labs/python-wasi) in [their Python Wasm runtime](https://wasmlabs.dev/articles/python-wasm32-wasi/). In WasmEdge, we could support the zlib host functions through our [plugin system](https://wasmedge.org/book/en/plugin.html). This way, any existing zlib apps can be compiled to Wasm and runs inside WasmEdge. - Expected outcome: Create a new [WasmEdge plugin](https://wasmedge.org/book/en/plugin.html) that exports all public functions in `zlib`. Implement SDK (in C/Rust) that uses the C ABI to generate corresponding headers for the above plugin. Generate the unit tests and pass the unit tests. >80% of code coverage for verification.

<p>Writing and maintaining software is challenging. Software is complex and keeping it bug-free remains an unsolved problem. Debian Stretch, the next Debian stable release, comprises 850 million lines of software source code. Code written in the C programming language accounts for 41% of the lines, which is more than in any other programming language. Debile, Debian’s package analysis platform, so far includes the CppCheck, Clang Static Analyzer, and Coccinelle tools for packages with C, C++, and Objective-C code. However, all of the tools perform static analyses, which can result in false positives. Too many reported false positives hinder adoption of the tools. To address this issue, I propose to integrate the KLEE tool into Debile. KLEE performs dynamic analysis on C programs and reports only true positives, i.e. real bugs. It does so by systematically exploring as many as possible execution paths in a given program. Errors that KLEE reports exist only along feasible execution paths, i.e. they correspond to real bugs in the program.</p>

Currently InVesalius does not support simultaneous visualization of structural MRI and fMRI volumes. This is however of large interest to visualize both modalities for people involved in the clinical and analytical domain. Indeed a direct implication would be to have functional connectivity induced graphs visible along with structural connections (white matter). On top of which, after generating 3d maps, it may then be possible to visualize in space the functional connections versus structural connections. First of all, this project would be a useful feature to InVesalius, but secondly also to the neuroscience community. By having InVesalius open source and in a UI format it would enable clinical experts or neuroscientists without engineering background to have ready to go visualization of fMRI and structural MRI volumes. In general this could be extended to other modalities as well. Two possible ways to simultaneously visualize structural MRI and fMRI are: 1. Overlay different masks or contrasts (need to be carefully picked) for each of the two modality. There might be a need to apply some color distribution matching between structural and functional (e.g histogram equalization) since one would be T1 and the other T2 to have better visualization. Both slices would need to be co-registered prior to overlaying. The effect on the generation of 3D visualization would also be cared for. 2. Having two views or preview of fMRI in each orientation (sagittal, coronal, axial and 3d). Two views or one main view and a preview would require to have a tracker (dot) that points to the same voxels in the two views. This could be a way for the user to match regions for instance and essentially avoid crowding the visualization. The language I plan on using and believe fits the project would be python. The potential libraries used during the project would include already required ones for InVesalius (e.g scipy,opencv)

Currently, Bluetooth HID support in FreeBSD is limited to the bthidd daemon. The daemon, while functional, uses its own custom userspace drivers rather than the existing HID drivers in the kernel. Of these userspace drivers, only keyboards and mice are supported. This project proposes a more integrated design via a new Netgraph node type: ng_bthid. This node will hook to ng_l2cap and function as a virtual transport layer that interfaces directly with hidbus. The aim is to make HID support more transport-agnostic, moving away from the previous approach of maintaining separate, redundant drivers for devices over Bluetooth.

This project is a continuation of the project : ROS-2 Native Support for Ardupilot, which I worked on while receiving mentorship from Ardupilot in 2021. It intends to provide a number of technical improvements to the ROS-2 support capabilities currently available in the Ardupilot codebase.The major improvements planned for the project are 1) Implementation of Data Writer functions for ROS-2 messages 2) Creating a ROS-2 package that verifies if the DDS capabilities in Ardupilot are functioning properly or not 3) Development support for Gazebo Simulation with ROS-2 4) General Improvements for Ardupilot’s DDS Client to make it more user-friendly

pwndbg currently has support for debugging the jemalloc and glibc allocators. There are many programs out there that use different allocators, so extending support is important. I will implement support for musl's allocator: mallocng. This will require gaining a precise understanding of the used data-structures and algorithms. It will involve carefully reading the source (https://git.musl-libc.org/cgit/musl/tree/src/malloc/mallocng). In the end pwndbg will have additional commands for visualizing the data-structures used by mallocng, analogous to the heap, bins, arena, mp, vis etc. commands used for glibc malloc.

This project aims to add Arm Arm Confidential Computing Architecture (CCA) support to the Unikraft ecosystem, which is a step of “Unikraft as the Secure Configurable Unikernel”. Arm CCA is introduced in Arm v9 and it introduces new hardware features to make OS run as a confidential VM without trusting the underlying hypervisor. To achieve this goal, this project needs to finish the following tasks: 1) making CCA an option for Unikraft and adding support for necessary RSI commands; 2) preparing the FVP environment; 3) Adding support for more advanced features like attestation and memory encryption; 4) testing the project using several applications.

<p>This project aims to add support for arrays and allocatables in LFortran. Specifically, features to be added for arrays are as follows,</p> <ul> <li>Declaring Arrays</li> <li>Operations on Arrays</li> <li>Indexing Arrays</li> <li>Passing Arrays as Functions/Subroutines Arguments</li> <li>Array Initializer Expressions</li> <li>Slicing Arrays</li> <li>Intrinsic Functions for Arrays</li> </ul> <p>For supporting allocatables, the main focus would be on generating instructions to allocate memory in heap using <code>malloc</code>. There are some miscellaneous goals as well, such as improving support for pointers and kinds and some bug fixes discovered along the way.</p>

<p>While MAVProxy serves as a fully-functional cross-platform portable ground control station software, the system lacks the presence of a Graphical User Interface making it more difficult to use as compared to other GCS like Mission Planner, QGroundControl etc. Also, the GCS can be improved by the addition of some modules to replace the commonly used cumbersome terminal commands. A major deliverable of this project would be the addition of a UI based parameter handling module with incremental search capabilities. With a recent increase in the number of users, academic researchers and developers working on swarms and multi-vehicle simultaneous control; a new module providing a few high-level commands to all the vehicles or to individual vehicles with a GUI based environment can potentially serve as a good addition to the GCS.</p>

<p>VISual MAth (visma) is an equation solver and visualiser, which can be used to solve complex mathematical equations. It not only solves the equation but also displays step by step approach which is deployed in the solution. It is also capable of plotting 2D and 3D plots. My proposal is to refactor old simplify modules (to include built-in python functions) and adding new modules like Discrete Maths module, higher degree equation solvers, implementing Matrix Module in GUI, adding support for simultaneous equation solvers, adding integration &amp; derivation modules etc. Also, I will be implementing "Equation Scanner" in VisMa as a side project. This would enable the user to input the equation to VisMa by providing an image of the equation. I will also be focussing on improving existing documentation and adding more documentation to the project.</p>

<p>The UI Migration project is an effort focused on generating the new component-based architecture with the integration of the APIs. To make the project more <strong>efficient</strong> and <strong>easily accessible</strong>, an entire code base shift from Symfony-Twig to React.js is proposed. React.js features an incrementally adaptable architecture that focuses on declarative rendering and component composition. React.js component system will enable us to organize the current working APIs appropriately.</p> <p>The main <strong>objectives</strong> of this project are:</p> <ol> <li>Working on good interactive design, with a modern look.</li> <li>Integrating the APIs to the new component-based UI structure.</li> <li>Seamless routing and page transitions.</li> <li>Giving the power of the node engine to our UI. Making all NPM accessible.</li> <li>Write appropriate documentation.</li> </ol>

<h5>End-to-End Testing Support</h5> <p>Oppia Android's current testing corpus includes unit tests using the Robolectric testing framework &amp; integration tests using the Espresso testing framework (to ensure that the app operates as expected in a real Android environment). The current tests have a few limitations: they do not correctly facilitate cross-activity navigation flows which actual users will be triggering, and they do not verify that the app can interact with Oppia's backend correctly.</p> <p>To prepare for the global launch of the app, we need end-to-end tests that:</p> <ul> <li>Verify that the app works as a user would expect by playing through select critical user journeys</li> <li>Verify that the app operates as expected when interacting with a local developer instance of the Oppia backend server</li> </ul> <p>We expect that the tests will be written using UiAutomator &amp; are set up for interacting with a local development server (see <a href="https://developer.android.com/studio/run/emulator-networking.html" target="_blank">relevant documentation</a>).</p> <p>Note that this project requires running Linux with virtualization support (in order to run an Android emulator). You will need to make sure your computer supports <a href="https://help.ubuntu.com/community/KVM/Installation" target="_blank">KVM</a> and is running Linux.</p>

This proposal lays out plans to bring native MPLS support into the FreeBSD kernel. MPLS—Multi-Protocol Label Switching—is a fast packet-forwarding method you’ll find everywhere in big service provider and data center networks. Instead of making routers do complex IP lookups at every hop, MPLS uses simple label swapping. The magic happens with a tiny 32-bit shim header that holds a 20-bit label, a few bits for traffic class, a stack indicator, and an 8-bit TTL. This header sits snugly between Layer 2 and Layer 3 headers, letting routers in the core do blazing-fast forwarding while pushing tough routing decisions to the network edge. FreeBSD is famous for its solid IPv4 and IPv6 networking stack, but it’s been missing native Layer 2.5 switching. That gap has made it hard for FreeBSD to get traction in provider core networks. Meanwhile, OpenBSD and NetBSD have shipped MPLS support for ages, and Linux has had MPLS built in since kernel 4.3. FreeBSD’s overdue update doesn’t just catch up—it leapfrogs the other BSDs. This project stands out in two big ways: it adds ECMP multipath support using the modern nhgrp (Nexthop Group) subsystem, and it swaps out the old, hard-to-extend rtsock interface for a much more flexible Netlink-based control plane.

Ampath form builder provides an interactive interface that allows OpenMRS to build schemas effortlessly. Users can create schemas using their interactive form builder or by writing JSON in the Schema editor. The current form builder is an angular JS-based module. This form builder makes creating/editing forms more effortless. But the user interface of the form builder has various unexpected bugs and user experience issues. As a solution to this problem, the Form Builder UI can be redone using React JS. By the end of this project, a React JS based Ampath Form Builder will be delivered with an improved User interface.

Problem: FFmpeg DNN(Deep Neural Network) module has enabled OpenVINO backend inference on Intel GPU. While the FFmpeg decode and encode work on cpu currently memory copy between CPU and GPU, which lead to notable latency. It results in performance degradation when we do inference with some certain models. Therefore,I wan't to support the FFmpeg DNN inference GPU full pipeline, which means the FFmpeg DNN can do all the decode, encode and inference only on Intel GPU, without any memory copy. Method: Integrate ffmpeg dnn module and OpenVINO GPU inference with VaSurface GPU memory type Deliverables: A full gpu codec and inference pipeline on ffmpeg dnn module and a well writen document with user guide expamples

<p>The current GRASS GIS version has partial support for Python 3. This project aims to update core GRASS components for Python 3 and update all the python modules, libraries and components like script package, python/ctypes, pygrass, temporal, wxGUI, etc. At the end of this project, GRASS GIS will be compatible with both the versions of python, i.e Python 2.7 and Python 3 with its GUI having support for wxPython 4.</p>

<p>In the last GSoC, kingiw created an initial version of casbin.js. This version has a CASL-like API. He also adds support to go-casbin and node-casbin.</p> <p>However, casbin.js relies on an insufficient way to share permissions between the frontend and backend. The backend needs to send the whole policy definition model to the frontend, which will use node-casbin to check the permission. This method requires a heavy data transfer in between, and has potential security problems.</p> <p>To build a production-ready frontend permission control library, we need to</p> <ul> <li>Design a new data structure to only store one-user permission.</li> <li>Add a full set of API to operate on the data structure.</li> <li>Implement integration with the frontend frameworks like React or Vue.js.</li> <li>Add util function in different implementations of Casbin.</li> </ul>

<p>Building and maintaining a website is an essential task for any business or organization. This project aims to ease the workflow of getting a website up and running by developing a “generalized website builder”, with the help of the Gatsby Js Framework. The individuals would be able to utilize this generalized platform to plug-in required modules and configure the datasource as per requirements to build custom websites for their organizations.</p> <p>The built website builder will be used to to fully migrate <a href="https://www.scorelab.org/" target="_blank">https://www.scorelab.org/</a>, the current Score Lab website to Gatsby Js and also migrate all the data into an easily maintainable datasource. The new website would be a highly refined version of the current site in terms of the look and feel and the maintainability.</p>

<p>Sustainable energy production and consumption are crucial for a prospering life on earth. Decentralized energy production is one of the next big challenges, which will influence the energy production in the future years. The emerging smart grids include an inherent need for communication for monitoring and control purposes in a more and more dynamic environment. One of the major challenges is monitoring the power quality parameters in a decentralized manner. The Freifunk mesh network is an outstanding example for a decentralized infrastructure that could be augmented with grid related functionalities to cope with future energy challenges. The main goal of this project is to enable power quality measurements on OpenWrt. Voltage samples from the electric socket are retrieved at the router. Next power quality parameters are calculated, and finally made available for retrieval over IP networks.</p>