diff --git a/content/academia/alive2-maintainer-spotlight.md b/content/academia/alive2-maintainer-spotlight.md
new file mode 100644
index 000000000..317c6029d
--- /dev/null
+++ b/content/academia/alive2-maintainer-spotlight.md
@@ -0,0 +1,74 @@
+---
+name: Nuno Lopes
+institution: University of Lisbon
+department: Computer Science
+projectName: Alive2
+projectRepo: https://github.com/AliveToolkit/alive2
+maintainerProfiles:
+  - github: https://github.com/nunoplopes
+  - scholar: https://scholar.google.com/citations?user=DQnsjaoAAAAJ
+badges: ["Academic Maintainer", "Associate Professor"]
+description: "A tool to automatically verify the correctness of LLVM optimizations, used by several companies and instrumental in finding hundreds of bugs in LLVM."
+---
+
+## What is Alive2, and what does it help people do?
+
+Alive2 is a tool to automatically verify the correctness of LLVM optimizations.
+
+## What inspired this project?
+
+It all started when I noticed that one of LLVM's optimizations (InstCombine) was consistently the part of LLVM with the most bug reports. I looked more closely and tried to prove a few cases by hand with the support of an SMT solver. It worked, so I began working on automating the process. It later became my PhD thesis.
+
+## How does this project connect to your academic work?
+
+This project is part of my research agenda on making compilers correct.
+
+## Who contributes to the project?
+
+We have faculty from our and other universities, PhD students, and external contributors from a dozen companies.
+
+## How are students involved in the project?
+
+Some students base most of their PhD thesis on the project, contributing large parts of the theory and/or code. Others contribute smaller pieces, such as adding support for new LLVM features or improving specific algorithms in the tool.
+
+## How is the project used in teaching or coursework?
+
+Alive2 is not used for teaching in my university (we don't have any course on the topic), but other universities include the tool in their lectures.
+
+## What impact has this project had on your students?
+
+It is quite a unique project in the world of verification. There are not many fully automated tools used in industry. It has also inspired students to build other tools based on the same techniques, including superoptimizers and verification tools for other compilers and languages.
+
+## What impact has the project had beyond the classroom or research?
+
+We have published several papers and won two Best Paper awards at PLDI, a leading compiler conference. The tool is used by several companies, and we have found hundreds of bugs in LLVM. Overall, it has had a strong impact on the compiler industry.
+
+## What does it take to maintain the project?
+
+I am the main maintainer, so the schedule depends on my teaching load. It also depends on whether there are interested students in a given year. Sometimes it is challenging to keep up with the workload, but we have a few great external contributors that help tracking and fixing issues.
+
+## What have been the biggest challenges in maintaining the project, especially in an academic setting?
+
+Balancing project work with teaching is difficult. This project is mostly a hobby. Securing funding is also very challenging; we are part of that familiar story where many people use the project, but no one wants to fund it. For example, only recently we received a server for regular testing (thank you, Google!).
+
+## How do you ensure the project remains sustainable over time?
+
+It would be ideal to have regular funding to support a full-time professional software developer maintaining the project.
+
+## How do you engage with your community?
+
+We participate in the LLVM conference occasionally and share work through documentation and research papers. We also engage in relevant discussions around semantics of LLVM IR. We often prototype proposed changes so we can assess the impact of the changes before committing to a particular IR design.
+
+## Have you taken part in any open source programs or events?
+
+I participate in Google Summer of Code through LLVM and have been involved for about 20 years.
+
+## What would you love to achieve by showcasing your project?
+
+If it helps attract funding and international students, that would be great. I also think it is a good example of technology transfer and what academia can achieve. And that professors can code too!
+
+## Is there anything else you'd like to share about your project or open source journey?
+
+Getting Alive2 adopted by industry at wide took time. But we were very lucky that we got a few expert users early on. They provided feedback on the design and did a lot of beta testing.
+
+The way we started was by doing automatic reviews of patches sent to the LLVM mailing list in the Summer of 2014. We caught a bunch of errors related with corner cases. Some people noticed and started asking me how I was catching these bugs. They wanted to try the tool themselves.
diff --git a/content/academia/gandlf-maintainer-spotlight.md b/content/academia/gandlf-maintainer-spotlight.md
new file mode 100644
index 000000000..832aac88b
--- /dev/null
+++ b/content/academia/gandlf-maintainer-spotlight.md
@@ -0,0 +1,101 @@
+---
+name: Sarthak Pati
+institution: MLCommons
+department: Medical AI Working Group
+projectName: Generally Nuanced Deep Learning Framework (GaNDLF)
+projectRepo: https://github.com/mlcommons/GaNDLF/
+projectWebsite: https://gandlf.org
+maintainerProfiles:
+  - github: https://github.com/sarthakpati
+  - orcid: https://orcid.org/0000-0003-2243-8487
+badges: ["Academic Maintainer", "Vice Chair for Algorithm Development and Benchmarking"]
+description: "A framework designed to make deep learning development, training, and inference more stable, reproducible, interpretable, and scalable for computational precision medicine — without requiring an extensive technical background."
+---
+
+## What is GaNDLF, and what does it help people do?
+
+GaNDLF is a framework designed to make deep learning (DL) development, training, and inference more stable, reproducible, interpretable, and scalable, without requiring an extensive technical background. It provides an end-to-end solution for DL-related tasks in computational precision medicine.
+
+GaNDLF supports the analysis of both radiology and histology images, with built-in features such as k-fold cross-validation, data augmentation, support for multiple modalities, and multiple output classes. Its performance across a wide range of use cases and computational tasks demonstrates its potential as a robust framework for deployment in clinical workflows.
+
+## What inspired you to start this project?
+
+Deep learning has strong potential to advance machine learning in both scientific and clinical settings. However, developing DL algorithms requires significant expertise, and differences in implementation often limit reproducibility, translation, and deployment.
+
+GaNDLF was created as a community-driven framework to lower these barriers and make deep learning more accessible and reliable.
+
+## How does this project connect to your academic work?
+
+GaNDLF is part of multiple research initiatives.
+
+## Who contributes to the project?
+
+The project is contributed to by faculty, students, and external contributors.
+
+## How are students involved in the project?
+
+Students contribute code related to their research and help with testing.
+
+## How is the project used in teaching or coursework?
+
+It is not currently integrated into coursework or curriculum.
+
+## What impact has this project had on your students?
+
+Students involved in the project develop software skills and gain a deeper understanding of best practices in open-source development.
+
+## What impact has the project had beyond the classroom or research?
+
+The project has contributed to multiple peer-reviewed publications.
+
+## What does it take to maintain the project?
+
+GaNDLF is maintained through a structured team approach, supported by CI/CD pipelines with integrated unit tests, regular release schedules, and connections to research grants.
+
+## What have been the biggest challenges in maintaining the project?
+
+One of the main challenges is getting researchers up to speed with coding guidelines and best practices.
+
+## How do you ensure the project remains sustainable over time?
+
+Securing funding for long-term development and maintenance has been a major challenge. Partnering with companies to provide specific services has been an important strategy to support sustainability.
+
+## How do you engage with your community?
+
+We engage with the community through documentation, forums, internships, and contribution guidelines.
+
+## Have you taken part in any open source programs or events?
+
+Not yet, but we plan to.
+
+## What would you love to achieve by showcasing your project?
+
+We want to raise awareness about community-driven, sustainable open-source software in the healthcare AI domain.
+
+## Do you use AI tools in your day to day work on this project? If so, how?
+
+This project is now in maintenance mode. I use AI to update documentation, and track any reported bugs.
+
+## Has AI changed how you maintain or manage your project?
+
+Absolutely. The speed with which features go in has dramatically increased.
+
+## How do you see your contributors using AI when working on your project?
+
+AI is another tool. Its efficacy is dictated by the one holding the reins.
+
+## What concerns or challenges, if any, do you have about the use of AI in your project or field?
+
+My primary concern is that people commit changes without understanding what the changes were. This leads to lower quality, and potential code issues (such as someone accidentally posting API KEY information).
+
+## How has your approach to maintaining this project evolved over time?
+
+I have primarily focused on ensuring issues are taken care of in a timely manner.
+
+## How do you see AI shaping the future of your project or field?
+
+AI has levelled the playing field for engineers. Now, the main capital someone has are ideas, because their implementation is pretty quick.
+
+## Is there anything else you'd like to share?
+
+No additional comments.
diff --git a/content/academia/gym-pybullet-drones-maintainer-spotlight.md b/content/academia/gym-pybullet-drones-maintainer-spotlight.md
new file mode 100644
index 000000000..094227500
--- /dev/null
+++ b/content/academia/gym-pybullet-drones-maintainer-spotlight.md
@@ -0,0 +1,106 @@
+---
+name: Jacopo Panerati
+institution: Technology Innovation Institute
+department: Autonomous Robotics Research Centre
+projectName: gym-pybullet-drones
+projectRepo: https://github.com/learnsyslab/gym-pybullet-drones
+maintainerProfiles:
+  - github: https://github.com/JacopoPan
+  - orcid: https://orcid.org/0000-0003-2994-5422
+badges: ["Academic Maintainer", "Research Software Engineer"]
+description: "A Python package for simulating Gymnasium environments for single- and multi-agent reinforcement learning of quadcopter control, built on the PyBullet physics engine."
+---
+
+## What is this project, and what does it help people do?
+
+This project is a Python package for simulating Gymnasium (formerly OpenAI Gym) environments for single- and multi-agent reinforcement learning of quadcopter control.
+It is based on the PyBullet physics engine and integrates with PyTorch-based stable-baselines3 implementations for deep reinforcement learning.
+
+## What inspired you to start this project?
+
+The project was inspired by the need to simultaneously teach low-level quadcopter control and continuous-action reinforcement learning at the University of Toronto Institute for Aerospace Studies during the COVID lockdowns.
+
+## How does this project connect to your academic work?
+
+It started as a simulation research initiative and has supported various capstone projects at the University of Toronto, as well as an online competition at IROS.
+
+## Who contributes to the project?
+
+Several graduate students and interns from the University of Toronto DSL group, along with contributors from GitHub.
+
+## How are students involved in the project?
+
+UTIAS DSL students contributed to the initial PID controller integrated into the simulation, international students further contributed additional controllers, examples, and evaluations scripts through GitHub PRs over the years.
+
+## How is the project used in teaching or coursework?
+
+The simulation has been used to teach multicopter dynamics in two University of Toronto robotics courses.
+
+## What impact has this project had on your students?
+
+It has supported the development of several collaborative research papers using the same simulation framework.
+
+## What impact has the project had beyond the classroom or research?
+
+The project was presented at IROS and has formed the basis for further journal publications.
+
+## What does it take to maintain the project?
+
+Maintenance is primarily handled by myself, with support from a few former students from Canada and Germany.
+
+## What have been the biggest challenges in maintaining the project?
+
+Responding to issues in a timely manner is critical for building trust with the community.
+
+## How do you ensure the project remains sustainable over time?
+
+Involving others and distributing the workload has been key to sustainability.
+
+## How do you engage with your community?
+
+I aim to respond promptly to all open issues, including requests for explanations and research guidance.
+
+## Have you taken part in any open source programs or events?
+
+No additional comments.
+
+## What would you love to achieve by showcasing your project?
+
+To demonstrate that even relatively simple ideas can be successful when they are designed to work well for others.
+
+## Do you use AI tools in your day to day work on this project? If so, how?
+
+I often interact with an LLM with a coding-oriented prompt when planning out a new feature or fix PR.
+I sometimes accept in-line LLM coding suggestions in my IDE.
+
+## Do you implement AI into your classroom or coursework (if applicable)? If so, what does that look like in practice?
+
+n/a
+
+## Has AI changed how you maintain or manage your project?
+
+I do appreciate the in-PR coding quality suggestions (when they are single line changes) when using deprecated or non-standard syntax.
+
+## Have you experimented with AI driven or automated workflows in your project? What has that looked like?
+
+Not yet.
+
+## How do you see your contributors using AI when working on your project?
+
+I have been seeing more small, code quality oriented PRs that seem to be suggested by AI and/or agents.
+
+## What concerns or challenges, if any, do you have about the use of AI in your project or field?
+
+As an educational project, the goal of this repo is to help humans better master theoretical concepts (about flight dynamics and controls) rather than developing "working features passing unit and integration tests". The code itself (and not just its runtime) is supposed to be the human-centric product.
+
+## How has your approach to maintaining this project evolved over time?
+
+I've been relying on scheduled workflows and automated dependency updates more.
+
+## How do you see AI shaping the future of your project or field?
+
+Coding LLMs have certainly sped up the number of features an expert developer can ship in a fixed amount of time but it does not seem to me to have reached a level of maturity where it can make always sound architectural choices and this is particularly tricky to observe/understand/mitigate (before it's too late and a project has spiraled out of control) for the novice.
+
+## Is there anything else you'd like to share?
+
+No additional comments.
diff --git a/content/academia/librosa-maintainer-spotlight.md b/content/academia/librosa-maintainer-spotlight.md
new file mode 100644
index 000000000..0c647bc5e
--- /dev/null
+++ b/content/academia/librosa-maintainer-spotlight.md
@@ -0,0 +1,129 @@
+---
+name: Brian McFee
+institution: New York University
+department: Center for Data Science and Music and Performing Arts Professions
+projectName: librosa
+projectRepo: https://github.com/librosa/librosa/
+projectWebsite: https://librosa.org/
+maintainerProfiles:
+  - github: https://github.com/bmcfee
+  - orcid: https://orcid.org/0000-0001-6261-9747
+badges: ["Academic Maintainer", "Professor"]
+description: "A Python package for music and audio analysis that provides the building blocks necessary to create music information retrieval systems, fundamental signal processing algorithms, and tools to interact with and visualise music and audio signal data."
+---
+
+## What is librosa, and what does it help people do?
+
+librosa is a Python package for music and audio analysis. It provides the building blocks necessary to create music information retrieval systems, fundamental signal processing algorithms, and tools to interact with and visualise music and audio signal data.
+
+It is widely used by academic researchers, educators, students, and industry practitioners.
+
+## What inspired you to start this project?
+
+The project grew out of a concerted effort to translate disparate collections of MATLAB scripts for music signal processing into a unified, coherent Python package.
+
+At the time the project began (2012), there was a growing sense within the music information retrieval (MIR) community that machine learning and data science software was rapidly moving from MATLAB to Python, driven by the development of scikit-learn and Theano, as well as the broader SciPy ecosystem.
+
+While there was excitement about this transition, a critical barrier remained: the lack of reliable implementations of standard signal analysis methods and pipelines. librosa began as a port of in-house code at Columbia University's Laboratory for the Organization of Speech and Audio (LabROSA), and later expanded to incorporate contributions from other research groups and independent developers.
+
+## How does this project connect to your academic work?
+
+The project serves as a foundation library for nearly all of my research in music and audio analysis. It is also frequently used by students for class assignments, capstone projects, and thesis work.
+
+## Who contributes to the project?
+
+At this point, the project has over 100 contributors spanning nearly every career stage in academia, including undergraduate, graduate, postdoctoral, and faculty contributors, as well as industry researchers and software developers.
+
+## How are students involved in the project?
+
+The project is now fairly mature, and students do not often contribute directly. However, in the past, I have had both undergraduate and graduate students contribute code and documentation.
+
+## How is the project used in teaching or coursework?
+
+librosa is widely used in coursework within the graduate music technology program at NYU, although not typically in my own courses, which focus more on fundamentals than applications.
+
+It is also used broadly in courses at other universities.
+
+## What impact has this project had on your students?
+
+Students who use or contribute to librosa often have limited prior experience with software development. As maintainers, we make a strong effort to demonstrate best practices, including documentation, code review, and testing.
+
+Students who contribute gain exposure to modern software development practices, as well as specific tools and workflows within the scientific Python ecosystem.
+
+## What impact has the project had beyond the classroom or research?
+
+librosa is widely used in both academia and industry. The 2015 paper published at the SciPy conference has accumulated over 4,000 citations. We also encourage users to cite the specific software version they use via DOIs provided through Zenodo integration with GitHub releases.
+
+The documentation site receives around 20,000 monthly visits globally, and the package has been downloaded more than 88 million times from the Python Package Index (PyPI).
+
+## What does it take to maintain the project?
+
+The team structure has fluctuated over time. I have consistently served as the lead developer and maintainer, with other contributors joining and leaving core development as needed.
+
+Contributions follow a standard pull request and code review workflow, with continuous integration testing applied to code, documentation, and style at each stage. We aim to release one major version each year, with minor updates as needed in between.
+
+## What have been the biggest challenges in maintaining the project, especially in an academic setting?
+
+As with many open-source projects, contributor turnover has been a persistent challenge. Meaningful contributions often require substantial domain knowledge, which student contributors typically develop only toward the end of their studies. At that point, their career paths often lead them elsewhere, making sustained engagement difficult.
+
+Another major challenge is maintaining compatibility with related software packages. These dependencies may evolve quickly, requiring frequent updates, or too slowly, which can delay new releases.
+
+## How do you ensure the project remains sustainable over time?
+
+For the most part, sustainability has been driven by voluntary contributions and my own need for stable, reproducible research tools.
+
+## How do you engage with your community?
+
+Most direct engagement occurs through the discussion forum, GitHub issues, and comment threads. We also maintain a comprehensive documentation site and provide clear guidelines for development and contribution.
+
+## Have you taken part in any open source programs or events?
+
+We have participated in Hacktoberfest in the past, and the occasional SciPy conference sprint.
+
+## What would you love to achieve by showcasing your project?
+
+I do not actively promote the project beyond small efforts, such as distributing stickers. However, we are planning a major stable release (1.0) in the coming months, and this could be a good opportunity to increase visibility, attract new users, and begin planning for future growth and development.
+
+## Do you use AI tools in your day to day work on this project? If so, how?
+
+I wouldn't say daily, but I definitely use Copilot code review as a backup or supplement to my own reviews on pull requests (including my own). Much less often—maybe every couple of months—I'll try out various coding agents to prototype new functionality or API designs, but almost always find it to be less efficient than just doing it myself in the first place. This probably owes to the somewhat niche nature of the functionality I'm often trying to design, which is probably rarely represented well in the training data for these models.
+
+Outside of coding agents, I do sometimes find use in running particularly obtuse error log dumps through a bot to more efficiently hone in on potential causes of failures. Success rates on this are hit-or-miss, as the kinds of errors I often encounter arise from recent updates to underlying software that haven't yet propagated through to the information available to bots.
+
+## Do you implement AI into your classroom or coursework (if applicable)? If so, what does that look like in practice?
+
+I sometimes use AI tools to generate one-off scripts to help with things like back-end logistics for running courses (e.g. generating student group membership assignments), or to generate variations of exam questions, but almost never for course content. At most I find it useful sometimes as an enhanced search engine to help fill in some background reading on a topic, but I always follow with a manual verification of whatever the bots produce.
+
+Most of the courses that I teach tend to be foundational concept courses (e.g. introductory signal processing). For this, using AI tools in class is roughly akin to buying a gym membership and then showing up to lift weights with a forklift: it gets the job done technically, but completely misses the point.
+
+## Has AI changed how you maintain or manage your project?
+
+Not really. We've been pretty lucky that our PRs have not been inundated with bot-generated slop code (yet), so not much has had to change from the management perspective. Automated code review is nice to have, but mostly just improves the existing workflow rather than radically upending it.
+
+## Have you experimented with AI driven or automated workflows in your project? What has that looked like?
+
+Not substantially. I sometimes will look at generated documentation, but it almost never provides the kind of content that I'd want in documentation.
+
+## How do you see your contributors using AI when working on your project?
+
+It's largely invisible to me. Probably there is some code generation and iteration happening behind the scenes before anything makes it to PR, but it's not generally part of the process after a PR is opened. (Or if it is, nobody tells me about it.)
+
+## What concerns or challenges, if any, do you have about the use of AI in your project or field?
+
+I don't see much meaningful impact either way for this project—it's a mid-level library in a complex software ecosystem that fills a particular niche. Some AI coding tools might be helpful for maintaining and extending it, but I don't anticipate huge direct impacts from AI tool adoption here.
+
+On the other hand, my field (music information retrieval, or MIR for short, see ismir.net) is in a current state of flux over AI research, and specifically the rapid advances in AI music generation and the subsequent impacts on the music industry and society more broadly. This is a related but distinct question from the use of AI in research (e.g. for code generation, paper writing, etc.). To that point, I do have substantial fear of a future where people naively tab-complete their way through programming tasks without having any understanding of how anything works.
+
+## How has your approach to maintaining this project evolved over time?
+
+In almost 14 years of development, most of the evolution has been catching up to best practices learned from other nearby projects (numpy, scipy, matplotlib, etc), and the broader infrastructural and platform changes that affect everyone.
+
+## How do you see AI shaping the future of your project or field?
+
+This depends on how the term "AI" is scoped. Many of the initial use cases for librosa have been at this point replaced by deep neural network models, but these often lack many desirable features such as interpretability, transparency, direct user-interpretable controls, or coherent management of statistical dependencies (i.e. training data). Depending on who you ask, these models may or may not count as "AI", but much of the recent work in the field has been on integrating audio analysis with large language models to exploit high-level semantics in structuring learned audio representations. However, this is still very much an active research area, and there's quite a bit more work to be done before these methods, in spite of providing higher "accuracy" (whatever that might mean) for particular tasks, fully recover all of the desirable properties of classical engineered methods.
+
+## Is there anything else you'd like to share about your project or open source journey?
+
+I have been fortunate that my career path has allowed me to dedicate time to this and related projects. None of this would be possible without the support of the broader scientific Python community, particularly the developers of core libraries such as NumPy, SciPy, and Matplotlib.
+
+I have learned much about scientific open-source development through attending the SciPy conference and through informal interactions with contributors in the community.
diff --git a/content/academia/scikit-robot-maintainer-spotlight.md b/content/academia/scikit-robot-maintainer-spotlight.md
new file mode 100644
index 000000000..4902e28b5
--- /dev/null
+++ b/content/academia/scikit-robot-maintainer-spotlight.md
@@ -0,0 +1,129 @@
+---
+name: Iori Yanokura
+institution: The University of Tokyo
+department: Graduate School of Information Science and Technology / Mechano-Informatics
+projectName: scikit-robot
+projectRepo: https://github.com/iory/scikit-robot
+projectWebsite: https://scikit-robot.readthedocs.io/en/latest/
+maintainerProfiles:
+  - github: https://github.com/iory
+  - orcid: https://orcid.org/0009-0009-4433-0013
+badges: ["Academic Maintainer", "Assistant Professor"]
+description: "A lightweight, pure-Python library for robotic kinematics, motion planning, visualization, and control, designed to make robotics more accessible to students, researchers, and engineers."
+---
+
+## What is Scikit-robot, and what does it help people do?
+
+Scikit-robot is a lightweight, pure-Python library for robotic kinematics, motion planning, visualization, and control. It is designed to make robotics more accessible by allowing users to easily simulate, control, and extend robots using Python. By lowering the barrier to entry, it helps students, researchers, and engineers quickly turn their ideas into working robotic systems without needing to deal with complex underlying implementations. Over the past year the library has grown to include a full-body inverse-kinematics solver that treats the floating base as a solved degree of freedom (via new PlanarJoint and FloatingJoint primitives), differentiable and batched kinematics implemented in JAX, ROS 2 robot interfaces (e.g., a parameterised PandaROS2RobotInterface for multi-arm setups), and humanoid models such as JAXON JVRC. This makes scikit-robot increasingly viable not only for educational use but also for whole-body humanoid and dual-arm research.
+
+## What inspired you to start this project?
+
+The story behind Scikit-robot began with a desire to make robotics more accessible and approachable. At the Information Systems Engineering Laboratory, we had long relied on EusLisp, a powerful robot programming language, but it had limitations such as integration challenges and less accessible documentation.
+
+During my time as a graduate student, I started thinking about how to preserve EusLisp's strengths while combining them with Python's simplicity and ecosystem. Inspired by tools like NumPy and Scikit-learn, I saw the need for a robotics library that was easy to start with and versatile in its applications. This led to the creation of Scikit-robot.
+
+## How does this project connect to your academic work?
+
+Scikit-robot is deeply connected to my academic work and originated from my graduate research at the Information Systems Engineering Laboratory. It became a core part of my efforts to lower the barriers to robot development.
+
+It has since been used in research projects, including work with PR2 robots and ROS, and more recently with humanoid platforms such as JAXON and ROS 2-based robots including the Franka Panda (with first-class support for multi-arm setups), and continues to support both research and educational activities.
+
+## Who contributes to the project?
+
+Students are the primary contributors to the project. Several lab members have led core features that became the basis of recent publications — the integrated URDF toolchain, dynamic root transformation, and hash-based model management were developed jointly.
+
+## How are students involved in the project?
+
+Students contribute by writing code, improving documentation, testing features, and using the library in their own research projects.
+
+## How is the project used in teaching or coursework?
+
+Scikit-robot is actively integrated into coursework. At the University of Tokyo's Department of Mechanical Informatics, students use it in practical exercises where they design robots in CAD, convert them into URDF models, and control or simulate them.
+
+It is also used in workshops for Toshimagaoka Girls' Junior and Senior High School students, where it helps teach basic robotics concepts through hands-on activities.
+
+## What impact has this project had on your students?
+
+Participating in Scikit-robot has had a significant impact on students. They gain hands-on experience in robotics, develop practical engineering skills, and build confidence in programming.
+
+Students involved in research and development also improve their problem-solving abilities, creativity, and teamwork skills, while gaining a deeper understanding of open-source development.
+
+## What impact has the project had beyond the classroom or research?
+
+Scikit-robot has had a meaningful impact in both education and research. It has enabled students and researchers to move from design to implementation more easily and has supported projects in areas like modular robots and assistive technologies. Concrete examples include the Tycoon modular robot system and the Griphis manipulator, both of which rely on scikit-robot's dynamic root-transformation algorithm to compose modules into physically meaningful assemblies. The framework now also powers FormaMotus, a [Blender plugin](https://github.com/iory/formamotus) for visualising and authoring modular robot configurations on top of scikit-robot.
+
+By reducing cost and complexity, it allows more people to experiment with robotics and has helped expand access to practical robotics applications. This year, the work was published as "scikit-robot: An Integrated Framework for Solving Structural Challenges in Dynamic Modeling for Reconfigurable Robotics" at IEEE/SICE SII 2026.
+
+## What does it take to maintain the project?
+
+The project is maintained through a structured development process that includes continuous integration using GitHub Actions, automated testing, and real-world validation with physical robots. More recently, code review on every diff is increasingly assisted by AI tools (Codex and Claude Code), which has shortened the loop between writing changes and getting a careful second pass on them — particularly valuable when the only other reviewers are busy graduate students.
+
+Releases are automated through PyPI, and testing includes unit tests, integration tests, and real-world testing to ensure reliability.
+
+## What have been the biggest challenges in maintaining the project?
+
+One of the biggest challenges is balancing development speed and quality with limited time and resources in an academic environment. Contributors, including students, often have limited availability.
+
+Another challenge is maintaining stability while exploring new research ideas, as well as keeping documentation up to date despite frequent contributor turnover.
+
+## How do you ensure the project remains sustainable over time?
+
+To ensure sustainability, I rely heavily on automation, including continuous integration and automated releases, to reduce maintenance workload. I have also started incorporating agentic AI workflows — using coding agents for code review, refactoring, and documentation upkeep — which helps offset the limited reviewer bandwidth that comes with maintaining an open-source project inside a small academic lab.
+
+I also focus on keeping the design simple and intuitive to lower the barrier for new contributors, incorporate real-world testing to ensure reliability, and integrate the project into educational programs to continuously engage new users and contributors.
+
+## How do you engage with your community?
+
+Community engagement mainly happens through educational use, GitHub discussions, and collaboration within the lab. Feedback from students and users helps guide improvements.
+
+Issues and pull requests are used for open discussion, and contributions are encouraged through transparent workflows.
+
+## Have you taken part in any open source programs or events?
+
+No.
+
+## What would you love to achieve by showcasing your project?
+
+I would like Scikit-robot to be showcased to increase awareness and highlight its value in education and research. It could also encourage feedback, collaboration, and broader adoption.
+
+Ultimately, I hope it helps more people explore robotics and turn their ideas into reality.
+
+## Do you use AI tools in your day to day work on this project?
+
+Yes, I use AI tools in my daily workflow, particularly for brainstorming research ideas and determining implementation strategies. They are also highly effective for coding and debugging robotic systems.
+
+## Do you implement AI into your classroom or coursework?
+
+Yes, I integrate AI into my teaching. I guide students on how to navigate challenges when they first get stuck, specifically instructing them to use generative AI to analyze and troubleshoot error messages they encounter.
+
+## Has AI changed how you maintain or manage your project?
+
+It has significantly increased our development speed. AI has also streamlined tasks that used to be considered high-value manual work — such as handling software version compatibility, creating user-friendly error messages, and managing migrations, like the transition from ROS 1 to ROS 2.
+
+## Have you experimented with AI driven or automated workflows in your project?
+
+I use AI extensively for documentation generation. It is also instrumental in rapidly developing Proof of Concepts (PoC) for new research ideas.
+
+## How do you see your contributors using AI when working on your project?
+
+I believe contributors use AI primarily to understand the codebase rather than just for generating code or documentation. It helps them quickly learn what is possible within the framework and how to implement specific features they have in mind.
+
+## What concerns or challenges, if any, do you have about the use of AI in your project or field?
+
+I don't have major concerns, but while AI makes it easy to create numerous codebases, I believe the real priority remains ensuring that these projects are maintained over the long term and not abandoned.
+
+## How has your approach to maintaining this project evolved over time?
+
+My approach has evolved to focus on sustainability through GitHub Actions and a strict commitment to avoiding breaking changes. Since the project is used extensively within our laboratory, I am very careful to ensure backward compatibility. I prioritize abstraction so that we can improve functionality without changing how users call functions.
+
+## How do you see AI shaping the future of your project or field?
+
+I believe AI will allow us to incorporate a wider range of features that will ultimately make robots significantly more accessible and easier to use.
+
+## Is there anything else you'd like to share?
+
+One key lesson from this project is the importance of automated testing in robotics. Unlike typical software, robotics directly interacts with physical systems, so reliability is critical.
+
+Scikit-robot emphasizes automated testing and real-world validation, helping bridge the gap between theory and practice. This approach improves reproducibility and allows students and researchers to focus more on innovation rather than debugging.
+
+The project has also highlighted both the challenges and rewards of open-source collaboration in academia, and I hope it encourages a more open and inclusive robotics community.
diff --git a/content/academia/scta-texts-maintainer-spotlight.md b/content/academia/scta-texts-maintainer-spotlight.md
new file mode 100644
index 000000000..3016e9b28
--- /dev/null
+++ b/content/academia/scta-texts-maintainer-spotlight.md
@@ -0,0 +1,193 @@
+---
+name: Jeffrey C. Witt
+institution: Loyola University Maryland
+department: Philosophy
+projectName: SCTA Texts
+projectRepo: https://github.com/scta-texts/
+projectWebsite: https://scta.info
+maintainerProfiles:
+  - github: https://github.com/jeffreycwitt
+  - orcid: https://orcid.org/0000-0002-0682-4065
+badges: ["Academic Maintainer", "Professor"]
+description: "A repository for transcriptions of Medieval Latin texts, enabling students and scholars worldwide to collaboratively build a connected, machine-actionable corpus of the medieval scholastic tradition."
+---
+
+## What is the SCTA Texts Repo, and what does it help people do?
+
+The SCTA Texts Repo is a repository for transcriptions of Medieval Latin texts. I work with students to teach them how to read the abbreviated Latin scripts of the medieval world. The GitHub workflow is a critical step in inviting students into active research, even as they are still learning and building new skills.
+
+Students fork existing repositories and make, correct, or update transcriptions. They use GitHub Codespaces, where I configure the workspace with XML extensions and a Latin spell checker. Their work is submitted as a pull request, where I use GitHub's commenting features to guide and correct it.
+
+Once a pull request is accepted, the work is merged into the official repository and becomes live data for scholars around the world. A webhook then triggers updates to the corpus and re-indexes the XML database.
+
+## What inspired you to start this project?
+
+My long-term goal is to build a connected web of machine-actionable text representing the medieval scholastic tradition. This is a large and complex body of work that forms the foundation of much of modern science, philosophy, and theology. The SCTA already indexes more than 60 million Latin words.
+
+However, this material is very difficult to access. Much of it is locked in hard-to-read manuscripts, and printed editions are often expensive and inaccessible. We need to rethink texts not as static books, but as a dynamic, connected database that can be continually improved.
+
+At the same time, I want to train a new generation of scholars to think this way. Students learn best when they participate in real research, and the GitHub workflow allows them to contribute at their current skill level while developing new ones.
+
+## How does this project connect to your academic work?
+
+I am a specialist in late medieval philosophy and intellectual history. A major bottleneck in research is access to texts, so my long-term goal is to make the entire corpus linked and available at the click of a button.
+
+## Who contributes to the project?
+
+We have contributors from all over the world at every level, including undergraduates, graduate students, postdocs, and faculty.
+
+## How are students involved in the project?
+
+Students improve the corpus by forking repositories, creating or correcting transcriptions, and identifying sources for quotations and references. This work helps link the corpus together.
+
+They submit their work through pull requests, which I review. They then revise based on feedback until the work is ready to be merged.
+
+## How is the project used in teaching or coursework?
+
+At Loyola, this is generally an extracurricular activity. I run a small "text lab" and take on a few students each year as fellows.
+
+We also collaborate with partner projects across multiple countries. These contributors, often graduate students or faculty, work on editions relevant to their research. GitHub allows us to coordinate this decentralized work and bring it together into a connected corpus.
+
+## What impact has this project had on your students?
+
+Students reflect on the value of the work in semester reports. Some have gone on to PhD programs, noting that their work with SCTA and skills in paleography and GitHub contributed to their success.
+
+I've also highlighted students' GitHub work in recommendation letters, particularly when they apply to graduate programs or related fields.
+
+## What impact has the project had beyond the classroom or research?
+
+The number of global collaborations continues to grow, with new projects joining the effort. For example, the Bartolome de Las Casas society has reached out to publish their corpus through SCTA.
+
+We are also seeing new research outcomes made possible by the data. One team used SCTA data to train AI transcription models, and other work has uncovered previously unknown textual connections through programmatic analysis.
+
+## What does it take to maintain the project?
+
+I am the project founder and main maintainer.
+
+## What have been the biggest challenges in maintaining the project?
+
+In the humanities, very few people are familiar with tools like GitHub, which makes it difficult to find collaborators who can help maintain or improve workflows.
+
+I often need to teach new contributors the basics, such as forks and branches. While Codespaces has helped with onboarding, there is still a steep learning curve.
+
+I also have many ideas for improving automation and workflows, but limited time due to teaching and research responsibilities.
+
+## How do you ensure the project remains sustainable over time?
+
+I have applied for grant funding, including an NEH grant, to secure time to focus on the project and improve workflows.
+
+More broadly, progress can be slow because I don't have a large technical network to collaborate with or exchange ideas, unlike in industry settings.
+
+## How do you engage with your community?
+
+I work on improving documentation and have started creating video tutorials to demonstrate workflows.
+
+Much of the engagement happens through direct interaction. I meet weekly with undergraduate students and also collaborate regularly with international teams, reviewing their work and supporting their contributions.
+
+## Have you taken part in any open source programs or events?
+
+No.
+
+## What would you love to achieve by showcasing your project?
+
+I would like to encourage people in the humanities to think differently about texts, not as static books but as data that can be analyzed and connected.
+
+It is also important that students develop the digital literacy needed for modern research. Showcasing this project could highlight these new approaches and inspire both current and future students to engage with them.
+
+## Do you use AI tools in your day to day work on this project?
+
+Yes, I (with my students) am using AI at almost every level of our workflow.
+
+- I train models to segment columns and lines in medieval manuscripts and early modern printings.
+- Once images are segmented, I train models to transcribe the text.
+
+Once the text is structured and deployed to GitHub, I use various embedding algorithms (doc2vec, LatinBert, etc.) to profile the text in different ways. These embedding vectors become the seeds of a recommender service that I provide to scholars using and reading these texts.
+
+See slide deck: [https://jeffreycwitt.com/slides/2026-03-05-vienna](https://jeffreycwitt.com/slides/2026-03-05-vienna)
+
+Increasingly, I'm using agentic AI to assist with the mark-up, especially quotation source identification.
+
+We've also been experimenting with AI-generated translations of historical Latin texts. This is a real benefit to our discovery layer. Even if the translations are not perfect, we can pair them with the original Latin and get a quicker sense of what is being discussed, which then helps us improve the Latin transcriptions and, in a circular fashion, helps us improve the original machine translations.
+
+This is particularly helpful as we encourage undergraduates, who are still learning Latin, to participate in the work. Having an English translation alongside the text allows them to participate in a deeper way than they might otherwise be able.
+
+## Do you implement AI into your classroom or coursework?
+
+I'm working with students mostly as an extracurricular activity who are generally coming from a humanities background rather than a coding background.
+
+As they begin to work with structured data for the first time, this is often the first time that they really see how code (and processing instructions) can be useful to their interests. Previously, because they had limited or zero coding experience, they weren't really able to execute their ideas or experiments.
+
+"Vibe coding" with Copilot has really changed this.
+
+During our meetings, we can now discuss a problem (perhaps how to batch encode a repeated pattern in a text or fix false positives marked by an AI model in image segmentation). Now, I can say: why don't you try to describe this problem to Copilot and see if you can generate a Python script that solves this problem?
+
+I wouldn't say the results are always a production-ready solution, but it really allows the students to see how they could use code to tackle a problem, and I think it inspires them to learn more.
+
+## Has AI changed how you maintain or manage your project?
+
+As the SCTA-TEXTS repository grows to more than 100,000 files, I am increasingly focused on automatic checking and validation, as well as automating post-processing steps.
+
+AI has been a really helpful tool for this. Copilot makes it quite easy to generate GitHub Actions files from a prompt. Over the last year, I've expanded or improved these actions to auto-validate changes to individual XML files and to automatically initiate post-processing steps on incoming pull requests, such as assigning unique xml:ids or line break numbers.
+
+## Have you experimented with AI-driven or automated workflows in your project?
+
+One of the most exciting advances in the last year has come from setting up the necessary MCP services to allow AI agents to assist with some of the text markup tasks that were previously done manually by editors.
+
+The best example I have of this is the automatic marking of text sources, especially Bible verses.
+
+Once data has been published to GitHub, it gets indexed as n-grams. Using these n-gram tokens, we can generate a similarity matrix for each paragraph in a medieval text to each verse in the Bible. From this similarity matrix, we can generate a candidate list of paragraphs which have a high probability of citing a specific Bible verse.
+
+In the past, this is where my (or my students') "manual" work would begin. I would take this list, go to each paragraph and look for the Bible verse and then mark it.
+
+Now, I've developed MCP services for agentic AI to:
+
+- Look up the Bible verse
+- Confirm its presence in the paragraph
+- Identify the word range
+- Insert the `<quote>` element in the XML document with the correct @source
+
+This task is documented as a SKILL called `/encode-quotes` that Claude Code uses to reliably identify and mark quotations.
+Edits can then be submitted as pull requests, where GitHub Actions help validate and quality control the changes.
+
+Over the last 10 years, my students and I have marked about 9,000 verses manually. Using Claude Code over the last month, I have added 8,000+ new Bible quotations, bringing the total to 17,112 confirmed quotations.
+
+At this rate, I expect to add an additional 50,000 Bible quotations by the end of 2026. I know of no other database of biblical reception in the Middle Ages that can match this size.
+
+This doesn't just work for Bible verses. Once those are complete, I will use the same process for marking citations of Patristic authors and uses of Canon Law.
+
+GIF: ["A gif demonstrating the new AI process and tools"](https://s3.amazonaws.com/lum-faculty-jcwitt-public/2026-03-19-providence/bibleMarkingProcess.gif)
+
+Slide deck: [https://jeffreycwitt.com/slides/2026-03-19-providence/#/3/20](https://jeffreycwitt.com/slides/2026-03-19-providence/#/3/20)
+
+
+## How do you see your contributors using AI when working on your project?
+
+From watching my students, I mostly see Copilot and inline recommendations via VS Code speeding up their work, either by correcting repeated errors or suggesting batch updates that they would have previously done manually.
+
+## What concerns or challenges, if any, do you have about the use of AI in your project or field?
+
+I frequently run out of tokens. The only thing stopping my Bible Verse Index from being completed within a week is token limitation.
+
+If I had unlimited tokens, I could spawn agents and index all known Bible verses within a couple of weeks.
+
+Successful use of AI agents also depends on maintaining a wide variety of services, including MCP services.
+
+It's a lot for one person to maintain.
+
+## How has your approach to maintaining this project evolved over time?
+
+See above.
+
+## How do you see AI shaping the future of your project or field?
+
+The success described above has been really astounding, and I'm mostly thinking of ways to expand this work. But it takes careful planning.
+
+In my experience, success requires very controlled parameters and prompts paired with well-designed MCP services that help keep the AI agent on track and using the right identifiers for the right system.
+
+The success of automatically creating indices encourages me to focus student work on creating high-quality foundational data.
+
+The better the initial transcriptions and markup are, the easier it becomes to reliably automate upstream tasks, such as citation marking and linking.
+
+## Is there anything else you'd like to share?
+
+I'm very grateful to have access to a GitHub educator account. The GitHub workflow has been central to my work, and I appreciate the effort that goes into maintaining it.
diff --git a/content/academia/storyteller-maintainer-spotlight.md b/content/academia/storyteller-maintainer-spotlight.md
new file mode 100644
index 000000000..c32f62c26
--- /dev/null
+++ b/content/academia/storyteller-maintainer-spotlight.md
@@ -0,0 +1,111 @@
+---
+name: Mark Mahoney
+institution: Carthage College
+department: Computer Science
+projectName: Storyteller
+projectRepo: https://github.com/markm208/storyteller
+projectWebsite: https://markm208.github.io/
+maintainerProfiles:
+  - github: https://github.com/markm208
+  - orcid: https://orcid.org/0000-0003-3037-3441
+badges: ["Academic Maintainer", "Professor"]
+description: "A free and open source VS Code extension that helps software developers guide others through their work using annotated code 'playbacks' that replay programming sessions with narrative commentary."
+---
+
+## What is Storyteller, and what does it help people do?
+
+Storyteller is a free and open source tool that helps software developers guide others through their work using code "playbacks." Playbacks replay programming sessions with a narrative provided by the author. All that is needed to view a playback is a web browser. Viewers can get inside the author's head as they write code. Authors can include text, hand-drawn whiteboard-style images, screenshots, and videos, and link them directly to highlighted sections of code.
+
+I create collections of code playbacks instead of assigning textbooks in my programming-focused courses. I also use them as the main tool for my in-class teaching activities. Students consistently say that playbacks are more valuable than textbooks and videos. They use them as references when writing their own code, and 88% of my students said they would like their other CS courses to use playbacks.
+
+## What inspired you to start this project?
+
+I have always wanted to guide others through my code and explain how it came to be. Version control systems are great for collaboration, but they are too coarse-grained to allow a developer to walk someone through the thinking behind their code.
+
+So, I started building my own tools to help me explain my work. I wanted others to be able to see what I see and understand my thought processes.
+
+The main tool is a VS Code extension that records changes to files in an open directory. This data can then be used to replay one or more development sessions. The playback is annotated by the author, allowing them to describe in detail what is happening. These guided walkthroughs can include text, hand-drawn whiteboard-style images, screenshots, videos, and even multiple-choice questions.
+
+Recently, I added an AI tutor to playbacks so learners can ask questions that the author has not addressed. The AI tutor is like having a helpful guide right by your side. It can also generate multiple choice questions and project ideas based on the code in the playback. This makes learning from code playbacks more interactive and fun.
+
+[You can see an example in this short video](https://youtu.be/WAPql5KZFR4)
+
+## How does this project connect to your academic work?
+
+This has been my main research project for several years. It started as a fine-grained version control system alternative to Git but many people told me that it was better as a teaching tool than a version control system. So, I pivoted and added more teaching and learning features to it.
+
+## Who contributes to the project?
+
+I am the main contributor, though I have worked with undergraduate students at my university during summer research programmes. I have supported around 10–15 students over the years through our undergraduate research experience programme.
+
+## How is the project used in teaching or coursework?
+
+I use this tool every day in my classes. Instead of assigning textbooks for my students to read, I create collections of code playbacks for all of my programming-focused courses. I find this to be more effective than using expensive textbooks and more efficient than creating my own videos.
+
+When presenting material in class, I project code playbacks to the class to help guide the discussion. Students can always review the playbacks outside of class and when working on their assignments.
+
+## What impact has this project had on your students?
+
+My students prefer code playbacks to textbooks. They also prefer them over videos because they are easier to search and reference. Through anonymous surveys, my students have told me that they use the code playbacks in the classroom and outside when they are working on their programming projects.
+
+## What impact has the project had beyond the classroom or research?
+
+I presented findings from using code playbacks in my courses at SIGCSE 2023. Other educators are starting to make their own code playbacks.
+
+Many people who are not traditional students also view my code playbacks to learn about programming. I have written about a dozen 'books' covering programming languages like C++, Python, Web Dev, Clojure, Elixir, Ruby, with additional books on SQL, Flutter, and design patterns.
+
+## What does it take to maintain the project?
+
+It is mostly just me working on the project in my free time. I release new features as they are completed.
+
+## What have been the biggest challenges in maintaining the project?
+
+Time management, particularly alongside teaching responsibilities, is the biggest challenge. The project is transitioning from a small project to a medium-sized project so it is starting to get hard to remember how all of the pieces fit together.
+
+## How do you ensure the project remains sustainable over time?
+
+I personally fund the AI API costs, so sustainability remains a challenge. I do accept GitHub Sponsors :)
+
+## How do you engage with your community?
+
+Through documentation, social media outreach, and direct engagement.
+
+## What would you love to achieve by showcasing your project?
+
+Learning how to program is hard. My goal has always been to allow learners to see and hear the narrative that experts have in their heads when they are writing code. Code playbacks combine the best parts of books, tutorials, and videos together. Plus, learning to read code and understand it is now an important skill that all of us have to excel at, I believe code playbacks will help us all become better code readers. I want more people to create code playbacks and share them with others.
+
+## Do you use AI tools in your day to day work on this project? If so, how?
+
+I use an AI coding assistant every day when developing features. I always explain my desired features in a spec document and ask the AI assistant for a plan before writing any code. I often discuss the plan interactively before signing off on it. Then, I check its work when it's done.
+
+## Do you implement AI into your classroom or coursework (if applicable)? If so, what does that look like in practice?
+
+I have slowly been integrating AI into my classroom and coursework. My 'code playback' platform integrates a helpful AI tutor into the medium. I am also encouraging students to have a tab open to ask questions while coding, but I encourage them to do as much of the coding as possible the old fashioned way.
+
+## Has AI changed how you maintain or manage your project?
+
+I can definitely add new features quite a bit faster than in the past. However, there is a real risk of losing sight of the big picture when I do this. I am still struggling to find the right mix of AI use and hand-writing my own code.
+
+## Have you experimented with AI driven or automated workflows in your project? What has that looked like?
+
+I love having the AI assistant examine my code and write documentation from it.
+
+## How do you see your contributors using AI when working on your project?
+
+I am the primary developer on this project.
+
+## What concerns or challenges, if any, do you have about the use of AI in your project or field?
+
+I definitely have preferences for how I like my code structured, designed, and written. I developed these preferences and practices over many years of programming. I believe that I have a great deal of valuable experience. I struggle to ensure the AI assistant follows my lead so that I can put my name on the code. I still want the code to read as if it is mine.
+
+## How has your approach to maintaining this project evolved over time?
+
+The introduction of AI assistants has definitely been the biggest change in my process in my entire career. Things are moving so fast sometimes I worry about people coming up and frankly, I don't know what the future holds. These are exciting times!
+
+## How do you see AI shaping the future of your project or field?
+
+I am now planning a project where my students will use an AI assistant to help them build their projects and then create their own code playbacks describing the changes. I'll grade their explanation of the code in the code playback instead of the code itself, as I did previously. I see this as one answer to the problem of teaching computer programming in the AI era.
+
+## Anything else you'd like to share?
+
+GitHub has been a key platform for hosting and sharing the project.
diff --git a/content/academia/trixi-jl-maintainer-spotlight.md b/content/academia/trixi-jl-maintainer-spotlight.md
new file mode 100644
index 000000000..23e94c9e9
--- /dev/null
+++ b/content/academia/trixi-jl-maintainer-spotlight.md
@@ -0,0 +1,83 @@
+---
+name: Hendrik Ranocha
+institution: Johannes Gutenberg University Mainz
+department: Institute of Mathematics
+projectName: Trixi.jl
+projectRepo: https://github.com/trixi-framework/Trixi.jl
+projectWebsite: https://trixi-framework.github.io/Trixi.jl/stable/
+maintainerProfiles:
+  - github: https://github.com/ranocha
+  - orcid: https://orcid.org/0000-0002-3456-2277
+badges: ["Academic Maintainer", "Professor"]
+description: "A numerical simulation framework for conservation laws written in Julia, designed to be useful to both scientists and students with a focus on ease of use, extensibility, and performance."
+---
+
+## What is Trixi.jl, and what does it help people do?
+
+Trixi.jl is a numerical simulation framework for conservation laws written in Julia. A key objective of the framework is to be useful to both scientists and students.
+
+In addition to having an extensible design and a fast implementation, Trixi.jl focuses on being easy to use for new or inexperienced users, including installation and post-processing procedures.
+
+## What inspired you to start this project?
+
+We previously used various closed-source and open-source codes for education and research. However, these codes were often limited to local groups and relied on traditional high-performance computing languages such as C, C++, and Fortran.
+
+Because they were optimized for HPC, they were complex and difficult to understand. Students had to spend a significant amount of time learning how to use and extend them, leaving little time to explore new ideas in their projects or theses.
+
+We wanted to start something different, where ease of use and extensibility were top priorities. We chose Julia as our programming language and adopted best practices from the Julia community. This led to Trixi.jl, an easy-to-use and extensible simulation framework that remains as efficient as the codes we previously used.
+
+## How does this project connect to your academic work?
+
+Trixi.jl is used in classroom projects, student theses, and research initiatives.
+
+## Who contributes to the project?
+
+Faculty, postdocs, PhD students, and external contributors.
+
+## How are students involved in the project?
+
+Students use the code in classroom projects as well as in their Bachelor's and Master's theses. Some also contribute code and documentation.
+
+## How is the project used in teaching or coursework?
+
+Trixi.jl is integrated into class projects, lab work, and senior theses.
+
+## What impact has this project had on your students?
+
+Students learn how to use open-source software and contribute to public projects. In particular, they gain practical skills using Git and GitHub.
+
+## What impact has the project had beyond the classroom or research?
+
+Trixi.jl has been used in over 70 publications, including several from outside the primary developer group. The main repository has more than 650 stars on GitHub, and the Slack workspace has around 200 members.
+
+## What does it take to maintain the project?
+
+Several contributors regularly work on the code and participate in code reviews. A small group of core developers manages releases and handles pull requests.
+
+## What have been the biggest challenges in maintaining the project?
+
+Maintaining open-source projects is rarely recognized in traditional academic reward systems. Additionally, ensuring continuity is difficult because there are no permanent positions dedicated to software maintenance.
+
+As a result, many skilled contributors are only involved for a limited time before moving on.
+
+## How do you ensure the project remains sustainable over time?
+
+The core developers are based across multiple universities and countries. We integrate Trixi.jl into course projects to align development with teaching responsibilities.
+
+We also involve student assistants, teaching them how to use the algorithms and open-source infrastructure while benefiting from their contributions. In addition, we apply for research grants to support ongoing work.
+
+## How do you engage with your community?
+
+We provide documentation and contribution guidelines, maintain a dedicated Slack workspace, and answer questions on the Julia Discourse forum and Zulip. Some researchers also contact us directly via email.
+
+## Have you taken part in any open source programs or events?
+
+We have participated in Hacktoberfest and Google Summer of Code in recent years.
+
+## What would you love to achieve by showcasing your project?
+
+We want to highlight the importance of open-source software and open science. In our view, the contributions of open-source maintainers should be more visible, and showcasing the project helps reinforce the value of this work in modern society.
+
+## Is there anything else you'd like to share?
+
+We value the tools and infrastructure that GitHub provides for our open-source projects.