chore: consolidate GSoC 2026 page cleanups and metadata fixes

aniruddhaadak80 · aniruddhaadak80 · commit 69afdaf7cbde · 2026-03-13T22:06:01.000+05:30
- Added missing epository and license keys to 2026 project pages (resolves formatting requirement from #1862). - Replaced instances of 'student' with 'participant' in proposals to align with modern GSoC terminology. - Fixed unquoted �lt attributes in _layouts/blog_post.html to generate valid HTML for multi-word author names. Closes #1862. Signed-off-by: Aniruddha Adak <aniruddhaadak80@users.noreply.github.com>
diff --git a/_gsocprojects/2026/project_CMS.md b/_gsocprojects/2026/project_CMS.md
@@ -2,6 +2,8 @@
 project: CMS
 layout: default
 logo: CMS-logo.png
+repository: https://github.com/cms-sw/cmssw
+license: Apache-2.0
 description: |
    [CMS](http://cms.cern/) is a high-energy physics experiment at the [Large Hadron Collider](http://home.web.cern.ch/topics/large-hadron-collider) (LHC) at [CERN](http://home.cern/).  It is a general-purpose detector that is designed to observe any new physics phenomena that the LHC might reveal. CMS acts as a giant, high-speed camera, taking 3D "photographs" of particle collisions from all directions up to 40 million times each second. The CMS collects few tens of Peta-Bytes of data each year and processes them through Worldwide LHC Computing Grid infrastructure around the globe.
 ---
diff --git a/_gsocprojects/2026/project_CernVM-FS.md b/_gsocprojects/2026/project_CernVM-FS.md
@@ -3,6 +3,8 @@ title: CernVM-FS
 project: CernVM-FS
 layout: default
 logo: cernvmfs-logo.png
+repository: https://github.com/cvmfs/cvmfs
+license: BSD-3-Clause
 description: |
   The CernVM-File System ([CVMFS](https://cernvm.cern.ch/fs/)) is a global, read-only POSIX filesystem that provides the universal namespace /cvmfs. It is based on content-addressable storage, Merkle trees, and HTTP data transport.  CernVM-FS provides a mission critical infrastructure to small and large HEP collaborations.
 ---
diff --git a/_gsocprojects/2026/project_Clad.md b/_gsocprojects/2026/project_Clad.md
@@ -2,6 +2,8 @@
 project: Clad
 layout: default
 logo: Clad-logo.png
+repository: https://github.com/vgvassilev/clad
+license: LGPL-3.0
 description: |
   [Clad](https://clad.readthedocs.io/en/latest/) enables 
   automatic differentiation (AD) for C++. It is based on LLVM compiler 
diff --git a/_gsocprojects/2026/project_FCC.md b/_gsocprojects/2026/project_FCC.md
@@ -3,6 +3,8 @@ title: Future Circular Collider
 project: FCC
 layout: default
 logo: fcc-logo.png
+repository: https://github.com/HEP-FCC/FCCAnalyses
+license: Apache-2.0
 description: |
   The [Future Circular Collider](https://fcc.cern/) (FCC) is a proposed
   next-generation particle accelerator at CERN for the post High Luminosity
diff --git a/_gsocprojects/2026/project_Key4hep.md b/_gsocprojects/2026/project_Key4hep.md
@@ -3,6 +3,8 @@ title: Key4hep
 project: Key4hep
 layout: default
 logo: key4hep-logo.png
+repository: https://github.com/key4hep/EDM4hep
+license: Apache-2.0
 description: >
   The [Key4hep](https://cern.ch/key4hep/) project provides an
   experiment-independent, turnkey software stack for future colliders such as
diff --git a/_gsocprojects/2026/project_NNPDF.md b/_gsocprojects/2026/project_NNPDF.md
@@ -3,6 +3,8 @@ title: NNPDF
 project: NNPDF
 layout: default
 logo: nnpdf.png
+repository: https://github.com/NNPDF/nnpdf
+license: GPL-3.0
 description: |
   The [NNPDF collaboration](https://nnpdf.mi.infn.it/) determines the structure of the proton using contemporary methods of artificial intelligence. A precise knowledge of the so-called Parton Distribution Functions (PDFs) of the proton, which describe their structure in terms of their quark and gluon constituents, is a crucial ingredient of the physics program of the Large Hadron Collider of CERN. The NNPDF projects includes tools for DGLAP evolution: [EKO](https://eko.readthedocs.io), grid interpolation: [PineAPPL](https://nnpdf.github.io/pineappl/), and the fitting framework [nnpdf](https://docs.nnpdf.science)
 ---
diff --git a/_gsocprojects/2026/project_Spack.md b/_gsocprojects/2026/project_Spack.md
@@ -2,6 +2,8 @@
 project: Spack
 layout: default
 logo: spack-logo-220-LLNL.png
+repository: https://github.com/spack/spack
+license: Apache-2.0
 description: |
   [Spack](https://spack.io) is a flexible package manager designed to support multiple versions, configurations, platforms, and compilers. It is widely used in high-performance computing (HPC) environments to manage complex software stacks.
 ---
diff --git a/_gsocproposals/2026/proposal_ATLAS_TILESIGNAL.md b/_gsocproposals/2026/proposal_ATLAS_TILESIGNAL.md
@@ -26,7 +26,7 @@ project_mentors:
 
 ATLAS will produce data at an unprecedented scale at the High-Luminosity LHC (HL-LHC). This project offers the opportunity to work on a real problem at the intersection of machine learning, real-time computing, and the experimental physics frontier, with direct relevance for the future ATLAS detector upgrade.
 
-The student will develop and evaluate deep-learning-based signal reconstruction methods for the ATLAS Tile Calorimeter (TileCal), comparing them with classical algorithms and exploring how to deploy efficient inference on modern hardware accelerators (GPU and/or FPGA-friendly models).
+The participant will develop and evaluate deep-learning-based signal reconstruction methods for the ATLAS Tile Calorimeter (TileCal), comparing them with classical algorithms and exploring how to deploy efficient inference on modern hardware accelerators (GPU and/or FPGA-friendly models).
 
 Recent studies indicate that AI-based reconstruction can be implemented on FPGAs and outperform classical methods in amplitude and timing estimation, especially in challenging pile-up regimes. However, for real deployment, models must satisfy strict constraints on:
 - latency (sub-microsecond scale, trigger-compatible),
diff --git a/_gsocproposals/2026/proposal_BioDynamo_CartopiaX.md b/_gsocproposals/2026/proposal_BioDynamo_CartopiaX.md
@@ -30,15 +30,15 @@ CartopiaX is an emerging simulation and modeling platform designed to support co
 
 CartopiaX aims to provide a flexible research environment that enables computational scientists and domain biologists to collaboratively design, execute, and analyze large-scale biological simulations. The platform combines high-performance C++ simulation kernels with user-friendly interfaces and scripting capabilities to enable rapid experimentation and reproducible research workflows. Currently, CartopiaX provides a performant core simulation engine but still requires improvements in usability, extensibility, and performance portability to support wider adoption in computational oncology and systems biology communities.
 
-This project invites contributors to explore improvements that help integrate, extend, and deploy CartopiaX for real-world research applications. Students are encouraged to propose approaches that enhance developer productivity, accessibility for domain scientists, and computational performance.
+This project invites contributors to explore improvements that help integrate, extend, and deploy CartopiaX for real-world research applications. participants are encouraged to propose approaches that enhance developer productivity, accessibility for domain scientists, and computational performance.
 
 ## Possible Directions
 
-* Easy integration - a possible direction focuses on improving the usability of CartopiaX by developing more intuitive ways for researchers to configure and run simulations. Currently, simulations rely heavily on static configuration files and parameter definitions. Students may explore designing graphical or web-based interfaces that allow researchers to interactively define experiments, create structured configuration systems using formats such as YAML or JSON, and develop reusable experiment templates. This direction aims to make CartopiaX more accessible to domain scientists who may not have extensive programming experience while improving reproducibility and workflow management.
+* Easy integration - a possible direction focuses on improving the usability of CartopiaX by developing more intuitive ways for researchers to configure and run simulations. Currently, simulations rely heavily on static configuration files and parameter definitions. participants may explore designing graphical or web-based interfaces that allow researchers to interactively define experiments, create structured configuration systems using formats such as YAML or JSON, and develop reusable experiment templates. This direction aims to make CartopiaX more accessible to domain scientists who may not have extensive programming experience while improving reproducibility and workflow management.
 
-* Flexibility: A potential direction involves extending CartopiaX through Python integration to support flexible and rapid scientific experimentation. Many researchers in computational biology prefer Python due to its strong ecosystem for data analysis and prototyping. Students may investigate technologies such as cppyy to enable seamless interaction between the high-performance C++ simulation core and Python. This could allow scientists to define cell behaviors, simulation rules, or analysis pipelines directly in Python while preserving the performance advantages of the C++ backend. This area provides opportunities to work on language interoperability and mixed-language scientific workflows.
+* Flexibility: A potential direction involves extending CartopiaX through Python integration to support flexible and rapid scientific experimentation. Many researchers in computational biology prefer Python due to its strong ecosystem for data analysis and prototyping. participants may investigate technologies such as cppyy to enable seamless interaction between the high-performance C++ simulation core and Python. This could allow scientists to define cell behaviors, simulation rules, or analysis pipelines directly in Python while preserving the performance advantages of the C++ backend. This area provides opportunities to work on language interoperability and mixed-language scientific workflows.
 
-* HPC: a third direction explores improving the performance and scalability of CartopiaX by identifying and optimizing computational bottlenecks within the simulation engine. Agent-based biological simulations frequently involve expensive processes such as diffusion modeling and large-scale cell interaction calculations. Students may explore profiling the simulation engine, investigating GPU acceleration strategies for diffusion solvers or other parallelizable components, and developing benchmarking tools to evaluate performance improvements. This direction is particularly suited for students interested in high-performance computing and parallel programming techniques.
+* HPC: a third direction explores improving the performance and scalability of CartopiaX by identifying and optimizing computational bottlenecks within the simulation engine. Agent-based biological simulations frequently involve expensive processes such as diffusion modeling and large-scale cell interaction calculations. participants may explore profiling the simulation engine, investigating GPU acceleration strategies for diffusion solvers or other parallelizable components, and developing benchmarking tools to evaluate performance improvements. This direction is particularly suited for participants interested in high-performance computing and parallel programming techniques.
 
 ## Requirements
 
diff --git a/_gsocproposals/2026/proposal_BioDynamo_LargeScaleAntimatter.md b/_gsocproposals/2026/proposal_BioDynamo_LargeScaleAntimatter.md
@@ -24,7 +24,7 @@ project_mentors:
 
 Deliver a self-contained BioDynaMo module and research prototype that enables validated, reproducible simulations of charged antiparticle ensembles in Penning-trap-like geometries at scales beyond existing demonstrations. The project generalizes prior BioDynaMo Penning-trap work into a reusable, documented, and scalable module suitable for antimatter-motivated studies and other charged-particle systems.
 
-The student will extend BioDynaMo with a focused set of features (pluginized force models, neighbor search tuned for charged particles, elastic runtime hooks, and analysis/visualization pipelines), validate the models on canonical testcases (single-particle motion, small plasma modes), and demonstrate scaling and scientific workflows up to the largest feasible size within available resources. BioDynaMo already provides an agent/plugin API, parallel execution (OpenMP), and visualization hooks (ParaView/VTK). A prior intern report demonstrates a Penning-trap proof-of-concept and identifies directions for extension (custom forces, multi-scale runs, hierarchical models, CI, containerization)[[1]](https://repository.cern/records/7capf-rqp49). 
+The participant will extend BioDynaMo with a focused set of features (pluginized force models, neighbor search tuned for charged particles, elastic runtime hooks, and analysis/visualization pipelines), validate the models on canonical testcases (single-particle motion, small plasma modes), and demonstrate scaling and scientific workflows up to the largest feasible size within available resources. BioDynaMo already provides an agent/plugin API, parallel execution (OpenMP), and visualization hooks (ParaView/VTK). A prior intern report demonstrates a Penning-trap proof-of-concept and identifies directions for extension (custom forces, multi-scale runs, hierarchical models, CI, containerization)[[1]](https://repository.cern/records/7capf-rqp49). 
 
 ## Engineering Goals
 * Implement a BioDynaMo plugin module (“AntimatterKernel”) optimized for charged-particle workloads, including SoA-compatible data layouts, spatial decomposition, and an efficient neighbor search.
diff --git a/_gsocproposals/2026/proposal_CMS_CompOpsArchi.md b/_gsocproposals/2026/proposal_CMS_CompOpsArchi.md
@@ -29,7 +29,7 @@ project_mentors:
 
 Archi (AI Augmented Research Chat Intelligence) is an open-source, end-to-end framework for building AI agents to automate research and operational workflows. Various groups have already applied the system to their use case; the most advanced is the Computing Operations (CompOps) team at the Compact Muon Solenoid (CMS) experiment at CERN. CompOps has a private, constantly evolving, and scattered knowledge base, with scarce personnel on short term contracts. Archi puts together state-of-the-art, open-source tools like LangChain, knowledge graphs, and Model Context Protocol, and combines documentation, code, tickets, and live diagnostics to accurately retrieve relevant information, assisting operators in daily tasks, improving operator efficiency, and lessening the load on experts. Other groups at CMS deploying Archi for their use case include the Data Quality Monitoring (DQM) team and a group focusing on retrieval of the vast analysis code and documentation across the CMS landscape.
 
-The goal of this GSoC project is to work on the development of autonomous agents to perform non-trivial computing operations at CMS, a task which integrates large language models with highly accurate retrieval, expert domain knowledge, heteregenous data sources, and agentic tools. The student will get familiarity with state-of-the-art and in-demand agentic tools like LangChain and MCP.
+The goal of this GSoC project is to work on the development of autonomous agents to perform non-trivial computing operations at CMS, a task which integrates large language models with highly accurate retrieval, expert domain knowledge, heteregenous data sources, and agentic tools. The participant will get familiarity with state-of-the-art and in-demand agentic tools like LangChain and MCP.
 
 
 ## Task idea
diff --git a/_gsocproposals/2026/proposal_Clad-GPU.md b/_gsocproposals/2026/proposal_Clad-GPU.md
@@ -22,13 +22,13 @@ project_mentors:
 
 ## Description
 
-Clad is a Clang-based automatic differentiation (AD) plugin for C++. Over the past years, several efforts have explored GPU support in Clad, including differentiation of CUDA code, partial support for the Thrust API, and prototype integrations with larger applications such as XSBench, LULESH, a tiny raytracer in the Clad repository, and LLM training examples (including work carried out last year). While these efforts demonstrate feasibility, they are fragmented across forks and student branches, are inconsistently tested, and lack reproducible benchmarking.
+Clad is a Clang-based automatic differentiation (AD) plugin for C++. Over the past years, several efforts have explored GPU support in Clad, including differentiation of CUDA code, partial support for the Thrust API, and prototype integrations with larger applications such as XSBench, LULESH, a tiny raytracer in the Clad repository, and LLM training examples (including work carried out last year). While these efforts demonstrate feasibility, they are fragmented across forks and participant branches, are inconsistently tested, and lack reproducible benchmarking.
 
 This project aims to consolidate and strengthen Clad’s GPU infrastructure. The focus is on upstreaming existing work, improving correctness and consistency of CUDA and Thrust support, and integrating Clad with realistic GPU-intensive codebases. A key goal is to establish reliable benchmarks and CI coverage: if current results are already good, they should be documented and validated; if not, the implementation should be optimized further so that Clad is a practical AD solution for real-world GPU applications.
 
 ## Expected Results
 
-* Recover, reproduce, and upstream past Clad+GPU work, including prior student projects and LLM training prototypes.
+* Recover, reproduce, and upstream past Clad+GPU work, including prior participant projects and LLM training prototypes.
 * Integrate Clad with representative GPU applications such as XSBench, LULESH, and the in-tree tiny raytracer, ensuring * correct end-to-end differentiation.
 * Establish reproducible benchmarks for these codebases and compare results with other AD tools (e.g. Enzyme) where feasible.
 * Reduce reliance on atomic operations, improve accumulation strategies, and add support for additional GPU primitives and CUDA/Thrust features.
diff --git a/_layouts/blog_post.html b/_layouts/blog_post.html
@@ -1,4 +1,4 @@
----
+﻿---
 layout: default
 ---
 
@@ -10,13 +10,13 @@
   <div class="row">
     {% if page.avatar %}
       <div class="col-md-3">
-        <img src="{{ page.avatar }}" alt={{ page.author }} width="100%" style="float:right">
+        <img src="{{ page.avatar }}" alt="{{ page.author }}" width="100%" style="float:right">
       </div>
       <div class="col-md-9">
     {% else %}
       {% if page.photo %} 
         <div class="col-md-3">
-          <img src="{{ site.baseurl }}/images/{{ page.photo }}" alt={{ page.author }} width="100%" style="float:right">
+          <img src="{{ site.baseurl }}/images/{{ page.photo }}" alt="{{ page.author }}" width="100%" style="float:right">
         </div>
         <div class="col-md-9">
       {% else %}
