Explore Projects

Pallene is a statically typed companion language to Lua, designed to write performance sensitive part of it. Pallene has a very similar syntax as Lua, sharing its runtime as well. Pallene is Ahead-of-Time compiled language, compiling into C before getting compiled into a Lua module. As the situation stands for Lua stack trace, it does not store any line number information for any native C call, which Pallene eventually ends up using. There are also missing traces when a Pallene function calls another Pallene function as the call is in Pallene environment and completely oblivious to Lua. This proposal aims to fix that issue in Pallene, improving its overall debugging support.

The OpenMRS Authentication module supports powerful features like Multi-Factor Authentication and TOTP, but there is no working integration with the modern O3 frontend. When the backend issues a secondary authentication challenge, O3 has no way to handle it gracefully and will breaking the user's workflow and losing their unsaved work. My plan is to fix this on both sides. On the backend, I will update the backend to return structured JSON responses instead of legacy redirects, and expose new REST endpoints for TOTP setup and verification. On the frontend, I will update to pause and replay requests around authentication challenges, and build the React components that handle the TOTP flow that all without interrupting what the user was doing.

<p>The project is to add more comprehensive support for mcmc sampler methods in PyMC4. Currently there is no support for discrete distributions in model, support for gradient-free samplers, etc. The goal of the project is to expand the support for mcmc sampling, add various samplers, including SMC, etc.. Also, from the design perspective there is a need for compound step/Gibbs sampling. We need to collaborate with the Tensorflow Probability team developers to implement the most effective solution.</p>

<p>Search_API_Location module provides the geospatial search experience to Drupal. Geo-spatial search mainly refers to searching data that is associated with a particular location. Queries such as give me all the restaurants that serves meat within 20 miles from me, or create a distance heat map of them are example of spatial search. Here, some live websites like <a href="https://www.airbnb.co.in" target="_blank">Airbnb</a>, <a href="https://www.tripadvisor.in" target="_blank">TripAdvisor</a> , <a href="https://www.yelp.com" target="_blank">yelp</a>, <a href="https://www.olx.in/" target="_blank">olx</a> etc use Geospatial searching functionality with different type of features which are still missing in Drupal domain.</p> <p>As we know location based search is slowly becoming popular and a must have for any content website in the recent era, Drupal 8 needs to have a drop-in solution for geospatial search. Right now there are some alpha modules existing but these modules need some serious investment for it to become production ready. As well as it should support both Apache solr and MySql server as backend for indexing location data.</p> <p>Search_API_Location module is an extension for Search_API module and it mainly does two things</p> <ul> <li>Adds support for indexing location values</li> <li>Helps in filtering and sorting location values</li> </ul>

Numba is a JIT compiler that translates a subset of Python and NumPy code into fast machine code. Cppyy is an automatic, run-time, Python-C++ bindings generator, for calling C++ from Python and Python from C++. Cppyy has to pay a time penalty each time it needs to switch between languages which can multiply into large slowdowns when using loops with cppyy objects. This is where Numba can help. Since Numba compiles the code in loops into machine code it only has to cross the language barrier once and the loops thus run faster. Initial support for Cppyy objects in Numba enabled the use of builtin types and classes, but some essential C++ features, such as references and STL classes, are not yet supported. The project aims to add support for C++ reference types in Numba through Cppyy and improve the existing numba extension implementation to provide general support for C++ templates. This added support will allow cppyy users to define a wider array of standard and templated functions that can leverage reference types to the C++ code defined in python.

<p>Injection attacks are still the most common type of vulnerabilities found in software, SQL injection is one of them, it exploits the lack of sanitization of the user input when performing database queries, the goal of the project is to enhance SQL injection support in the metasploit framework, to make it easier for module writers to implement SQL injection attacks.</p> <p>In order to accomplish that, I will be implementing the common SQL injection attack types (including blind injections), and adding a level of abstraction, where I handle retrieving the table and column names, and other informations, on the different database management systems.</p> <p>People developing SQL injection exploits with metasploit will no longer need to implement the binary search required to do blind SQL injection, or measure timing in time-based attacks, or prepare a query that depends on the DBMS to retrieve the table names.</p>

<p>Cuckoo Sandbox is a malware analysis platform which performs basic static file analysis to in-depth dynamic analysis of binaries. Even though macOS modules exist, they are not being properly used by the Cuckoo work system. The idea is to add a long term support for macOS binaries by setting up kernel-space extension by rewriting <em>xnumon</em>. As xnumon in itself is an up to date monitoring module, we can rewrite the kext to incorporate our custom logging and reporting methods. Apart from that macOS malware specific auxiliary modules are to be written in the later part of the project</p>

<p>OpenCV is used extensively in computer vision, tackling almost all major computer vision problems. Many Modern CV applications require working with videos, which are essentially images(frames) stacked on top of each other. Potential applications can also include working with audio along with video frames. OpenCV currently doesn’t provide support for such applications out of the box. The goal of this project is to add speech recognition samples, to be used with the OpenCV DNN module, to provide out of the box support for applications involving audio. The newly added AudioIO module can provide a convenient way to read such audio files.</p>

<p>This project aims at making Anita, a tool for automated testing of NetBSD, modular, provide support for other virtual machine systems like GXemul and Virtualbox and support testing for as many releases/ports (like NetBSD/evbarm-earmv7hf etc.) as possible. This also includes building releases, testing them and debugging the system files (written in C) to make them work. Currently, Anita only has support for qemu (and experimental support for running NetBSD as Xen DomU). Unlike BSD, Linux has a kernel module known as KVM, which allows a user space program to utilize the hardware virtualization features of various processors and can be utilized by qemu to provide “KVM acceleration” when the target architecture is the same as host architecture. The lack of such support makes qemu really slow on NetBSD. Testing system installation on a wide variety of platforms is very crucial for any organisation that’s into OS business. It can be a frustrating task to do that manually, but, if neglected can be a make or break situation for the OS (adoption/marketing). Automated testing with Anita makes the job a cakewalk. Support for Xen and Virtualbox will further enhance the capabilities of Anita.</p>

This project aims to implement full coarray support in the LFortran compiler, enabling native parallel programming capabilities based on the Partitioned Global Address Space (PGAS) model defined in the Fortran 2008/2018 standards. Currently, while LFortran’s parser supports coarray syntax, the feature is not implemented beyond basic stubs, preventing execution of even minimal coarray programs. The project will bridge this gap by extending LFortran’s Abstract Semantic Representation (ASR) to model coarrays, implementing semantic analysis for coarray constructs, and introducing a dedicated coarray runtime library. A key component is an ASR-to-ASR lowering pass that translates high-level coarray operations (such as coindexed access, synchronization, and collective intrinsics) into runtime calls. This design follows LFortran’s existing OpenMP architecture, ensuring backend-agnostic support across LLVM, C, and other targets. The implementation will proceed in two phases: first, establishing a fully functional single-image mode with correct semantics and runtime integration; second, enabling multi-image execution using an MPI-based runtime backend. By the end of the project, LFortran will be capable of compiling and executing coarray programs in both single-node and distributed environments. This work lays the foundation for supporting real-world coarray-based HPC applications and positions LFortran as a leading LLVM-based Fortran compiler with modern parallel programming support.

One of OpenMRS’ strengths is its concept-based data model that allows each implementation to be configured in a suitable way for its own clinical scenario. Open Concept Lab Module is the admin tool that is used by OpenMRS to import the concepts defined in the Open Concept Lab which is the shared web service used for managing concept dictionaries. The existing OCL Module is built as an Open Web App module targeting OpenMRS RefApp 2.x. This project aims to rebuild this module as an OpenMRS 3.x Admin Tool with modern micro frontend technologies and enhance the user experience.

Kyverno is working towards support of ValidatingAdmissionPolicy (CEL admission). Extend this support for other items such as CLI, reporting, and auto-generating ValidatingAdmissionPolicies from Kyverno policies. - Expected outcome: Extended support and integration with ValidatingAdmissionPolicies

<p>Mass spectrometry is an important analytical technique that allows to determine molecular composition of samples by obtaining mass spectra of ionized molecules.</p> <p>In this project I am going to develop a new module for automatic mass calibration that aims to reduce systematic error of measurement by shifting features to better match with predicted compounds. The calibration will give more accurate and easier to work with data, and is crucial to reduce false positives in molecular identification.</p> <p>I am also going to develop deisotoping support using high-resolution of mass spectra. Recent developments allow to obtain mass spectra of resolution high enough to observe differences of nuclear binding energies among isotopes. The new module I am going to build will detect isotopic patterns of chemical compounds and relate fine mass peaks with each other based on m/z differences corresponding to nuclear mass defects of isotopes of selected elements. The project will, among others, help annotate molecular formulas, improve and simplify downstream analysis and also be a software part visualizing the evidence supporting relativity (by incorporating binding energies into molecular prediction).</p>

OpenSSL 3.2 introduced native QUIC support, enabling HTTP/3 on top of the world’s most widely deployed TLS library. Apache httpd, however, is still architected around TCP-based connections and its Multi-Processing Modules (MPMs), which makes integrating QUIC and HTTP/3 non-trivial. An example codebase (openssl-h3-examples) already demonstrates HTTP/3 using OpenSSL’s QUIC support and nghttp3 in a standalone server, and reuses patterns inspired by mod_http2, but it remains experimental and is not integrated into httpd as a module. This project proposes a new HTTP/3 module for Apache httpd, building on OpenSSL QUIC and nghttp3, and aims to resolve the architectural mismatch between httpd’s TCP-oriented worker model and QUIC’s UDP-based, stream-multiplexed transport. The goal is a maintainable, reviewable prototype module that the Apache HTTP Server community can evaluate and evolve toward production readiness.

<p>Traversal-based graph algorithms are good at extracting “subgraphs of interest” when applied to large networks. However, applying known algorithms may not be enough every time to extract the useful information. Some specialized queries may be helpful in this sence to extract more useful or more specific information. Actually, these types of queries are already implemented inside the PATIKAweb software that is a result of the study done by Doğrusöz et al. in Java programming language. The aim of this project is to move these implementations into the common use of developers by making an extension to Cytoscape.js, which is a commonly used graph drawing library written in Javascript. Cytoscape.js already includes some basic graph traversal algorithms such as DFS, BFS, Dijkstra, Bellman-Ford, Kruskal etc., but I believe that these specialized queries will provide a good functionality to be used in not only in biological networks, but also in other types of networks. With the advantage of compound node support in Cytoscape.js, these specialized traversal algorithms will also be easily applied to the large networks with compound node content.</p>

<p>There are numerous MPI implementations in the Gentoo portage tree and far more in general, but most of them can't be installed together as is. The only way to do this now is by using empi from the science overlay and empi has its shortcomings such as lack of multilib support and was not ported to the main tree. In my proposed plan, a new MPI framework ported from existing MPI applications is introduced to enable Gentoo to use multiple MPI versions and relevant packages depending on them (for example, HPL). The new MPI framework is mainly based on ‘Modules’ package together with Gentoo Prefix technique for detecting, choosing or manipulating MPI environment. Also, a new implementation of mpi.eclass is introduced and the packages can still be emerged normally onto the system without any trace of mpi.eclass being used. The approach also enables users to easily work with different implementations at the same time without any special privileges. In order to solve the defect that empi does not support multilib, the new framework also adds support for allowing the environment to be configured and installed into different places among different architectures (amd64, x86 etc.).</p>

This project aims to develop a robust, secure, and extensible Drupal module that integrates with Appwrite, an open-source backend-as-a-service (BaaS). The module will enable seamless support for Appwrite’s authentication, file storage, and database APIs within Drupal’s architecture. By bridging these platforms, the module will empower developers to build dynamic, serverless applications while leveraging Drupal’s powerful CMS capabilities. The project will prioritize modularity, configurability, and maintainability, ensuring that it aligns with both Appwrite’s evolving API surface and Drupal’s best practices. Project Goals: Develop a Drupal module that connects with Appwrite’s OAuth-based authentication system (supporting providers like Google, GitHub, Apple, etc.). Enable media file management by integrating with Appwrite's object storage APIs, reducing the dependency on traditional cloud storage solutions. Integrate Appwrite’s document database to store and retrieve structured Drupal content efficiently. Create an intuitive configuration interface within Drupal for managing all Appwrite-related settings.

**Pwndbg** is a debugger extension that enhances the debugging experience. It currently supports only GDB and LLDB on Linux and macOS. This project introduces Windows support for Pwndbg. Initially, only WinDbg will be supported, but a generic interface could enable support for other debuggers (GDB, LLDB, x64dbg, etc.). The goal is to bring Pwndbg enhancements to the WinDbg console — providing a similar experience to using it with GDB or LLDB. End users should be able to access all native WinDbg features while also using Pwndbg commands and context windows. The project leverages WinDbg’s `wdbgexts` or `DbgEng` to interface with Pwndbg. This requires either an RPC client-server protocol or native integration of Pwndbg on Windows. Pwndbg needs to hook into WinDbg states (registers, memory, etc.) and respond to all command calls from WinDbg.

This project aims to add native SVG import and export capabilities to p5.js through enhancements to the p5.Shape system. Currently, p5.js only supports raster exports which limits professional workflows for artists and educators who require vector outputs. The project will first extend the Shape system by adding ArcSegment and EllipseSegment primitives to enable structured geometry recording. Then an SVG export add-on will be developed using a visitor pattern to convert recorded primitives into clean SVG paths with transform support. Key deliverables include a shape recording API, SVG export via saveSVG(), basic SVG import support, documentation, and tests. This will improve interoperability of p5.js with design tools and vector workflows while maintaining backwards compatibility.

The current Continuum Mechanics module is very useful and has been developed to a good extent. However, there are many more concepts that are prevalent in the field of Solid Mechanics and have not been implemented in SymPy. This project aims to implement some new classes that would bring these utilities into the module. This way a wider range of engineering problems can be solved using SymPy. The two features that are planned to be implemented are solving Torsional problems due to the presence of torque along the direction of the shaft and calculating internal forces & reactions for a given Truss under external forces and moments. This project also plans to add some functions to the geometry module to add some flexibility to the way one can form composite shapes so that it is easier to define complex cross-sectional geometries for the beam module. Implementing the above-mentioned features will expand SymPy to a great extent and help users solve a wider range of problems with ease and precision.

<p>The project is about implementing a Qt5 and ROS support in RoboComp’s DSL</p>

Optimizing code for heterogeneous hardware like GPUs requires specialized approaches. While LLVM/Clang supports various GPU programming interfaces, LLVM IR hinders effective analysis for GPU code with its SIMT model. Clang's mid-level IR (ClangIR) based on MLIR is better suited to capture this information from source code. This project proposes adding basic OpenCL C support to ClangIR. Challenges and Solutions: 1. Code Generation Paradigm Shift: CodeGen and Lowering (ClangIR's compilation passes) employ distinct coding paradigms due to their underlying infrastructure (AST reflection vs. MLIR Pass Rewriter). Migrating existing CodeGen code to the Lowering framework could be complex. We will actively debate the trade-off between optimization potential and implementation complexity to propose and execute well-designed, achievable plans. 2. Scattered OpenCL Support Code: Current OpenCL support code is dispersed throughout the codebase, hindering development quality control. Strategies will be developed to address this issue, such as extracting key information from flags like getLangOpts().OpenCL and getOpenCLRuntime(), or implementing systematic code searches to consolidate functionalities and address issues in a structured manner. The final deliverables of this project include a) A set of testcases that combines unit tests with integration tests b) An AST Consumer for OpenCL C (extension of CIRGen) c) A set of MLIR Passes for properly generating SPIR Kernels d) A functional and performance test report (optional) e) Detailed development documentation for all the above parts

The goal of this project is to improve OpenCV’s imgcodecs module by reducing code duplication, enhancing performance, and improving format support. Deliverables: Modular and maintainable imgcodecs module. Faster, more efficient image I/O. Improved support for modern image formats and metadata. Robust and complete JPEG XL implementation with animation.