Explore Projects

Migrating content between different CMSs like Joomla, WordPress, and Drupal is challenging due to their distinct data structures. Traditional migration methods require custom tools for each CMS pair, leading to an O(n²) scalability problem. This project introduces a Common Content Model (CCM) as an intermediate format to simplify migrations to O(n) complexity. Using Model-Driven Engineering (MDE), we will dynamically adapt to various CMS schemas and automate migration script generation. The solution will be a Joomla component acting as a universal mediator to extract and transform content between CMSs. It can be installed on any Joomla instance, either directly or as a temporary migration app to handle API-based content migration between any CMSs. This project reduces development overhead, enables reusable migration structure, and positions Joomla as a central hub for content exchange across platforms. Deliverables: * CCM Joomla Component: A standalone migration component built for Joomla. * WordPress-to-Joomla Migration: Real implementation example using the CCM. * Testing Suite: Unit, integration, and E2E tests to ensure migration reliability. * Documentation: Clear guides for extending to other CMSs.

This project aims to bring real-time, AI-powered live translation to the eventyay-video platform. Currently, the SUSI Translator prototype works well but relies on local computer microphones and standalone scripts. To make it ready for live online events, this project will upgrade it into a fast, web-native system that works entirely in the browser. The solution captures live audio directly from the speaker's browser, immediately filtering out silence to save server costs. This speech is then streamed at high speeds to a backend server. There, AI models (Whisper and an LLM) transcribe and translate the speech. To prevent robotic or broken grammar, the AI uses a "sliding window" to remember the last few spoken sentences, ensuring translations make sense in context. Finally, the translated text is sent back to the audience's screen as smooth, easy-to-read subtitles. Key Deliverables: - A browser-based audio capture and silence-filtering module. - A high-speed server connection (WebSockets) for instant data transfer. - A context-aware AI translation pipeline that prevents grammatical errors. - A stable, flicker-free subtitle interface built directly into the eventyay-video player.

CrocoLakeTools currently downloads ocean datasets from static sources, either a fixed URL or a fixed file list. This works for stable snapshots like GLODAP, but not for live ERDDAP servers like the IOOS Glider DAC, which hosts hundreds of delayed-mode glider deployment datasets that grow and change over time. This project builds an incremental sync layer targeting the IOOS Glider DAC. The implementation follows a three-layer architecture discussed with the mentor: a CLI script for user interaction, a dataset-specific downloader (DownloaderIOOSGliders) that handles ERDDAP query logic and URL construction using erddapy, and the base Downloader class that provides shared tools used by all downloaders in the package. The sync tool queries the server, compares server-side timestamps against local files, and downloads only what is new or updated. Files are stored exactly as served by ERDDAP with no schema conversion. Deliverables: (1) download_parallel() added to the base Downloader class, (2) DownloaderIOOS base class wrapping erddapy, (3) DownloaderIOOSGliders with incremental sync logic, (4) download_ioos_gliders.py CLI script, (5) unit and integration tests, (6) animal telemetry subclass as a stretch goal.

Scikit-bio offers a great toolkit for working with biological data that has a tree-like structure. Although the current implementation, TreeNode, can accommodate a large variety of use-cases, its pointer-based nature limits its scalability to large trees with billions or even trillions of nodes. This project aims to remedy this problem by implementing a succinct data structure for trees based on its balanced parentheses representation, such that the memory usage and the time required for operations are minimized. There are two main components to this project. The first component pertains to the implementation of the data structure proposed in using Numba and NumPy based on improved-octo-waddle, a previous implementation using Cython. The other component relates to integrating the new data structure into the back-end of the existing TreeNode class within the library to enable compatibility with the existing APIs. The core deliverables include: an implementation of the new data structure that can be interfaced via TreeNode, an extensive suite of tests for correctness and benchmarking to ensure performance uplifts, and documentation to guide users on the usage of the new data structure. As a potential extension, GPU support will be investigated along with the exploration of an alternative solution proposed by Córdova, J. and Navarro, G. (2016).

Kolibri Studio is a content curation tool for Kolibri. Its main purpose is to provide an easy and convenient way to organize learning resources and build channels for Kolibri. User Experience is a really important aspect of Kolibri Studio as it may involve multiple users working on the same content curation unit (channels). Delayed reflection of the modified state of a channel to a collaborative user may cause inconvenience and may even lead to repetitive change to the same entity. The current setup for Real-Time Communication in Studio involves maintaining a server-side log which is being simulated by calling the POST method of sync API. All collaborative users are hitting this POST method at regular intervals to post any changes made by them (if no changes are made then the empty changes array is posted) and receive any changes made by other users as a response of this method. The proposed WebSocket architecture will neutralize and reduce the load on the server which is currently being created due to continuous polling of the APIs. It will convert the complex underlying structure of Sync API into a simple real-time-friendly architecture in which a full-duplex communication between client and server takes place. It will also enormously enhance the user experience of the whole process of collaborative content curation.

<p><strong>Boost::boyer_myrvold_planarity_test</strong> A graph is planar if it can be drawn in two-dimensional space with no two of its edges crossing. Such a drawing of a planar graph is called a plane drawing. Every planar graph also admits a straight-line drawing, which is a plane drawing where each edge is represented by a line segment. When a graph has K5 or K3,3 as subgraph then the graph is not planar. This algorithm is only applicable for <strong>undirected</strong> graphs. It has a linear time complexity of <strong>O(|V|)</strong>.</p> <p><strong>Boost::make_connected</strong> Adds the minimum number of edges needed to make the input graph connected. The algorithm first identifies all of the connected components in the graph, then adds edges to connect those components together in a path. For example, if a graph contains three connected components A, B, and C, make_connected will add two edges. The two edges added might consist of one connecting a vertex in A with a vertex in B and one connecting a vertex in B with a vertex in C. This algorithm is only applicable for <strong>undirected</strong> graphs. It has a linear time complexity of <strong>O(|V| + |E|)</strong>.</p> <p>I propose to add the above two algorithms to pgRouting during the GSoC period.</p>

Simulating quantum physics in QuTiP provides an excellent educational tool. However, using QuTiP requires writing Python code, which may present an obstacle in some teaching contexts. Programming is, of course, a very valuable skill to master. Attempting to master it while simultaneously coming to grips with quantum mechanics is perhaps less advisable. We would like to create a graphical virtual laboratory powered by QuTiP which allows users to explore quantum systems without being distracted by the need to write software. The virtual lab would allow building up experiments from components (e.g. sub-spaces such as qubits, Hamiltonians for those subspaces, interaction Hamiltonians, environment baths), evolving the system over time, applying measurements, and attaching monitoring of quantum states or measurement outcomes (e.g. Hinton plots, Bloch sphere plots). Deliverables - A graphical interface that acts as a virtual laboratory - Allows the construction of simple quantum systems (e.g. placing four neutral atoms) - Allows defining the evolution of each system component - Allows defining the interactions between system components - Allows coupling the system to an environment bath - Allows simulating the system dynamics and visualizing their evolution over time - Allows visualizing the steady state of the defined system - Can be run on both desktop and tablets

<p>Mission Support System is a flight planning software which a researcher can use to analyze predicted atmospheric data, and plan a flight-path with 3D way-points. The software in the present state allows editing by a single user per flight-path. To share this work, one has to export the work as a <code>$name.ftml</code> file and send it to other researchers for further planning. This back and forth communication not only consumes a lot of human efforts and time, but also can be frustrating when the number of researchers involved in a project is bigger, say &gt;=3.</p> <p>I propose a solution to this problem, the development of <code>Mscollab</code> which stands for "Mission Support Collaboration". <code>Mscollab</code> server would facilitate <em>real-time</em>, <em>collaborated</em> editing of flight-paths by <em>authorized</em> users. By design, it will also provide a chat facility for the users who are collaborating on the project. Its UI would be a part of <code>msui</code>, the core User Interface module of <code>mss</code>. It would additionally provide insights about temporal changes related to waypoints and the users who created them, for analytics purpose. <code>Mscollab-server</code> will be a standalone server built with Python, Flask, and python-socketio.</p>

The erddapy package provides a Python interface to the ERDDAP data server API. Currently, most of erddapy's functionality is concentrated into a single class, and the URL building features are implemented in that class along with the data transformation methods that process server responses into Python objects, such as Pandas DataFrames. This project proposes to separate erddapy into core and object (or opinionated) layers. The former will hold the URL building and data transformation functionality, which will be reused by the rest of the library. The latter layer will provide high-level objects that will support a functional API that does not depend on the state of the underlying object (which is the case for the current version of erddapy). This functional API will provide cleaner iterative usage when querying multiple servers and datasets, and new classes implemented in the object layer will support serialization so that they can be pickled and passed on to other processes or machines. To execute this project, I delineate two separate aims: refactoring the URL building and data transformation functionality into a new module containing minimal, standalone functions and reusing those functions in the existing primary class; and implementing an additional layer containing the high-level objects that will provide the basis for the functional API. Overall, this will greatly improve the flexibility and scalability of the package, and will help support its wide spectrum of users.

Kgateway can be used as an “AI Gateway” that allows applying traditional traffic management, security, and resiliency policies when reaching out to LLM providers. It also allows sending a request to another server for processing things like prompt guards or enrichment before we send it off to the LLM providers. An important aspect in any system that has lots of moving parts is observability: the collection of metrics and other information that allow you to identify issues and troubleshoot a live system. This project aims to enable OpenTelemetry support in kgateway’s AI extensions by allowing users to configure a gRPC tracing collector. This feature enables span propagation from the AI extensions extproc server and exporting traces to an OpenTelemetry-compatible backend (e.g., OpenTelemetry Collector, Jaeger, Zipkin, or Datadog). This feature will build on Envoy’s native tracing capabilities and aligns with industry-standard observability practices. This will make it easier to debug, monitor, and optimize traffic flowing to LLM Providers through kgateway. Expected Outcome: 1. Design and implement an API to enable tracing for the kgateway’s AI extproc extension. 2. Extend the AI extensions extproc server with OpenTelemetry tracing. 3. Create end-to-end (e2e) tests to validate configuration and trace propagation. 4. Write documentation for plugin developers and end users.....

Abstract: This proposal outlines a plan to enhance Meshery's relationship evaluation capabilities by implementing client-side policy evaluation using WebAssembly. By integrating OPA's WebAssembly compilation capabilities into Meshery's UI, I aim to enable real-time evaluation of complex Rego policies, providing users with immediate feedback on configuration changes and policy compliance. This enhancement will significantly improve the user experience when designing their designs and will make the policy evaluation distributed hence reducing load on a meshery server Problem Statement Meshery currently doesn't support evaluating policies in real-time on the client side. The existing approach ( relying on the rest api interface exposed by meshery-server) introduce s latency when policy evaluation occurs server-side, limiting the responsiveness of the UI when users make configuration changes. Additionally, as policies become more complex and numerous, the ability to quickly validate configurations against these policies becomes increasingly important for a smooth user experience. Proposed Solution: Use opas capibilty to compile rego policies directly into wasm plans and then integrate the evaluation process in ui using OPA's JavaScript SDK, which provides a simpler way to load and evaluate Rego policies compiled to WebAssembly. This approach is more lightweight and performant . Deliverables : - Real time evaluation of policies in ui - Keeping the support for both targets of evaluation backend or realtime on frontend - Making the evaluation responsive and performant by implementing webworkers , caching

Neural networks are descendants of McCulloch & Pitts' threshold-based mathematical model of a binary neuron, but there is ample evidence that unicellular organisms are capable of relatively complex maze navigation and other cognitive tasks, indicating information-processing capabilities in cellular subsystems. The task is to develop a computational model of elementary processing of analog information using Schrödinger's wave equation and Pilot Wave theory, leveraging the fact that a quantum wave function has multiple valid solutions and only one of them manifests. In Bohm & Hiley's elaboration of Pilot Wave theory, the Quantum Hamilton-Jacobi Equation can be decomposed into a classical component and a quantum component, the quantum potential. Most of the energy is in the classical component, but a small part of it is in the quantum potential. As the energy in the quantum potential is informed by and responds to the shape of the quantum wave, the process creates new information, expressed in the trajectory of the particle. The trajectory will help us take decisions. We propose two techniques, Statistical approach and Instantaneous approach. Both of the approaches use Pilot Wave theory since it is causal. For Statistical approach we will model the double slit experiment with Bohmian mechanics. The slits shape will depend on the input. We will pass many particles through the slit and take decision based on the interference pattern produced and the trajectory of the particles. In the second approach we will model the FMO complex in Green Sulphur Bacteria. Our model of the FMO complex will be used for Binary classification. There will be multiple slits in this and we will use AI to find the dimensions and location of the slits. Based on the trajectory we will take decision.

I am writing to express my interest in contributing to GitLab's Pajamas Migration project as part of the Google Summer of Code program. As a computer science student at South Asia University, I am eager to gain more experience in the open-source community, and I believe that contributing to Pajamas Migration would be an excellent opportunity to do so. In Pajama Migration We have to ensure that all of the frontend components we use are GitLab-UI components, there are still some pages that are not using the right components. I am already Involved with Gitlab through MLH Fellowship and am working with the Foundation Team under the mentorship of our maintainer (James Rushford). James was a really great leader and mentor. I have worked on the following issue so far 112392, and 115432, and right now I am working on Pajamas Migration with our maintainer(James) on issues #395782 and #396775. my Deliverables will include~ : Complete Pajamas migrations. : Build out the design system. : improve user experience My plan~ May 4 - May 30: read project-related documents and codes, and get started quickly. May 30 - July 5: reasonably divide the work with another contributor, and record the corresponding documents at the same time. july 5 - august 21: will continue work on our plans and will try to complete our mission and also will get feedback from the mentor. my previous experience at MLH with Gitlab was incredible. I gained valuable technical and soft skills, and I had the opportunity to work on real-world projects with experienced developers. Working with Gitlab helped me gain a better understanding of DevOps.So, I am looking forward work with GitLab again. I am looking forward to hearing back from you and learning more about how I can get involved in this project in your way. Maybe by giving more details? Knowing the Scope. Thank you for considering my application.

OGC SensorThings API is an international standard to eliminate vendor lock-ins in IoT systems and to create an open geospatial ecosystem by defining a standard data model and describe how to retrieve the ingested data. However, the standard by itself does not specify a way to physically store the data. Most of the current server implementations are all based on Postgres databases using the PostGIS extension. Unfortunately, relational databases are not a great choice to store large volumes of data, which is often the case with IoT applications. As a result, retrieving large volumes of data from any of the open source SensorThings API servers is painfully slow. Modern data lakehouse standards and cloud-native geospatial file formats offer a scalable, modular, cost-effective and a much faster way to store and work with large volumes of geospatial data on the web. Specifically, Apache Iceberg is an open table format for organizing data lakes in object stores and ensuring ACID guarantees. GeoParquet is a cloud-native geospatial file encoding, based on a columnar data storage format for tabular data that significantly compresses the data and improves querying efficiency. A cloud native SensorThings API extension using Apache Iceberg could significantly enhance the standard's ability to ingest and aggregate large heterogeneous streams of sensor data. The proposal hence puts forth a design architecture for any SensorThings API server to use Iceberg to store and retrieve sensor data in a more efficient manner reducing memory overhead and network latencies when retrieving such data over the web. Eventually, as GeoParquet gets merged into Iceberg, the implementation will support a much faster alternative to existing SensorThings API implementations for handling sensor data at scale.

The KomMonitor web client, a tool for geospatial data monitoring in urban planning, is currently based on AngularJS and requires a complete migration to the modern Angular framework to improve maintainability, scalability, and ease future contributions. While migration started previously, significant parts remain in AngularJS, and foundational issues like specific AngularJS patterns ($rootScope, $compile) and JavaScript files hinder the direct use of standard upgrade tools.   Solution: This project aims to fully migrate the KomMonitor web client from AngularJS to Angular. The approach involves:   1. Addressing the foundational roadblocks identified by analysis tools (e.g., refactoring $rootScope usage, eliminating $compile, converting JavaScript to TypeScript).   2. Incrementally migrating remaining AngularJS components and services to Angular, leveraging ngUpgrade within a hybrid architecture during the transition.   3. Implementing modern Angular best practices, including modular architecture, dependency injection, and potentially lazy loading.   4. Refactoring components using design patterns like Observer (RxJS), Facade, and Container-Presenter to improve structure and data handling.   5. Ensuring UI consistency using ng-bootstrap.   6. Establishing a robust testing strategy encompassing unit, integration, and end-to-end tests using frameworks like Jest and Cypress.   Deliverables: 1. A fully migrated KomMonitor web client codebase, transitioned from AngularJS to Angular.   2. Resolution of key AngularJS patterns ($rootScope, $compile) and conversion of necessary JavaScript files to TypeScript.   3. Migrated and optimized components/services adhering to modern Angular standards and design patterns.   4. A comprehensive test suite ensuring application stability and functionality post-migration.   5. Updated documentation reflecting the migrated codebase.   6. Final project code, documentation, and evaluation report.

This project aims to make Liquid Galaxy easier to use by building a system that can automate content creation and control the screens using simple natural language commands. Currently, users need technical knowledge to create KML files, manage content, and operate the system, which makes it difficult for beginners. To solve this, I will build an AI server that runs on a Single Board Computer and acts as an assistant for Liquid Galaxy. Users will be able to give commands using chat or voice, and the system will handle tasks like generating KML visualizations, sending content to the screens, and controlling the setup. The system will be modular, so different features (like visualization, control, and communication) can be added or improved easily. It will also support both local processing and external services depending on what works best with the available hardware. This server will live on the same LAN as the liquid galaxy rig. The main deliverables include: A working AI agent server running on a Single Board Computer Chat and voice interfaces for user interaction, external services like telegram, discord, etc will also be supported. A media pipeline to generate and send KML, images, and other content to Liquid Galaxy A content builder for creating simple apps, and interactive outputs Real-time data visualization from open data sources (aircraft, satellites, disasters, etc.) Automated storytelling and guided tours based on user input (eg- historical events) News and event-based visualization on the globe A knowledge assistant using Liquid Galaxy documentation An interactive troubleshooting system for diagnosing and fixing issues User friendly instructions via .md files, to help new developers get started Agent personality customization Complete documentation, deployment scripts, and setup guides The final result will be a simple, flexible, and easy to use system that helps users and contributors interact with Liquid Galaxy.

<p>This mentorship focuses on improving the usability, maintainability, and contributor experience of Hyperledger Cacti. Following the merger of Hyperledger Cactus and Weaver, the codebase and architecture have grown complex, with fragmented documentation and legacy components that hinder onboarding and long-term sustainability.</p><p><br></p><p>The project targets the ongoing Cacti Cleanup Initiative, aiming to simplify architecture, remove deprecated modules, improve security, and create high-quality documentation. The mentee will audit and restructure developer and user documentation, align docs with the evolving architecture, identify outdated components for removal, and improve onboarding guides and contribution workflows.</p><p><br></p><p>Implementation will follow an iterative process: reviewing GitHub issues and cleanup boards, proposing improvements, implementing updates to documentation and selected code areas, and validating improvements with maintainers. The outcome will be a streamlined, well-documented Cacti framework that lowers entry barriers for contributors and strengthens the project’s long-term sustainability.</p><p><br></p><h3>Learning Objectives</h3><ul><li>Understand cross-chain architectures and pluggable DLT frameworks</li><li>Gain experience contributing to a large open-source project under the LF Decentralized Trust ecosystem</li><li>Learn best practices for technical documentation, developer experience, and onboarding design</li><li>Develop skills in codebase refactoring, modularization, and security-driven cleanup</li><li>Collaborate with an international open-source community using GitHub, CI/CD pipelines, and review workflows</li></ul><h3>Expected Outcome and Deliverables</h3><ul><li>A restructured and standardized documentation suite (developer, user, and architecture docs)</li><li>Cleanup contributions removing deprecated or low-value components and simplifying modules</li><li>Improved onboarding guides, tutorials, and contributor documentation</li><li>CI/CD improvements reducing pipeline runtime and complexity (where applicable)</li><li>A final report summarizing changes, impact, and recommendations for future improvements</li></ul><p><br></p><p>Lean more at <a href="https://github.com/LF-Decentralized-Trust-Mentorships/mentorship-program/issues/62" rel="noopener noreferrer" target="_blank">https://github.com/LF-Decentralized-Trust-Mentorships/mentorship-program/issues/62</a></p>

<p>This connector will create an interface between the Apache Web Server to the libModSecurity. By creating this connector, the target application will be able to apply ModSecurity inspections and actions on Apache Web Server.</p>

CoreDNS is a cloud native, authoritative DNS server written in Go. It provides dynamic service discovery backed by different data sources, including etcd and Kubernetes. It serves as a simple, flexible DNS server in both cloud-native and traditional environments.

<p>Improve current functionality of the OwnMailbox personal email server, implement support for a GPG Key Server and HSTS. Furthermore, thoroughly document the whole process, ensure the stability of the code and gain valuable knowledge on linux, cryptography and scripting.</p>

<p>The main goal of the project is to investigate how Google Cardboard can be used and integrated with MIT App Inventor, then - create some predefined components (use-cases). In addition to research, activities will also include improving Android components - ListView and Menu</p>

Universal Network Objects (UNO) serves as the component model within LibreOffice. It enables users to interact with UNO components through various programming languages that have corresponding language bindings. The deliverable of this project is to develop language bindings specifically tailored for the lightweight scripting language LUA.

<p>The creation of a telemetry system, which allows you to better understand what users of Krita are using. That is something similar to clickstream analytics for sites. It is supposed to create: a client part, a backend server, a front-end server. The collection of statistics will help improve future development.</p>