Explore Projects

The pyaslreport package currently has no automated tests for its core processing logic and no CI pipeline that runs on code changes, meaning regressions in validation behavior, parameter extraction, or report generation can go undetected until a user encounters them in a real research context. This project will build a meaningful automated test suite around the real architecture of the package and integrate it into a GitHub Actions CI workflow. The suite has two layers: an example-based integration runner that accepts a directory of input and expected output pairs and verifies the tool produces correct results for each one, and focused unit tests covering the internal normalization pipeline, schema-driven validators, M0 and TSV validation branches, file grouping logic, and sequence factory dispatch. Adding a new test case to the integration layer requires no code changes, only a new subfolder with the right files. The same runner works locally against any directory of examples and in CI against a smaller committed set, which is exactly the design Jan described in his feedback. Deliverables: an expanded test suite for pyaslreport, a committed example set covering clean, warning, error, and major error cases, a GitHub Actions workflow with coverage reporting, and a contributor guide explaining how to run and extend the tests.

ArviZ is a Python library for the exploratory analysis of Bayesian inference models. It is currently undergoing a major refactor into a modular structure comprising three sub-packages: arviz-base, arviz-stats, and arviz-plots. This refactoring brings changes to both the API and the internal implementation, with most of the design decisions already in place. The primary task that remains is migrating and reimplementing existing features from legacy ArviZ into the new structure. This project focuses on achieving feature parity in arviz-plots by reintroducing essential visualization tools from the original ArviZ while also enhancing them with new capabilities. These include plots for MCSE, t-statistics, parallel coordinates, quantile dot plots, support for circular variables in trace plots and rank distribution plots, among others. Additionally, new features such as a dark theme and improved rank plots with better envelopes for multiple sample comparisons will be incorporated. The goal is to implement and rigorously test these plotting functions, which are critical for model comparison, criticism, and sampling diagnostics. By ensuring that arviz-plots matches and improves upon the original functionality, this project will enhance the usability, maintainability, and extensibility of ArviZ. Ultimately, it will help strengthen ArviZ’s position as a go-to library for Bayesian model visualization and diagnostics.

This project implements five concrete improvements to animint2 across the R compiler, animint.js renderer, and CI pipeline. First, polygon holes via geom_polygon(aes(subgroup)) — the JS renderer will use D3's d3.geo.path.projection(null) with fill-rule: evenodd to correctly draw multi-ring SVG paths instead of silently garbling them. Second, the CI race condition where R_coverage and JS_coverage share a hardcoded GitHub repo name will be fixed by deriving a unique repo name per job from the existing TEST_SUITE variable. Third, the inner apply() kernel of getCommonChunk() moves to C++ via Rcpp — benchmarks show 28x speedup for numeric columns and 32.5x for character columns. Fourth, scale range calculation moves from the R compiler to the JavaScript renderer — computed at click-time from visible data only, eliminating exponential blowup in plot.json. Fifth, stats and positions (stat_bin, position_stack, position_dodge) will be computed in JavaScript after showSelected is applied — fixing the silent breakage in geom_histogram and grouped bar charts. All features include renderer tests, documentation, and wiki updates. The RJSONIO → jsonlite migration will also be completed to remove a deprecated CRAN dependency.

Apache SkyWalking BanyanDB currently supports only local file systems through the remote.FS interface, which limits its flexibility in cloud-native environments. This project aims to extend remote.FS by implementing support for major object storage services including AWS S3, Google Cloud Storage, and Azure Blob Storage. Each backend will fully comply with the remote.FS interface to ensure seamless integration. The implementation will include cloud-specific optimizations such as multipart uploads, resumable downloads, and SHA-256 checksum validation to ensure data integrity. Additionally, the system will handle rate limiting, transient errors, and support configurable retry strategies. The project will also include a unified error mapping layer and Prometheus-based monitoring metrics. Deliverables: • Production-ready remote.FS implementations for AWS S3, GCS, and Azure Blob Storage. • Unit and integration tests using tools like GoMock and LocalStack. • Logging and observability features with structured logs and Prometheus metrics. • Complete documentation and setup guides. • Community demo and contribution-ready pull requests. This enhancement will enable seamless and secure cloud deployments of BanyanDB, significantly reducing operational complexity while improving scalability and reliability.

Meshery is the open-source cloud native manager that empowers platform engineers to design and operate infrastructure. As infrastructure complexity grows, the need for intelligent assistance becomes critical. This project focuses on developing and enhancing a dedicated AI Adapter and AI Connections for Meshery. This adapter serves as the bridge between Meshery’s core orchestration engine and various Large Language Models (LLMs). The goal is to enable "Natural Language to Infrastructure" capabilities, allowing users to describe their architectural intent (e.g., "Deploy a highly available Kubernetes cluster on AWS with Prometheus monitoring") and have Meshery auto-generate the visual topology and configuration manifests. The intern will work on decoupling the AI logic from the core platform, allowing users to "Bring Your Own Model" (BYOM)—supporting both cloud-based providers (OpenAI, Anthropic) and local inference runners (Ollama, LocalAI). Expected Outcome: 1. A fully functional AI Adapter (or Connection) integrated into the Meshery ecosystem. 2. Demonstrable capability for users to swap between at least two different LLM providers (e.g., OpenAI vs. a local Llama 3 model). 3. Implementation of a feature where natural language queries result in a rendered design. 4. Merged pull requests (PRs) including code, tests, and documentation.

<p>R provides two types of regular expressions in <code>base</code> package, extended regular expressions (the default) with TRE and Perl-like regular expressions used by <code>perl = TRUE</code> with PCRE.</p> <p>PCRE includes useful features, such as named capture, but it uses a backtracking algorithm, so it is easy to take exponential time or arbitrary stack depth for certain regular expressions. Using PCRE in the service backend would have left it open to easy denial of service attacks.</p> <p>TRE has a polynomial time complexity but does not include named capture.</p> <p><code>stringi</code> is a R package use the regular expression engine from the ICU library, which has an exponential time complexity. The <code>stringi</code> package does not support named capture yet because it is still considered as experimental in ICU.</p> <p>RE2 is a primarily DFA based regular expression engine from Google that is fast at matching large amounts of text with named capture. Users can build fast and scalable service backend with RE2 library.</p> <p>This project will create an R package interface to the RE2 library, providing the R community with the first regular expression package with both named capture and polynomial time complexity.</p>

With the help of JavaScript and HTML5/CSS, 1. Maintain musicblocks v3 issues Detailed discussion on all the existing features, issues and other resources of music blocks with the mentors, strategize and prioritize maintenance work accordingly and deliver a reasonably robust version. 2. Resolve issues of browser changes i.e. Planet's cross origin errors By reading the updates on chromium versions (Browser Security) there are a lot of websites facing issues to cop-up. However, it can be easily solved by the help of tutorials , brainstorming and better characterization of code. 3. Better characterize some music utils code to resolve the regression No regressions will be found by the end of the project in any music utils code. Pulling the latest bits of tone.js file in the repository will ensure that the problem is solved. 4. Update the documentation The document too needs updating to the latest versions of code changes , my experience of writing scientific research journals will ensure a finalized documentation by the end of the my term. 5. Add feature enhancement and solve other issues with musicblocks version 3. During the period of gsoc there are many possibilities of new a idea implementation or any unknown error detection during the continuous process of discussion and evaluation with mentor. In such cases , I am ready to work on that as my project size is medium and I am ready to give extra hours to ensure completion of the project while ensuring it's quality.

ImageLab is a block-based image processing tool built with Blockly and OpenCV . It helps students learn image processing by building pipelines with visual blocks. Problem statement: This project has the following key issues: This project will implement "Interactive Learning Mode" transforming ImageLab into a transparent, collaborative, and scalable learning ecosystem. First, per-step processing that returns intermediate image outputs after every operator, displayed in a scrollable filmstrip timeline so students can see the output after each step and what each step is contributing for the final output. Second, an image analysis panel showing RGB histograms and metadata for any selected step. Third, pipeline persistence allowing students to save, load, version, and share pipelines using secure share tokens. Fourth, a batch processing engine to run one pipeline across multiple images concurrently with progress tracking and ZIP download. Fifth, custom composite operators (macros) that let students save reusable block sub-chains into the Blockly toolbox. Deliverables: A production-ready fully tested interactive step viewer, image analysis panel with Canvas-based histogram renderer, SQLModel backed pipeline persistence with HMAC share tokens, asyncio batch processing engine, and a macro system with DAG validation and Blockly toolbox injection.

The healthcare system in Pakistan, particularly in rural areas, faces significant challenges due to limited access to medical facilities and high costs of conventional diagnostic equipment. These constraints leave a large portion of the population underserved, with limited access to timely and reliable healthcare. This project aims to address these gaps by providing a low-cost, portable healthcare solution powered by energy-efficient Edge-AI. By leveraging advancements in RISC-V technology, the proposed solution can revolutionize healthcare delivery in underprivileged areas, ensuring affordable and accessible diagnostics for all. The project, Healthcare-Centric Edge-AI Development on RVMCU Architecture, builds upon the RVMCU, a RISC-V microcontroller designed during the Linux Foundation's Spring 2024 LFX Mentorship Program. The RVMCU, which is compliant with the RV32IMC_Zba_Zbb_Zicsr_Zifencei specifications, was developed as an ultra-low-power, versatile SoC. This proposal seeks to extend that foundational work to enable healthcare-centric applications, specifically targeting wearable and portable devices. The enhanced RVMCU architecture will support diverse healthcare sensors (e.g., cough monitors, heartbeat detectors, ECG sensors) and provide real-time AI-powered analytics. The emphasis will be on achieving energy efficiency, modularity in hardware and firmware design, and seamless integration with AI frameworks optimized for edge computing.

Performance research/design of RISC-V CPU designs require workloads for analysis. Workloads can be custom user applications or industry benchmarks such as SPEC, GeekBench, Dhrystone, etc. Using tools like the RVI Olympia Perf CPU Model users can pinpoint bottlenecks in CPU design, the workload, or the compilers/libraries. When the workload is small, running the workload on Olympia is not complex: trace the workload using a functional model and run that trace through Olympia; count cycles. However, if the workload is large, tracing the entire workload is not practical. Workload reduction tools, such as SimPoint, help narrow down the points of interest (POI) as well as reduce the instruction length to calculate estimated performance. The flow using SimPoint: Workload -> SimPoint analysis (using tools like QEMU) -> workload fragments -> trace generation. Each trace can be run in parallel on Olympia to gather the point performance. Post-processing tools will collate the fragments and generate an overall estimate of performance. This internship will: * Establish workloads (research) * Establish a SimPoint flow to reduce the workloads (QEMU or other instruction set simulators) * Generate STF traces using SimPoint data (QEMU or other instruction set simulators) * Create a repository of traces and their metadata, such as compiler info * Tools to run traces on Olympia and generate perf data (python, C++)

The current reuse workflow in FOSSology provides a powerful mechanism to copy license clearing decisions from a previously analyzed upload to a newer version. However, this process remains largely mechanical and opaque, offering little insight into what has changed between versions after reuse is applied. As a result, users must manually inspect differences to understand the impact of reuse, which becomes increasingly difficult for large codebases and frequent updates. To address this limitation, this project proposes the development of an Enhanced Reuser Agent that adds an intelligent analysis layer on top of the existing reuse workflow. The agent runs automatically after scanners complete and reuse decisions are applied, comparing the previously cleared upload (v1) with the new upload (v2). It generates insights such as a diff-aware file tree, license comparison, aggregated statistics, and a risk-level summary. In addition, a Smart Reuse (Suggested Matches) mechanism automatically identifies and recommends similar previously-cleared uploads, reducing the manual effort required to search for suitable reuse candidates. By providing a clear and interactive view of structural and license-level changes, along with proactive reuse suggestions, the system enables users to better understand the outcome of reuse and efficiently refine decisions where needed. This transforms reuse into a more transparent and insight-driven process, reducing manual effort and improving overall usability while remaining fully compatible with the existing FOSSology workflow.

The goal of this project is to add CAN Framework and DCAN peripheral support for BeagleBone Black System on Chip in RTEMS. CAN protocol is a robust, reliable and multi-master serial communication protocol used to achieve real-time message transfer between devices within the CAN network. RTEMS being a real-time operating system, CAN peripheral support would increase the potential to meet real-time demands. BBB has two CAN 2.0 A, B (ISO 11898-1) controllers with 1 Mbps data transfer rate and DMA support. It also has inbuilt RAM which can hold 64 CAN messages. There is a loopback support also, which can be used for debugging purposes. By adding driver support for CAN modules, will enable the use of this potential hardware. With the help of the Am335x reference manual, TI’s starterware firmware and CAN specification I could understand the initialization and working of the CAN module. With the help of existing RTEMS supported CAN drivers I could understand the CAN framework and develop the support for CAN modules for BBB in RTEMS. I chose this project because I started learning embedded systems from BeagleBone Black and developed firmware from scratch with few peripherals and shell support https://github.com/slpp95prashanth/Beaglebone-mBootloader/tree/cpsw. As SoC and RTEMS are open source computing platforms, I would like to contribute to this project and learn more about RTEMS operating systems.

<p>Krkn-AI's [discover command](https://krkn-chaos.dev/docs/krkn_ai/discover/) connects to a Kubernetes/OpenShift cluster and generates a static configuration file by enumerating cluster components (namespaces, pods, services, PVCs, nodes). While useful, the generated config still requires significant manual work before it can actually be used. Health check URLs are commented-out placeholders, the fitness function defaults to a single hardcoded PromQL query, and scenario selection is static regardless of what exists in the cluster. This issue proposes enhancing discover to produce a dynamic, cluster-aware configuration that is closer to runnable out-of-the-box. By inspecting routes, ingresses, services, and available Prometheus metrics during discovery, we can auto-populate health check URLs, suggest relevant fitness function queries scoped to discovered namespaces, and intelligently enable only the scenarios that apply to the discovered infrastructure.</p><p><br></p><p>Expected Outcome:&nbsp;</p><p>&nbsp;- Auto-discover OpenShift Routes, Kubernetes Ingresses, and Services to populate health check URLs in the generated configuration.</p><p>&nbsp;- Query Prometheus for available metrics to suggest namespace-scoped fitness function queries instead of hardcoded defaults.</p><p>&nbsp;- Intelligently enable chaos scenarios based on discovered cluster components (e.g., PVC, VMI, network interfaces).</p><p><br></p>

The mediapipe-rs project provides a Rust SDK to support mediapipe AI models. The SDK provides utility functions to pre-process application data (such as images, audio and video) into TFLite / PyTorch formats, and convert the inference results back into application data. In order to accomplish this, the [mediapipe-rs](https://github.com/WasmEdge/mediapipe-rs) project has made extensive use of the [ffmpeg](https://www.ffmpeg.org/) library. It [compiles ffmpeg to Wasm](https://github.com/WasmEdge/mediapipe-rs/blob/main/src/build.rs) and then builds it together with the application binary. However, the issue with this approach is that those Wasm-compiled ffmpeg functions are slow. We believe a better approach is to create a ffmpeg plugin for WasmEdge, and allow Wasm applications to call native ffmpeg functions as host functions. - Expected Outcome: - The deliverables will be - A WasmEdge plugin for ffmpeg that is similar to the [WasmEdge OpenCV-mini plugin](https://github.com/WasmEdge/WasmEdge/tree/master/plugins/wasmedge_opencvmini). That is to re-export ffmpeg functions in C style as plugin functions as covered in the [plugin developer guide](https://wasmedge.org/docs/category/wasmedge-plugin-system). - A Rust SDK for Wasm programs to access ffmpeg functions in the plugin. Similar to the [WasmEdge OpenCV-mini SDK](https://github.com/second-state/opencvmini) - Refactor the mediapipe-rs project to use the ffmpeg plugin

For simulating a system that contains many variables and/or equations, traditionally computational engineers tend to focus on utilizing an appropriate method with realistic time and space complexity. The technique of model order reduction (MOR), however, aims at approximating the original model with reduced number of variables and/or equations and still keeping sufficient accuracy. MOR is especially useful in various industries, for example thermal-fluids engineering, micro-electro-mechanical systems and control, where large-scale simulations have to be performed. The methods of model order reduction can be classified into several classes including proper orthogonal decomposition, reduced basis, balanced truncation, etc. Several MOR libraries have been well developed in MATLAB and Python. For instance, pyMOR is a Python library that relies on the application of reduced basis methods to parameterized partial differential equations. MATLAB's model reducer supports pole-zero simplification, balanced truncation mode selection methods and so on. In Julia, the main package that enables symbolic modeling is ModelingToolkit.jl, whose key features consist of automatic transformation and structural simplification, but it needs further works on fast ML approximate transformations. So this project is targeted on implementing MOR methods as extended features for ModelingToolkit.jl. Besides implementation of methods of model order reduction, the expected deliverables will include documentation which shows both the improved simulation time and accuracy penalty for the application of different MOR methods on test problems from various disciplines.

CAR T-cell therapy is a form of cancer immunotherapy that engineers a patient’s T cells to recognize and eliminate malignant cells. Although highly effective in leukemias and other hematological cancers, this therapy faces significant challenges in solid tumors due to the complex and heterogeneous tumor microenvironment. CARTopiaX is an advanced agent-based model developed to address this challenge, using the mathematical framework proposed in the Nature paper “In silico study of heterogeneous tumour-derived organoid response to CAR T-cell therapy,” successfully replicating its core results. Built on BioDynaMo, a high-performance, open-source platform for large-scale and modular biological modeling, CARTopiaX enables detailed exploration of complex biological interactions, hypothesis testing, and data-driven discovery within solid tumor microenvironments. The project achieved major milestones, including simulations that run more than twice as fast as previous model, allowing rapid scenario exploration and robust hypothesis validation; high-quality, well-structured, and maintainable C++ code developed following modern software engineering principles; and a scalable, modular, and extensible architecture that fosters collaboration, customization, and the continuous evolution of an open-source ecosystem. Altogether, this work represents a meaningful advancement in computational biology, providing researchers with a powerful tool to investigate CAR T-cell dynamics in solid tumor and accelerating scientific discovery while reducing the time and cost associated with experimental wet-lab research.

The Problem General-purpose Automatic Speech Recognition (ASR) often fails language researchers and learners because it is designed to "clean up" speech. In second-language learner data, it is critical to capture exact production, including disfluencies, attempts at pronunciation, and interjections. Current models often struggle to segment these recordings correctly or erroneously "fix" a student's grammatical and phonological errors. The Solution My proposal implements a robust, three-phase automated pipeline: - Pre-processing: I will implement noise reduction using tools like noisereduce or DeepFilterNet and utilize industry-standard VAD (Voice Activity Detection) such as Silero VAD or Pyannote.audio to segment audio into single-sentence blocks. - Transcription: Using high-fidelity models like faster-whisper, the system will capture all vocalizations with word-level timestamps. This phase focuses on preserving the learner's actual speech patterns rather than idealized grammar. - Post-processing: The pipeline will identify pauses, match transcriptions to target sentences, and use Large Language Models (LLMs) with Constrained Prompting. This allows the system to distinguish between intelligible learner errors (to be preserved) and actual [gibberish] (to be flagged). Key Deliverables - Python-based CLI Tool: An efficient command-line interface capable of transcribing raw MP3 files. - High Accuracy: A system designed to achieve >90% agreement with human transcribers. - Structured Output: Final results formatted as an Excel sheet for easy analysis by researchers and learners.

Executive Summary: Create a Comprehensive FHIR facade Layer For OpenELIS Global. The Challenge: The Synchronization Gap The current architecture utilizes a HAPI FHIR JPA "Sidecar" which functions as a secondary, disconnected data store. This results in: Data Latency: Clinical data is trapped in a "sync queue," delaying real-time care coordination. State Drift: Risks of "Split-Brain" where the LIS database and FHIR store disagree on patient records. Resource Waste: Redundant storage of the same data in two different PostgreSQL schemas, increasing infrastructure costs by ~40%. The Solution: Real-Time Native Facade I propose a Native FHIR Facade embedded directly within the OpenELIS Spring context. This transforms OpenELIS into a FHIR-native server without the need for a secondary database. Core Innovations: HAPI Plain Server Integration: Swapping the heavy JPA engine for a lightweight RESTful controller. Live Resource Mapping: A FhirTransformService that maps OpenELIS Domain Objects (Java 21 Records) to FHIR Resources on-the-fly. Atomic Transactions: FHIR writes (POST/PUT) share the same @Transactional context as the LIS, ensuring 100% data integrity. Technical Implementation Stack Language: Java 21 (leveraging Pattern Matching for cleaner transformation logic). Engine: HAPI FHIR (Plain Server Library). Mapping: Manual POJO transformation or MapStruct for high-performance throughput. Validation: Native HAPI FhirValidator to ensure compliance with regional Implementation Guides (IGs).

The project aims to enhance the cBioPortal platform by generating a list of recommended default genes for each OncoTree code, which are often used for molecular classification of specific cancer subtypes. This will improve the effectiveness of the cBioPortal database by prioritizing the display of relevant genes to each disease subtype. To achieve this goal, a Large Language Model (LLM) such as GPT-4o, will be fine-tuned with prompt engineering and Retrieval-Augmented Generation (RAG) techniques to provide domain-specific knowledge and context. The goal is to train the LLM to connect relevant genes to each OncoTree code. Approach: LLM Selection: GPT-4o is a strong candidate due to its versatility and performance in various NLP tasks. Prompt Engineering: Develop efficient prompts for the selected LLM to generate gene lists. RAG Component: Implement a RAG component to provide context to the LLM and enhance accuracy using e-utilities to retrieve curated literature from NCBI GeneReviews and ClinVar. Validation: Cross-reference the generated gene lists with expert-curated resources like ClinGen and variant frequencies in cBioPortal, and COSMIC. Evaluation: Continuously monitor the model's performance using validation sets and adjust hyperparameters as needed. Deployment: Integrate the solution into the cBioPortal platform such as sorting variants on patient view pages by relevant genes first. Conclusion: Completion of this project will significantly improve the usability of cBioPortal, providing users like researchers and clinicians with relevant gene and pathway information based on the cancer type they are exploring.

Currently, two major languages are used in high-energy physics (HEP): C++ for numerically intensive code, where execution speed is critical, and Python for interactivity and simplicity of development (frequently used as 'glue' between high-performance code modules). Julia has recently sparked increased attention as a potential language for HEP. This could provide Python's convenient features while maintaining C++'s ideal computational efficiency. In order to continue this investigation, this project will interface the data model library PODIO with Julia. This will allow you to read existing data files into a Julia program. This project seeks to use the same YAML-syntax to auto-generate Julia code for the end user to be utilized in HEP, as well as to do performance testing to compare the language interfaces for C++ and Julia. General Plan PODIO can already : Read YAML files and validate and parse them to extract necessary information like data members, relations and vector members of components and form MemberVariable objects from that information, forming a object dictionary to be used by the jinja2 template engine (using templates for C++) to generate C++ code. Our Plan: Build a prototype without code generation to test whether the current info passed to the jinja2 template Engine by the ClassGenerator class is sufficient, Accordingly adding the pre-processing logic required to the ClassGenerator class create new templates and dictionaries for jinja2 to generate Julia code. Running tests on the Julia code and refactoring generator code. Benchmarking and Documentation.

The project aims to enhance the open-source ticketing system Trudesk by integrating critical accessibility features and advanced functionalities. The primary goal is to make Trudesk more inclusive and efficient for all users, including those with disabilities. The main problems addressed are: 1. Lack of accessibility in existing ticketing systems, making them difficult to use for people with disabilities. 2. Inefficient ticket management due to manual tagging and sorting processes. 3. Absence of community support features like public forums. 4. Inflexibility to cater to organization-specific needs. To solve these problems, the project proposes the following solutions: 1. Accessibility Enhancements: Optimize Trudesk for screen readers and assistive technologies, ensuring full accessibility for users with disabilities. 2. Advanced Functionalities: Implement auto-tagging, auto-categorization, and voice input capabilities to streamline ticket management. 3. Public Forums Integration: Create public forums within Trudesk, enabling users to collaborate and share knowledge. 4. Organization-Specific Enhancements: Develop automatic documentation suggestions and customizable knowledge bases tailored to frequent queries. The key deliverables of the project include: - Accessibility patches for Trudesk to ensure compliance with accessibility standards. - Public question polling interface and public forums for community engagement. - Efficient question searching, answer polling, and thread merging features. - Knowledge base creation and FAQ generation based on user queries. - Document suggestion system and voice-based query creation (stretch goal). - Integration of private ticket tracking and public forums. - Comprehensive testing and documentation.

Data is the new big thing for search engines in today’s time but it can be difficult for web crawlers to effectively interpret the context of the data. To deliver better search results, web crawlers need to have a context of the data and to understand the data better, structured data is used. Structured data is the data which conforms to a data model, has a well defined structure, follows a consistent order and can be easily accessed and used by a person or a computer program. It is used by search engines to generate rich snippets, which are small pieces of information that will then appear in search results making the search results more relevant. Currently Joomla! has rich snippets implemented but it uses inline microdata to implement rich snippets which is difficult to modify from the backend as it is hard coded into the html. With this project I’ll be working on to making it easier for the user to dynamically integrate structured data from the backend. For the dynamic integration of structured data I’ll be using schema.org which provides a universally recognized format for structuring data on the Web. There are different ways to implement schema markup but for this project I’ll be using JSON-LD as it can be inserted into the web page without disrupting other contents or HTML and it is easy to store in the database. This project will help user to add, update or delete schema markup on the articles from the backend. It will give user an option to select the type of schema from the available schema types and then insert values for the attributes of schema properties in the form. Some useful data which is already present in other forms will be fetched using AJAX Interface and it will be directly inserted into the JSON object. After saving the article, the generated schema will be pushed into the head element of the page.

Building modern Text User Interfaces (TUIs) often forces developers to choose between writing complex, low-level terminal sequence code or adopting restrictive, framework-specific solutions. This project addresses this fragmentation by bringing the universally beloved, declarative Shoes GUI DSL (via the Scarpe project) to the terminal environment, allowing developers to build complex CLI applications intuitively. The proposed solution leverages a robust, dual-language architecture. The frontend consists of a pure-Ruby DSL where developers define UI layouts and business logic. The backend is a custom-built, high-performance Rust rendering engine responsible for flexbox-like layout calculations, double-buffered differential rendering, and non-blocking event polling. These two layers communicate seamlessly in real-time through a memory-safe C-FFI (Foreign Function Interface) bridge, ensuring the Ruby VM is never blocked by terminal I/O. By the end of the project, the clearly defined deliverables are: 1) A Universal Low-Level TUI C-API: A standalone Rust rendering engine exposing a clean C-ABI, making it usable not just by Ruby, but by any FFI-capable programming language. 2) The scarpe-tui Ruby Backend: A complete mapping of core Shoes elements (stack, flow, button, edit_line, styling, and clipping) to the terminal grid. 3) An Advanced Showcase Demo: A complex, asynchronous CLI application (inspired by "Claude Code") featuring scrollable histories and bidirectional data flow, proving the framework's readiness for real-world production use. 4) Comprehensive Documentation and Test Suites: Ensuring maintainability and easy community adoption.