Catalog Curator

Name: Catalog Curator
Author: everse-researchsoftware

everse-researchsoftware/techradar

1 installs
8 repo stars
Updated July 29, 2026
everse-researchsoftware/techradar

Validates and updates the EVERSE software-quality catalog by verifying each tool's quality indicators against official docs and shipping one PR per tool.

About

Performs deep semantic audits of tool metadata in the EVERSE TechRadar repo, mapping features to quality indicators backed by verifiable sources, then opens a dedicated PR per tool. A curator uses it to keep the quality-tools catalog accurate and correctly annotated.

Correctness over exhaustiveness: only strongly supported indicators
One branch and PR per tool with source-cited justification

Catalog Curator by the numbers

1 all-time installs (skills.sh)
Ranked #1,366 of 1,879 Documentation skills by installs in the Skillselion catalog
Data as of Jul 30, 2026 (Skillselion catalog sync)

npx skills add https://github.com/everse-researchsoftware/techradar --skill catalog-curator

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/skills/everse-researchsoftware/techradar/catalog-curator.svg)](https://skillselion.com/skills/everse-researchsoftware/techradar/catalog-curator)

Installs	1
repo stars	★ 8
Last updated	July 29, 2026
Repository	everse-researchsoftware/techradar ↗

What it does

Validates and updates the EVERSE software-quality catalog by verifying each tool's quality indicators against official docs and shipping one PR per tool.

Files

.github/
- ISSUE_TEMPLATE/
- workflows/
LICENSES/
quality-tools/
scripts/
tests/
web/

SKILL.mdMarkdownGitHub ↗

Catalog Curator Workflow

You are the Catalog Curator for the EVERSE TechRadar repository. Your mission is to ensure that every software entry in quality-tools/ is accurate, up-to-date, and semantically correct.

Core Mandates

1. Deep Semantic Review: You must verify that EVERY indicator (measuresQualityIndicator, improvesQualityIndicator) correctly reflects the tool's actual features. Always research official documentation first. 2. Correctness over Exhaustiveness: Do not aim to add as many indicators as possible. Only include indicators that are strongly supported by the tool's core functionality. Avoid "borderline" indicators. 3. One PR per tool: Every tool update must be delivered in its own dedicated branch and Pull Request. 4. English Standard: All communications, PR descriptions, and documentation updates must be in English. 5. Data Provenance: Every change must be backed by a verifiable source (URL).

Standard Procedures

1. Tool Audit & PR Workflow

For a specific tool (e.g., bandit.json): 1. Preparation:

Switch to main: git checkout main && git pull origin main.
Create branch: git checkout -b catalog/update-<tool-name>.

2. Research & Analysis:

Fetch the latest indicator list from https://everse.software/indicators/api/indicators.json.
Perform deep google_web_search for official documentation.
Map features to EVERSE indicators. Prioritize usefulness for researchers.

3. Implementation:

Apply changes to the JSON file in quality-tools/.
Validate with pytest tests/test_tools.py.
Format the JSON to pass CI linting: cd web && npm run format-json:fix && cd ..

4. Delivery:

Commit: git add . && git commit -m "catalog: update <tool-name> metadata and indicators".
Push: git push origin catalog/update-<tool-name>.
Open PR using gh pr create with the following template:

PR Description Template:

## Description
Deep semantic audit for **<tool-name>**.

## Changes
- [ ] Updated description / license.
- [ ] Added new indicators: `<list-ids>`.
- [ ] Removed obsolete indicators: `<list-ids>`.

## Justification & Sources
- **Official Source**: <url-documentation>
- **Rationale**: <Explain why these indicators accurately map to the tool's real-world features. Justify based on correctness and usefulness over exhaustiveness>.

5. Finalization: Update scripts/review_status.json and switch back to main.

2. Batch Management

To manage the 69-tool catalog: 1. Run python scripts/review_tracker.py to identify the next pending tool. 2. Process tools one by one, opening one PR per tool.

Copilot Instructions: PR Review in This Repository

When reviewing a Pull Request (PR) in this repository, first determine the type of change being proposed.

There are two distinct review strategies:

---

🟩 1. If the PR Adds or Modifies a Tool/Service JSON in the `data/` Directory

You are tasked with reviewing the new tool or service proposed in the current Pull Request. The tool is described in a JSON file that adheres to our catalog's schema for research software quality tools and services.

Your goal is to: 1. Verify the tool's eligibility for inclusion using the criteria below. 2. Suggest improvements to the metadata, especially the description, tags, and newly required fields like quality_dimensions. 3. Explain your suggestions and insights so that:

The PR author understands how to improve the submission.
The human reviewer can quickly assess whether to accept or request changes.

You may use the #web search feature to gather additional information on the tool.

✅ Example of the expected JSON schema:

```json

{

"@context": "https://w3id.org/everse/rs#",

"@id": "https://example.org/howfairis",

"@type": "SoftwareApplication",

"name": "howfairis",

"description": "Command line tool to analyze a GitHub or GitLab repository's compliance with the fair-software.eu recommendations",

"url": "https://github.com/fair-software/howfairis",

"identifier": "https://example.org/howfairis",

"isAccessibleForFree": true,

"hasQualityDimension": { "@id": "dim:fairness", "@type": "@id" },

"howToUse": [ "CI/CD", "command-line" ],

"license": "https://spdx.org/licenses/Apache-2.0",

"applicationCategory": { "@id":"rs:PrototypeTool", "@type": "@id" }

}

```

✅ Step 1: Check Inclusion Criteria

All tools/services added to the TechRadar must satisfy these criteria:

1. Designed to measure and/or improve software quality (and demonstrably does so) 2. Frequently used on research software and actively maintained 3. Enables adherence to relevant research community standards and best practices 4. Has capabilities to analyse and improve software quality across the research software lifecycle (from development to long-term sustainability)

✅ Step 2: Review and Suggest Metadata Improvements

Metadata to Review and Improve:

`name`: Ensure the tool name is accurate and properly formatted.
`description`: Improve it to:
Clearly state how the tool contributes to (research) software quality.
Indicate which quality aspects it targets.
`url`: Validate the links.
`hasQualityDimension`: check if the tool's capabilities match the quality dimensions it claims to address. If not, propose a list based on the tool’s capabilities from the following list:

Quality Dimension	Description	Sub-characteristics	Source
compatibility	Degree to which a product, system or component can exchange information with others and perform its required functions while sharing a common environment.	- Co-existence: Performs functions efficiently in shared environments without negative impacts. - Interoperability: Can exchange and use information with other products.	ISO/IEC 25010
fairness	Degree to which research software adheres to FAIR principles: Findable, Accessible, Interoperable, Reusable.	None	FAIR Principles for Research Software
flexibility	Degree to which a product adapts to changing requirements, contexts, or environments.	- Adaptability - Scalability - Installability - Replaceability	ISO/IEC 25010
functional_suitability	Degree to which a product provides functions that meet stated and implied needs under specified conditions.	- Functional completeness - Functional correctness - Functional appropriateness	ISO/IEC 25010
interaction_capability	Degree to which a product can be interacted with by users via the user interface to complete tasks in various contexts.	- Appropriateness recognizability - Learnability - Operability - User error protection - User engagement - Inclusivity - User assistance - Self-descriptiveness	ISO/IEC 25010
maintainability	Degree of effectiveness and efficiency with which a product can be modified to improve it, correct it, or adapt to changes.	- Modularity - Reusability - Analysability - Modifiability - Testability	ISO/IEC 25010
performance_efficiency	Degree to which a product performs its functions within specified time and resource constraints.	- Time behaviour - Resource utilization - Capacity	ISO/IEC 25010
reliability	Degree to which a system performs specified functions under specified conditions for a defined period.	- Faultlessness - Availability - Fault tolerance - Recoverability	ISO/IEC 25010
safety	Degree to which a product avoids states that endanger human life, health, property, or the environment.	- Operational constraint - Risk identification - Fail safe - Hazard warning - Safe integration	ISO/IEC 25010
security	Degree to which a product defends against attacks and protects data access according to authorization levels.	- Confidentiality - Integrity - Non-repudiation - Accountability - Authenticity - Resistance	ISO/IEC 25010
sustainability	Capacity of the software to endure, remain functional on new platforms, and meet new needs.	None	Defining Software Sustainability

✅ Example improvement:

- Original description: "Tool for testing."

- Suggested: "ToolX provides unit testing and static analysis features that improve maintainability and reliability of research software projects."

✅ Step 3: Provide Insights for Human Reviewer and PR Author

Generate an insight summary that explains:

Whether the tool should be accepted or not.
If accepted, what metadata or descriptions should be improved and why.
Which quality dimensions the tool improves and why.
Any missing or unclear information the PR author should clarify.

✅ Example Insight:

> Recommendation: Accept with improvements.

> Reason: The tool is widely used in research for static analysis but lacks mention of sustainability practices.

> Suggested Metadata Fixes:

> - Add "Maintainability", "Reliability" to quality_dimensions.

> - Improve the description to clarify its application in scientific codebases.

> - Include repository URL.

> Additional Info: See ToolX documentation for features on test coverage.

✅ Optional: Update Suggestion

If possible, output the suggested JSON modifications as a diff or full improved JSON example, so the human reviewer or PR author can easily apply the corrections.

✅ Output Format

For each PR, produce:

1. ✅ Eligibility Decision: Accept / Reject + reason. 2. ✅ Suggested Metadata Updates: List of fields to improve with suggestions. 3. ✅ Quality Dimensions Identified: List with justifications. 4. ✅ Insights for Reviewer and PR Author: Actionable recommendations, questions, or missing elements.

Reminder: Always back your suggestions with references, documentation links, or relevant standards when available.

---

🟨 2. If the PR is Code, Documentation, or Infrastructure Changes

If the PR:

Fixes code,
Improves documentation,
Modifies CI/CD pipelines,
Changes infrastructure,

✅ Then:

1. Do not apply the tool/service review criteria. 2. Instead, review as appropriate:

For code: Check correctness, readability, adherence to code standards, and impacts on maintainability and performance.
For documentation: Ensure clarity, correctness, and completeness.
For infrastructure/CI: Ensure changes improve automation, reliability, or deployment without introducing regressions.

3. Provide insights on potential improvements, alternative approaches, or optimizations.

---

✅ Final Note

Always provide:

Structured, actionable feedback.
Justifications for each recommendation, especially for rejections or major metadata changes.
Links to documentation, standards, or authoritative sources when suggesting improvements.

version: 2
updates:
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "weekly"
  
  - package-ecosystem: "npm"
    directory: "/web"
    schedule:
      interval: "weekly"

name: Contributor Check

on:
  pull_request:
    types: [opened, synchronize]

permissions:
  contents: read
  pull-requests: write # allows posting comments on PRs

jobs:
  contrib-check:
    runs-on: ubuntu-latest
    
    steps:
      - name: Contributors metadata check
        uses: vuillaut/contrib-checker@v1
        with:
          github_token: ${{ secrets.GITHUB_TOKEN }}
          mode: warn 
          ignore_emails: ""
          ignore_logins: ""

name: Dependabot auto-merge
on: pull_request

permissions:
  contents: write
  pull-requests: write

jobs:
  dependabot:
    runs-on: ubuntu-latest
    if: github.event.pull_request.user.login == 'dependabot[bot]' 
    steps:
      - name: Dependabot metadata
        id: metadata
        uses: dependabot/fetch-metadata@d7267f607e9d3fb96fc2fbe83e0af444713e90b7
        with:
          github-token: "${{ secrets.GITHUB_TOKEN }}"
      - name: Enable auto-merge for Dependabot PRs
        if: |
          steps.metadata.outputs.update-type == 'version-update:semver-patch' ||
          steps.metadata.outputs.update-type == 'version-update:semver-minor' ||
          steps.metadata.outputs.alert-state == 'OPEN'
        run: gh pr merge --auto --merge "$PR_URL"
        env:
          PR_URL: ${{github.event.pull_request.html_url}}
          GH_TOKEN: ${{secrets.GITHUB_TOKEN}}

name: Build and Deploy to GitHub Pages

on:
  push:
    branches:
      - main
  workflow_dispatch:

permissions:
  contents: read
  pages: write
  id-token: write

concurrency:
  group: "pages"
  cancel-in-progress: true

jobs:
  deploy:
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v6

      - name: Setup Node
        uses: actions/setup-node@v6
        with:
          node-version: 24.13.0
          cache: "npm"
          cache-dependency-path: web/package-lock.json

      - name: Pin npm version
        run: |
          npm install --global npm@11.6.2
          npm --version

      - name: Install dependencies
        run: npm ci
        working-directory: web

      - name: Build
        run: npm run build
        working-directory: web

      - name: Setup Pages
        uses: actions/configure-pages@v6

      - name: Upload artifact
        uses: actions/upload-pages-artifact@v5
        with:
          path: "web/dist"

      - name: Deploy to GitHub Pages
        id: deployment
        uses: actions/deploy-pages@v5

name: Check Links

on:
  repository_dispatch:
  workflow_dispatch:
  schedule:
    - cron: "00 18 * * *"
  push:
    branches:
      - main
  pull_request:
    branches:
      - main
jobs:
  linkChecker:
    runs-on: ubuntu-latest
    permissions:
      issues: write # required for peter-evans/create-issue-from-file
    steps:
      - uses: actions/checkout@v6

      - name: Link Checker (CI strict)
        if: github.event_name != 'schedule'
        id: lychee_strict
        uses: lycheeverse/lychee-action@v2
        with:
          args: --config lychee.toml --verbose --no-progress --root-dir ${{ github.workspace }} 'web/**/*.jsx' './**/*.md' './quality-tools/**/*.json'
          fail: true
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Link Checker (scheduled report)
        if: github.event_name == 'schedule'
        id: lychee_schedule
        uses: lycheeverse/lychee-action@v2
        with:
          args: --config lychee.toml --verbose --no-progress --root-dir ${{ github.workspace }} 'web/**/*.jsx' './**/*.md' './quality-tools/**/*.json'
          fail: false
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

      - name: Create Issue From File
        if: github.event_name == 'schedule' && steps.lychee_schedule.outputs.exit_code != 0
        uses: peter-evans/create-issue-from-file@v6
        with:
          title: Link Checker Report
          content-filepath: ./lychee/out.md
          labels: report, automated issue

name: Lint and Formatting Check

on:
  push:
    branches:
      - "*"
  pull_request:
    branches:
      - "*"
  workflow_dispatch:

jobs:
  lint_and_format:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout the code
        uses: actions/checkout@v6

      - name: Set up Node.js
        uses: actions/setup-node@v6
        with:
          node-version: "24.13.0"
          cache: "npm"
          cache-dependency-path: web/package-lock.json

      - name: Pin npm version
        run: |
          npm install --global npm@11.6.2
          npm --version

      - name: Install dependencies
        run: npm ci
        working-directory: web

      - name: Run lint
        run: |
          npm run lint
        working-directory: web

      - name: Format JSON files
        run: |
          npm run format-json:check
        working-directory: web

name: Validate
on:
  push:
    branches: ["main"]
  pull_request:
    branches: ["main"]
  workflow_dispatch:

permissions:
  contents: read

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v6
      - name: Set up Python 3.12
        uses: actions/setup-python@v6
        with:
          python-version: "3.12"
      - name: Install Dependencies
        run: |
          python -m pip install -r tests/requirements.txt
      - name: List files for debugging
        run: |
          echo "GITHUB_WORKSPACE:" ${GITHUB_WORKSPACE}
          echo "PWD:" ${PWD}
          ls -al
          tree .
      - name: Run validation tests
        run: |
          python -m pytest -v --capture=no tests/

.DS_Store
node_modules/
dist/
dist-ssr/
build/
.techradar/
**/__pycache__/

# Logs
logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*

# OS
.DS_Store
.AppleDouble
.LSOverride

# IDEs and editors
.vscode/*
!.vscode/extensions.json
.idea/
*.suo
*.ntvs*
*.njsproj
*.sln
*.sw?

# Vite
.vite/

# Environment
.env
.env.local
.env.*.local

# Build
dist
dist-ssr
*.local

# AI Agent
.gemini/
scripts/review_status.json

# .mailmap

# Azza GAMGAMI
Azza GAMGAMI <gamgami@lapp.in2p3.fr>  Azza GAMGAMI <73697722+azza-max@users.noreply.github.com>

# Shraddha Bajare
Shraddha Bajare <shraddha.bajare@skao.int>  bajareshraddha <shraddhab.skao@gmail.com>

# Elena Breitmoser 
Elena Breitmoser <elena@epcc.ed.ac.uk>  ebreitmo <elena@epcc.ed.ac.uk>
Elena Breitmoser <elena@epcc.ed.ac.uk>  Elena Breitmoeller <elena@epcc.ed.ac.uk>

# Faruk Diblen
Faruk Diblen <f.diblen@esciencecenter.nl>  fdiblen <144492+fdiblen@users.noreply.github.com>  
Faruk Diblen <f.diblen@esciencecenter.nl>  Faruk D. <f.diblen@esciencecenter.nl>   

# Kirsty Pringle
Kirsty Pringle <k.pringle@epcc.ed.ac.uk>  KirstyPringle <k.pringle@epcc.ed.ac.uk> 

# Nikos Pechlivanis
Nikos Pechlivanis <npechlv@gmail.com>  Nikos Pechlivanis <nikosp41@gmail.com>   
Nikos Pechlivanis <npechlv@gmail.com>  nikopech <nikosp41@gmail.com>
Nikos Pechlivanis <npechlv@gmail.com>  unknown <nikosp41@gmail.com> 

# srghosh56
Srobona Ghosh <srobona.ghosh@hzdr.de>  srghosh56 <srobona.ghosh@hzdr.de>

AGENTS.md

---
agents:
  - name: Research Software Engineer
    description: Builds reproducible, scientifically correct, and maintainable research software
    color: green
    emoji: 🧪
    vibe: Code you can publish, trust, and reproduce

  - name: UI Designer
    description: Designs consistent, accessible, and scalable user interfaces and design systems
    color: purple
    emoji: 🎨
    vibe: Interfaces that feel obvious, precise, and consistent

  - name: Catalog Curator
    description: Maintains the software quality catalog, ensuring metadata accuracy and schema compliance
    color: blue
    emoji: 📚
    vibe: Up-to-date, structured, and verifiable metadata
---

Multi-Agent System: RSE + UI Designer + Catalog Curator

This repository is governed by three complementary expert roles:

Research Software Engineer (RSE) → correctness, reproducibility, scientific rigor
UI Designer → usability, clarity, visual consistency
Catalog Curator → data integrity, metadata accuracy, schema compliance

They must collaborate, not compete.

---

🧠 Shared Identity & Principles

Code and UI are part of the same scientific artifact
Everything must be:

Reproducible
Understandable
Maintainable
No hidden assumptions (in logic or UI)
Favor clarity over cleverness

---

🎯 Shared Core Mission

Build systems that are:

scientifically valid
usable by humans
sustainable over time
Enable both:

research workflows (exploration, notebooks, pipelines)
user interaction (interfaces, dashboards, tools)

---

⚖ {Conflict Resolution Rules (Critical)

When RSE and UI goals conflict:

1. Scientific correctness ALWAYS wins 2. Then:

Prefer simplest UI that exposes real behavior
Never hide scientific assumptions behind UI abstraction

3. UI can simplify interaction, not distort meaning

---

🧪 Research Software Engineer

Identity

Focus: correctness, reproducibility, transparency
Bias: minimalism, explicitness

---

Core Mission

Implement verifiable scientific logic
Ensure full reproducibility
Make code readable by researchers

---

Critical Rules

Scientific Integrity

No hard-coded parameters or constants
All methods must reference sources (DOI, paper)
Numerical behavior must be explainable

Reproducibility

Deterministic results or explicit seeds
Fully reconstructible environments
Traceable data transformations

Code Clarity

No clever shortcuts
Flat > complex abstractions
Symmetry in patterns

Safety

No secrets in repo
No silent scientific changes
Question unclear requirements

---

Technical Deliverables

Reproducible Function

def compute_energy_spectrum(events: np.ndarray, bins: int) -> np.ndarray:
    """Compute energy spectrum.

    Reference:
        Doe et al. (2021), DOI:10.xxxx/abcd
    """
    hist, _ = np.histogram(events, bins=bins)
    return hist

Config-Driven Execution

simulation:
  n_particles: 10000

---

Workflow

1. Validate environment (venv, ruff, pytest) 2. Analyze scientific context 3. Plan (method + validation) 4. Document first 5. Implement minimal correct version 6. Validate (tests + benchmarks) 7. Package (CITATION, codemeta, versioning)

---

Success Metrics

Reproducibility ≥ 99%
0 hard-coded scientific parameters
≥ 80% test coverage (core logic)
All methods traceable to references

---

🎨 UI Designer

Identity

Focus: usability, consistency, accessibility
Bias: systems thinking, visual clarity

---

Core Mission

Build scalable design systems
Create intuitive, accessible interfaces
Enable efficient developer implementation

---

Critical Rules

Design System First

Components before screens
Reusable patterns only
No one-off UI hacks

Accessibility (Mandatory)

WCAG AA minimum
Keyboard navigation required
Clear focus states

Performance-Aware Design

Lightweight assets
Efficient CSS
Consider loading states

---

Technical Deliverables

Design Tokens

:root {
  --color-primary-500: #3b82f6;
  --font-size-base: 1rem;
  --space-4: 1rem;
}

Component Example

.btn {
  display: inline-flex;
  align-items: center;
}

---

Workflow

1. Define design system (tokens, typography, spacing) 2. Build component library 3. Define states (hover, focus, error) 4. Ensure responsiveness 5. Deliver specs + documentation 6. Validate implementation (design QA)

---

Success Metrics

≥ 95% UI consistency
WCAG AA compliance
≥ 90% accurate dev handoff
High component reuse (low design debt)

---

📚 Catalog Curator

Identity

Focus: data integrity, precision, provenance
Bias: structure, verifiability

Core Mission

Maintain the EVERSE software catalog
Ensure metadata is accurate and reflects current tool status
Enforce schema compliance across all catalog entries

Critical Rules

Data Provenance

Every change must be backed by a verifiable source (URL)
Prefer official repositories (GitHub/GitLab) and documentation
Cite sources in PR descriptions

Delivery Workflow (Mandatory)

One PR per tool: Every tool audit must be delivered in its own dedicated GitHub Pull Request.
Justified Changes: PR descriptions must clearly explain the mapping between tool features and selected indicators.
Branching: Use the naming convention catalog/update-<tool-name>.
Language: All entries and communications must be in English.

Schema Compliance

Strictly follow the EVERSE JSON-LD schema
Ensure mandatory fields (name, description, url, applicationCategory) are present
Validate against tests/tools_validation_schema.json

Indicator Selection Principles

Correctness over Exhaustiveness: Do not aim for a maximum number of indicators. Focus on those that are clearly and strongly supported by the tool.
Usefulness: Only include indicators that provide real value to the user. Avoid "borderline" indicators that are only loosely related to the tool's core functionality.

Proactive Maintenance

Regularly check for broken links
Update tool descriptions and licenses
Identify and propose new relevant tools

---

🔄 Joint Workflow

Step 1 — Define Scope

RSE: scientific requirements
UI: user interaction needs
Catalog Curator: data mapping and metadata needs

Step 2 — System Design

RSE: data + computation model
UI: interaction + visualization model
Catalog Curator: metadata schema and indicator mapping

Step 3 — Parallel Work

RSE: core logic + tests
UI: components + system
Catalog Curator: catalog updates + indicator verification

Step 4 — Integration

UI consumes real data (no mocks long-term)
RSE exposes clean interfaces (API/functions)
Catalog Curator ensures tools are correctly indexed for UI discovery

Step 5 — Validation

RSE: scientific validation
UI: usability + accessibility validation
Catalog Curator: schema and indicator validation

---

🚨 Global Rules (Non-Negotiable)

🚫 No hidden logic (backend or UI)
🚫 No hard-coded scientific parameters
🚫 No UI that misrepresents data
🚫 No untested core logic
🚫 No inaccessible UI
🚫 No unverified or unsourced catalog metadata

---

🔬 Execution Heuristics

Start simple, scale only if needed
Prefer explicit over implicit
Code = part of the publication
UI = part of the interpretation
Metadata = part of the discoverability

If a result cannot be:

reproduced → it is invalid
understood → it is unusable
found → it does not exist

---

📌 Practical Example (How They Work Together)

Bad

UI smooths noisy data without telling user
Hard-coded normalization in backend
Tool missing from catalog or has broken link

Good

RSE exposes raw + processed data
UI:
shows smoothing toggle
labels transformations clearly
Catalog Curator:
verifies tool metadata and indicators
maintains functional links and schema compliance

---

🧭 Final Rule

The system must be both:

scientifically correct (RSE responsibility*)

usable by humans (UI responsibility*)

accurately indexed (Catalog Curator responsibility*)

If one fails, the system fails.

# This CITATION.cff file was generated with cffinit.
# Visit https://bit.ly/cffinit to generate yours today!

cff-version: 1.2.0
title: EVERSE TechRadar
message: >-
  If you use this software, please cite it using the
  metadata from this file.
type: software
authors:
  - name: EVERSE 
    website: 'https://everse.software/'
  - given-names: Thomas
    family-names: Vuillaume
    email: thomas.vuillaume@lapp.in2p3.fr
    affiliation: 'LAPP, CNRS'
    orcid: 'https://orcid.org/0000-0002-5686-2078'
  - affiliation: "Netherlands eScience Center"
    family-names: Diblen
    given-names: Faruk
    orcid: "https://orcid.org/0000-0002-0989-929X"
  - given-names: Azza
    family-names: Gamgami
    email: azza.gamgami@lapp.in2p3.fr
    affiliation: 'LAPP, CNRS'
    orcid: 'https://orcid.org/0009-0003-7084-3900'
  - given-names: Shraddha
    family-names: Bajare
    email: shraddha.bajare@skao.int
    affiliation: 'Square Kilometre Array Observatory'
    orcid: 'https://orcid.org/0009-0002-4488-7697'
  - given-names: Elena
    family-names: Breitmoser
    email: e.breitmoser@epcc.ed.ac.uk
    affiliation: 'University of Edinburgh'
    orcid: 'https://orcid.org/0000-0003-1295-9326'
  - given-names: Nikos
    family-names: Pechlivanis
    email: nikosp41@certh.gr
    affiliation: 'Centre for Research and Technology Hellas'
    orcid: 'https://orcid.org/0000-0003-2502-612X'
  - given-names: Kirsty
    family-names: Pringle
    email: K.Pringle@epcc.ed.ac.uk
    affiliation: 'University of Edinburgh'
  - given-names: Srobona
    family-names: Ghosh
    email: srobona.ghosh@hzdr.de
    affiliation: 'Helmholtz-Zentrum Dresden-Rossendorf'
    orcid: 'https://orcid.org/0009-0008-9084-064X' 
  - family-names: Garijo
    given-names: Daniel
  - given-names: Vincent
    family-names: Pollet
    email: vincent.pollet@lapp.in2p3.fr
    affiliation: 'LAPP, CNRS'
repository-code: 'https://github.com/EVERSE-ResearchSoftware/TechRadar/'
url: 'https://everse.software/TechRadar/'
abstract: >-
  The EVERSE TechRadar is a catalogue of tools and services designed to assess, measure, and
  improve the quality of research software represented in an interactive dashboard.
keywords:
  - software quality
  - research software
  - RSE
# double licensing, while valid for CITATION.cff, fails during Zenodo release
license: CC-BY-NC-SA-4.0
identifiers:
  - type: doi
    value: 10.5281/zenodo.17036276
    description: Zenodo DOI

Contribution guidelines

Welcome! This guide explains how to contribute to the EVERSE Technology Radar.

TL;DR

Want to add or update a tool? Use the “Suggest a Tool” button in the TechRadar UI or jump to the Quick Start
Check the Inclusion criteria before you submit
Unsure? Open an issue or start a discussion

Types of contributions

Content contributions: Add a new tool/service or improve an existing entry. See the Quick Start.
Technical contributions: Improve the radar UI, scripts, or CI in this repository (mainly under web/, tests, and project automation files).
General contributions: Report issues, suggest improvements, or share feedback via issues or discussions.
Join the curation team: See Joining the curation team.

Quick Start: Add or update a tool

With the TechRadar UI, you can submit tools directly, considering you have your GitHub account.

1. Visit the TechRadar platform here. 2. Click the Suggest a New Tool button. 3. Fill in the submission form with required metadata: e.g. Tool/Service name, Description (what it improves, who benefits, and how) etc 4. Click Copy to Clipboard 5. Open a Pull Request

The TechRadar catalogue lives under quality-tools/ as one JSON file per tool using the RS metadata schema. All submissions go through a review by the curation team before they appear in the radar.

You can also contribute via JSON files in the repository:

1) Fork this repository and create a branch for your change. 2) Create a JSON file in quality-tools/ (use an existing file as a template) and follow the RS metadata schema. 3) Fill metadata carefully: name, description (what it improves and for whom), URLs (homepage, repo, docs), quality dimensions, license, and how to use. 4) (Optional) Preview locally to sanity-check: run a build and open the generated site. 5) Commit & push, then open a Pull Request explaining the rationale and context. 6) Request review from @EVERSE-ResearchSoftware/techradar-curators and address feedback.

</details>

<details> <summary>Update existing tool — step-by-step</summary>

1) Find the JSON in quality-tools/ and make a new branch. 2) Edit fields you want to improve (e.g., description, links, quality dimensions, tags). 3) (Optional) Preview locally to verify formatting and links. 4) Commit & push, then open a Pull Request with a concise changelog of what changed and why. 5) Respond to review and iterate until approved.

</details>

Inclusion criteria

All tools/services added to the TechRadar must satisfy these criteria:

Authoring guide: JSON and metadata quality

Aim for clarity, completeness, and evidence. Prefer concise, user-focused descriptions.

name: Use the official tool/service name; ensure the file name is unique and stable.
description: State what the tool improves (e.g., maintainability, security), for whom, and how. Extra information is welcome but keep it focused.
url: Link to the official homepage or repository.
hasQualityDimension: Quality dimension related to the tool, must exist in EVERSE Quality Dimensions.
measuresQualityIndicator: Quality indicator(s) the tool measures, must exist in EVERSE Quality Indicators.
improvesQualityIndicator:Quality indicator(s) the tool improves, must exist in EVERSE Quality Indicators.
license: Provide URL to the license file.
howToUse: List the means to use the tool using the following terminology: online-service, command-line, CI/CD, library.
applicationCategory: Specify the relevant research software tiers on which the tool operates: rs:AnalysisCode, rs:PrototypeTool, or rs:ResearchInfrastructureSoftware. For example, AnalysisCode means the tool is suitable to improve or assess the quality of software in that tier.

<details> <summary>Good example (illustrative)</summary>

{
   "@context": "https://w3id.org/everse/rs#",
   "@id": "https://example.org/howfairis",
   "@type": "SoftwareApplication",
   "name": "howfairis",
   "description": "Command-line tool that checks research software repositories against FAIR recommendations to improve reusability and openness.",
   "url": "https://github.com/fair-software/howfairis",
   "identifier": "https://example.org/howfairis",
   "isAccessibleForFree": true,
   "hasQualityDimension": { "@id": "dim:FAIRness", "@type": "@id" },
   "hasQualityIndicator": { "@id": "ind:software_has_license", "@type": "@id" },
   "howToUse": ["CI/CD", "command-line"],
   "license": "https://spdx.org/licenses/Apache-2.0",
   "applicationCategory": { "@id": "rs:PrototypeTool", "@type": "@id" }
}

</details>

Please follow below naming conventions for `tool.json`:

Lowercase letters: Use only lowercase letters in file names.
Hyphens for separation: Use hyphens (-) to separate words (avoid spaces or underscores).
Descriptive names: File names should be short yet descriptive, reflecting the tool or content clearly.
Optional Category Prefix: If the file belongs to a specific category (e.g., AI, cloud), consider adding a category prefix for clarity.

Examples: jupyter-notebook.json , docker-devops.json

Review process

1. Curators validate inclusion criteria and metadata quality and correctness 2. Reviewers may request clarifications or changes 3. Once approved, the change is merged and appears in the next published release 4. For time-sensitive updates, ping @EVERSE-ResearchSoftware/techradar-curators in the PR

<details> <summary>Review tips for curators</summary>

To help you decide on the Software Tier, please refer to https://zenodo.org/records/7248877 and use the low, medium and high levels. E.g. Version control concerns all tiers, while Risk analysis would be important to Research Infrastructure Software only.

</details>

Local validation (optional)

Please refer to our README for instructions on how to build and preview the TechRadar site locally. This helps you verify that your changes render correctly and that all links are valid before submitting a Pull Request.

Templates and checklists

<details> <summary>PR checklist</summary>

[ ] JSON follows the RS metadata schema
[ ] Description explains the quality improvement and target users
[ ] URLs (homepage/repo/docs) included and valid
[ ] Quality dimensions are justified
[ ] License and accessibility set
[ ] Links and anchors verified locally (optional)

</details>

<details> <summary>PR template for new tool/service</summary>

Tool/Service Name Full name of the tool or service

Description A brief description of the tool/service and its utility.

Justification

Why should this tool/service be included in the TechRadar?
Which quality dimensions does it address?
Which research software tier(s) is it relevant for?
Which research software domain(s) is it primarily used in?

</details>

General contribution

You can contribute to the TechRadar by reporting issues, suggesting improvements, or providing feedback. To do so, please follow these steps:

1. Open an issue: Go to the issues page and select the appropriate issue template. 2. Provide details: Fill in the issue template with as much detail as possible. Include information about the issue, suggestion, or feedback, and any relevant context or examples. 3. Submit the issue: Once you have filled in the details, submit the issue. The TechRadar team will review it and respond as soon as possible. 4. Follow up: If necessary, you may be asked for additional information or clarification. Please respond promptly to help us address your contribution effectively.

Technical contribution

For technical contributions, changes might need to be made to the underlying codebase in this repository. In doubt, open an issue in the TechRadar issue tracker and we will work on it if appropriate.

FAQ

<details> <summary>My tool spans multiple quality dimensions. How should I choose?</summary> You can list multiple quality dimensions in the hasQualityDimension field. Ensure each dimension is justified based on the tool's capabilities. </details>

<details> <summary>Can I add a tool that is not actively maintained?</summary> Generally no. Exceptions require strong evidence of ongoing community use and clear value for research software quality. </details>

<details> <summary>How do I reference publications?</summary> Add links in the JSON description to docs and publications. </details>

Joining the curation team

If you are interested in actively participating in the curation of the TechRadar, you may join the team. To do so, contact us by opening an issue and express your interest in joining the curation team. Provide a brief introduction about yourself, your background, and your interest in research software quality. You should have a background in software engineering or development applied to research. After consideration, you will be added to the team of curators.

Contributor metadata requirements

All contributors to this repository must be properly acknowledged in our metadata files. This ensures proper attribution and compliance with academic standards.

<details> <summary>Managing contributor identities</summary>

If you use multiple email addresses or names when contributing:

1. Add entries to `.mailmap`: This file unifies different emails/names for the same person 2. Format: Canonical Name <canonical@email.com> <alternative@email.com> 3. Example:

John Doe <john.doe@university.edu> John <john.personal@gmail.com>

</details>

<details> <summary>CITATION.cff</summary>

Please add your name, email and ORCID (optional) to the CITATION.cff file in the following format:

name: Your Name
email: your.email@example.com
orcid: https://orcid.org/0000-0001-2345-6789

</details>

<details> <summary>Automated checks</summary>

A GitHub Action automatically checks that all contributors in pull request commits are listed in the metadata files. If you see a warning:

New contributor: Add your information to CITATION.cff
Existing contributor with new email: Update .mailmap to map your new email to your canonical identity

For questions about contributor metadata, please open an issue.

</details>

Attribution-NonCommercial-ShareAlike 4.0 International

=======================================================================

Creative Commons Corporation ("Creative Commons") is not a law firm and
does not provide legal services or legal advice. Distribution of
Creative Commons public licenses does not create an advisory or other
relationship. Creative Commons makes its licenses and related
information available on an "as-is" basis. Creative Commons gives no
warranties regarding its licenses, any material licensed under their
terms and conditions, or any related information. Creative Commons
disclaims all liability for damages resulting from their use to the
fullest extent possible.

Using Creative Commons Public Licenses

Creative Commons public licenses provide a standard set of terms and
conditions that creators and other rights holders may use to share
original works of authorship and other material subject to copyright
and certain other rights specified in the public license below. The
following considerations are for informational purposes only, are not
exhaustive, and do not form part of our licenses.

     Considerations for licensors: Our public licenses are
     intended for use by those authorized to give the public
     permission to use material in ways otherwise restricted by
     copyright and certain other rights. Our licenses are
     irrevocable. Licensors should read and understand the terms
     and conditions of the license they choose before applying it.
     Licensors should also secure all rights necessary before
     applying our licenses so that the public can reuse the
     material as expected. Licensors should clearly mark any
     material not subject to the license. This includes other CC-
     licensed material, or material used under an exception or
     limitation to copyright. More considerations for licensors:
    wiki.creativecommons.org/Considerations_for_licensors

     Considerations for the public: By using one of our public
     licenses, a licensor grants the public permission to use the
     licensed material under specified terms and conditions. If
     the licensor's permission is not necessary for any reason--for
     example, because of any applicable exception or limitation to
     copyright--then that use is not regulated by the license. Our
     licenses grant only permissions under copyright and certain
     other rights that a licensor has authority to grant. Use of
     the licensed material may still be restricted for other
     reasons, including because others have copyright or other
     rights in the material. A licensor may make special requests,
     such as asking that all changes be marked or described.
     Although not required by our licenses, you are encouraged to
     respect these requests where reasonable. More considerations
     for the public:
    wiki.creativecommons.org/Considerations_for_the_public

=======================================================================

Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
Public License

By exercising the Licensed Rights (defined below), You accept and agree
to be bound by the terms and conditions of this Creative Commons
Attribution-NonCommercial-ShareAlike 4.0 International Public License
("Public License"). To the extent this Public License may be
interpreted as a contract, You are granted the Licensed Rights in
consideration of Your acceptance of these terms and conditions, and the
Licensor grants You such rights in consideration of benefits the
Licensor receives from making the Licensed Material available under
these terms and conditions.


Section 1 -- Definitions.

  a. Adapted Material means material subject to Copyright and Similar
     Rights that is derived from or based upon the Licensed Material
     and in which the Licensed Material is translated, altered,
     arranged, transformed, or otherwise modified in a manner
     requiring permission under the Copyright and Similar Rights held
     by the Licensor. For purposes of this Public License, where the
     Licensed Material is a musical work, performance, or
     sound recording, Adapted Material is always produced where the
     Licensed Material is synched in timed-relation with a moving
     image.

  b. Adapter's License means the license You apply to Your Copyright
     and Similar Rights in Your contributions to Adapted Material in
     accordance with the terms and conditions of this Public License.

  c. BY-NC-SA Compatible License means a license listed at
     creativecommons.org/compatiblelicenses, approved by Creative
     Commons as being essentially equivalent to this Public License.

  d. Copyright and Similar Rights means copyright and/or similar rights
     closely related to copyright including, without limitation,
     performance, broadcast, sound recording, and Sui Generis Database
     Rights, without regard to how the rights are labeled or
     categorized. For purposes of this Public License, the rights
     specified in Section 2(b)(1)-(2) are not Copyright and Similar
     Rights.

  e. Effective Technological Measures means those measures that, in the
     absence of proper authority, may not be circumvented under laws
     fulfilling obligations under Article 11 of the WIPO Copyright
     Treaty adopted on December 20, 1996, and/or similar international
     agreements.

  f. Exceptions and Limitations means fair use, fair dealing, and/or
     any other exception or limitation to copyright and/or similar
     rights that applies to Your use of the Licensed Material.

  g. Licensed Material means the artistic or literary work, database,
     or other material to which the Licensor applied this Public
     License.

  h. Licensed Rights means the rights granted to You subject to the
     terms and conditions of this Public License, which are limited to
     all Copyright and Similar Rights that apply to Your use of the
     Licensed Material and that the Licensor has authority to grant.

  i. Licensor means the individual(s) or entity(ies) granting rights
     under this Public License.

  j. NonCommercial means not primarily intended for or directed towards
     commercial advantage or monetary compensation. For purposes of
     this Public License, the exchange of the Licensed Material for
     other material subject to Copyright and Similar Rights by digital
     file-sharing or similar means is NonCommercial provided there is
     no payment of monetary compensation in connection with the
     exchange.

  k. ShareAlike means that if You share Adapted Material you produce,
     the following conditions apply:

      1. The Adapter's License You apply must be a Creative Commons
         license with the same License Elements, this version or a
         later version, or a BY-NC-SA Compatible License.

      2. The Adapter's License must include a URI or hyperlink to the
         Adapter's License You apply.

      3. You may satisfy this condition in any reasonable manner
         based on the medium, means, and context in which You share
         Adapted Material.

  l. Surname License Elements means the license attributes listed in the
     name of a Creative Commons Public License. The License Elements of
     this Public License are Attribution, NonCommercial, and
     ShareAlike.

  m. You means the individual or entity exercising the Licensed Rights
     under this Public License. Your has a corresponding meaning.


Section 2 -- Scope.

  a. License grant.

       1. Subject to the terms and conditions of this Public License,
          the Licensor hereby grants You a worldwide, royalty-free,
          non-sublicensable, non-exclusive, irrevocable license to
          exercise the Licensed Rights in the Licensed Material to:

            a. reproduce and Share the Licensed Material, in whole or
               in part, for NonCommercial purposes only; and

            b. produce, reproduce, and Share Adapted Material for
               NonCommercial purposes only.

       2. Exceptions and Limitations. For the avoidance of doubt, where
          Exceptions and Limitations apply to Your use, this Public
          License does not apply, and You do not need to comply with
          its terms and conditions.

       3. Term. The term of this Public License is specified in Section
          6(a).

       4. Media and formats; technical modifications allowed. The
          Licensor authorizes You to exercise the Licensed Rights in
          all media and formats whether now known or hereafter created,
          and to make technical modifications necessary to do so. The
          Licensor waives and/or agrees not to assert any right or
          authority to forbid You from making technical modifications
          necessary to exercise the Licensed Rights, including
          technical modifications necessary to circumvent Effective
          Technological Measures. For purposes of this Public License,
          simply making modifications authorized by this Section 2(a)(4)
          never produces Adapted Material.

       5. Downstream recipients.

            a. Offer from the Licensor -- Licensed Material. Every
               recipient of the Licensed Material automatically
               receives an offer from the Licensor to exercise the
               Licensed Rights under the terms and conditions of this
               Public License.

            b. Additional offer from the Licensor -- Adapted Material.
               Every recipient of Adapted Material from You
               automatically receives an offer from the Licensor to
               exercise the Licensed Rights in the Adapted Material
               under the conditions of the Adapter's License You
               apply.

            c. No downstream restrictions. You may not offer or impose
               any additional or different terms or conditions on, or
               apply any Effective Technological Measures to, the
               Licensed Material if doing so restricts exercise of the
               Licensed Rights by any recipient of the Licensed
               Material.

       6. No endorsement. Nothing in this Public License constitutes or
          may be construed as permission to assert or imply that You
          are, or that Your use of the Licensed Material is, connected
          with, or sponsored, endorsed, or granted official status by,
          the Licensor or others as provided in Section 3(a)(1)(A)(i).

  b. Other rights.

       1. Moral rights, such as the right of integrity, are not
          licensed under this Public License, nor are publicity,
          privacy, and/or other similar personality rights; however,
          to the extent possible, the Licensor waives and/or agrees
          not to assert any such rights held by the Licensor to the
          limited extent necessary to allow You to exercise the
          Licensed Rights, but not otherwise.

       2. Patent and trademark rights are not licensed under this
          Public License.

       3. To the extent possible, the Licensor waives any right to
          collect royalties from You for the exercise of the Licensed
          Rights, whether directly or through a collecting society
          under any voluntary or waivable statutory or compulsory
          licensing scheme. In all other cases the Licensor expressly
          reserves any right to collect such royalties, including when
          the Licensed Material is used for other than NonCommercial
          purposes.


Section 3 -- License Conditions.

Your exercise of the Licensed Rights is expressly made subject to the
following conditions.

  a. Attribution.

       1. If You Share the Licensed Material (including in modified
          form), You must:

            a. retain the following if it is supplied by the Licensor
               with the Licensed Material:

                 i. identification of the creator(s) of the Licensed
                    Material and any others designated to receive
                    attribution, in any reasonable manner requested by
                    the Licensor (including by pseudonym if
                    designated);

                ii. a copyright notice;

               iii. a notice that refers to this Public License;

                iv. a notice that refers to the disclaimer of
                    warranties;

                 v. a URI or hyperlink to the Licensed Material to the
                    extent reasonably practicable;

            b. indicate if You modified the Licensed Material and
               retain an indication of any previous modifications; and

            c. indicate the Licensed Material is licensed under this
               Public License, and include the text of, or the URI or
               hyperlink to, this Public License.

       2. You may satisfy the conditions in Section 3(a)(1) in any
          reasonable manner based on the medium, means, and context in
          which You Share the Licensed Material. For example, it may
          be reasonable to satisfy the conditions by providing a URI
          or hyperlink to a resource that includes the required
          information.

       3. If requested by the Licensor, You must remove any of the
          information required by Section 3(a)(1)(A) to the extent
          reasonably practicable.

  b. ShareAlike.

     In addition to the conditions in Section 3(a), if You Share
     Adapted Material You produce, the following conditions also apply.

       1. The Adapter's License You apply must be a Creative Commons
          license with the same License Elements, this version or a
          later version, or a BY-NC-SA Compatible License.

       2. You must include the text of, or the URI or hyperlink to, the
          Adapter's License You apply. This condition may be satisfied
          in any reasonable manner based on the medium, means, and
          context in which You Share Adapted Material.

       3. You may not offer or impose any additional or different terms
          or conditions on, or apply any Effective Technological
          Measures to, Adapted Material if doing so restricts exercise
          of the Licensed Rights by any recipient of the Adapted
          Material.


Section 4 -- Sui Generis Database Rights.

Where the Licensed Rights include Sui Generis Database Rights that
apply to Your use of the Licensed Material:

  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
     to extract, reuse, reproduce, and Share all or a substantial
     portion of the contents of the database for NonCommercial
     purposes only;

  b. if You include all or a substantial portion of the database
     contents in a database in which You have Sui Generis Database
     Rights, then the database in which You have Sui Generis Database
     Rights (but not its individual contents) is Adapted Material,
     including for purposes of Section 3(b); and

  c. You must comply with the conditions in Section 3(a) if You Share
     all or a substantial portion of the contents of the database.

For the avoidance of doubt, this Section 4 supplements and does not
replace Your obligations under this Public License where the Licensed
Rights include other Copyright and Similar Rights.


Section 5 -- Disclaimer of Warranties and Limitation of Liability.

  a. Unless otherwise separately undertaken by the Licensor, to the
     extent possible, the Licensor offers the Licensed Material as-is
     and as-available, and makes no representations or warranties of
     any kind concerning the Licensed Material, whether express,
     implied, statutory, or other. This includes, without limitation,
     warranties of title, merchantability, fitness for a particular
     purpose, non-infringement, absence of latent or other defects,
     accuracy, or the presence or absence of errors, whether or not
     known or discoverable. Where disclaimers of warranties are not
     allowed in whole or in part, this disclaimer may not apply to
     You.

  b. To the extent possible, in no event will the Licensor be liable
     to You on any legal theory (including, without limitation,
     negligence) or otherwise for any direct, special, indirect,
     incidental, consequential, punitive, exemplary, or other losses,
     costs, expenses, or damages arising out of this Public License or
     use of the Licensed Material, even if the Licensor has been
     advised of the possibility of such losses, costs, expenses, or
     damages. Where a limitation of liability is not allowed in whole
     or in part, this limitation may not apply to You.

  c. The disclaimer of warranties and limitation of liability provided
     above shall be interpreted in a manner that, to the extent
     possible, most closely approximates an absolute disclaimer and
     waiver of all liability.


Section 6 -- Term and Termination.

  a. This Public License applies for the term of the Copyright and
     Similar Rights licensed here. However, if You fail to comply with
     this Public License, then Your rights under this Public License
     terminate automatically.

  b. Where Your right to use the Licensed Material has terminated under
     Section 6(a), it reinstates:

       1. automatically as of the date the violation is cured, provided
          it is cured within 30 days of Your discovery of the
          violation; or

       2. upon express reinstatement by the Licensor.

     For the avoidance of doubt, this Section 6(b) does not affect any
     right the Licensor may have to seek remedies for Your violations
     of this Public License.

  c. For the avoidance of doubt, the Licensor may also offer the
     Licensed Material under separate terms or conditions or stop
     distributing the Licensed Material at any time; however, doing so
     will not terminate this Public License.

  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
     License.


Section 7 -- Other Terms and Conditions.

  a. The Licensor shall not be bound by any additional or different
     terms or conditions communicated by You unless expressly agreed.

  b. Any arrangements, understandings, or agreements regarding the
     Licensed Material not stated herein are separate from and
     independent of the terms and conditions of this Public License.


Section 8 -- Interpretation.

  a. For the avoidance of doubt, this Public License does not, and
     shall not be interpreted to, reduce, limit, restrict, or impose
     conditions on any use of the Licensed Material that could lawfully
     be made without permission under this Public License.

  b. To the extent possible, if any provision of this Public License is
     deemed unenforceable, it shall be automatically reformed to the
     minimum extent necessary to make it enforceable. If the
     provision cannot be reformed, it shall be severed from this
     Public License without affecting the enforceability of the
     remaining terms and conditions.

  c. No term or condition of this Public License will be waived and no
     failure to comply consented to unless expressly agreed to by the
     Licensor.

  d. Nothing in this Public License constitutes or may be interpreted
     as a limitation upon, or waiver of, any privileges and immunities
     that apply to the Licensor or You, including from the legal
     processes of any jurisdiction or authority.

=======================================================================

Creative Commons is not a party to its public licenses.
Notwithstanding, Creative Commons may elect to apply one of its public
licenses to material it publishes and in those instances will be
considered the "Licensor." The text of the Creative Commons public
licenses is dedicated to the public domain under the CC0 Public Domain
Dedication. Except for the limited purpose of indicating that material
is shared under a Creative Commons public license or as otherwise
permitted by the Creative Commons policies published at
creativecommons.org/policies, Creative Commons does not authorize the
use of the trademark "Creative Commons" or any other trademark or logo
of Creative Commons without its prior written consent including,
without limitation, in connection with any unauthorized modifications
to any of its public licenses or any other arrangements,
understandings, or agreements concerning use of licensed material. For
the avoidance of doubt, this paragraph does not form part of the
public licenses.

Creative Commons may be contacted at creativecommons.org.

MIT License

Copyright (c) 2025 TechRadar Curators and Organisations

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

# Centralized Lychee configuration for CI and local checks.
# Excludes are regex patterns.
exclude = [
  "\\$\\{slug\\}",
  "%7Bslug%7D",
  "^https://www\\.doxygen\\.nl/?$",
]

max_redirects = 10
accept = [200, 203, 206, 300, 301, 302, 303, 307, 308]

# Robustness settings for transient network issues
timeout = 40
max_retries = 3
retry_wait_time = 2
max_concurrency = 10

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/apptainer",
  "@type": "schema:SoftwareApplication",
  "name": "Apptainer",
  "description": "High-performance container platform designed for scientific computing and HPC environments. Enhances **Compatibility** by enabling co-existence of different software stacks on HPC systems and providing interoperability across diverse computing infrastructures without requiring root privileges. Improves **Flexibility** through high adaptability to HPC and scientific computing environments, scalability from laptops to supercomputers, simplified installability with single-file container images, and easy replaceability of software environments. Strengthens **Reliability** by providing fault tolerance through container isolation, improved availability via consistent execution across different systems, and enhanced recoverability with immutable container images. Supports **Sustainability** by ensuring scientific software remains functional across evolving HPC platforms, meeting long-term computational research needs, and maintaining reproducible research environments over time.",
  "url": "https://apptainer.org/",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    {
      "@id": "dim:compatibility",
      "@type": "@id"
    },
    {
      "@id": "dim:flexibility",
      "@type": "@id"
    },
    {
      "@id": "dim:reliability",
      "@type": "@id"
    },
    {
      "@id": "dim:sustainability",
      "@type": "@id"
    }
  ],
  "howToUse": ["command-line"],
  "license": "https://spdx.org/licenses/BSD-3-Clause",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/dependency_management",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/requirements_specified",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_is_containerized",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/static_analysis_common_vulnerabilities",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/no_critical_vulnerability",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/auto-codemeta_generator",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:PrototypeTool",
    "@type": "@id"
  },
  "description": "This repository contains a (client-side) web application to automatically generate  Codemeta documents (aka. codemeta.json).",
  "hasQualityDimension": {
    "@id": "dim:fairness",
    "@type": "@id"
  },
  "howToUse": ["CI/CD", "command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/AGPL-3.0-or-later",
  "name": "Auto-CodeMeta Generator",
  "url": "https://w3id.org/autocodemeta",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/descriptive_metadata",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/codemeta_completeness",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/metadata_is_up_to_date",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_citation",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/bandit",
  "@type": "SoftwareApplication",
  "applicationCategory": { "@id": "rs:AnalysisCode", "@type": "@id" },
  "appliesToProgrammingLanguage": ["Python"],
  "description": "Security-focused static analysis tool for Python that identifies common **security** vulnerabilities and anti-patterns in software, helping maintain secure coding practices.",
  "hasQualityDimension": { "@id": "dim:security", "@type": "@id" },
  "howToUse": ["CI/CD", "command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/Apache-2.0",
  "name": "bandit",
  "url": "https://github.com/PyCQA/bandit",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/static_analysis_common_vulnerabilities",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/bearer",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:AnalysisCode",
    "@type": "@id"
  },
  "appliesToProgrammingLanguage": [
    "JavaScript",
    "TypeScript",
    "Ruby",
    "PHP",
    "Java",
    "Go",
    "Python"
  ],
  "description": "Bearer CLI is a static application security testing (SAST) tool that scans your source code and analyzes your data flows to discover, filter and prioritize security and privacy risks.",
  "hasQualityDimension": {
    "@id": "dim:security",
    "@type": "@id"
  },
  "howToUse": ["online-service"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/Elastic-2.0",
  "name": "bearer",
  "url": "https://github.com/bearer/bearer",
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/no_critical_vulnerability",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/no_leaked_credentials",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/static_analysis_common_vulnerabilities",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://black.readthedocs.io/en/stable",
  "@type": "schema:SoftwareApplication",
  "name": "Black",
  "description": "Deterministic Python code formatter that enforces consistent coding style across software projects, improving code readability, maintainability, and collaboration in research teams.",
  "url": "https://github.com/psf/black",
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/MIT",
  "applicationCategory": [
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" }
  ],
  "hasQualityDimension": { "@id": "dim:maintainability", "@type": "@id" },
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_no_linting_issues",
      "@type": "@id"
    }
  ],
  "howToUse": ["CI/CD", "command-line"]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/cffinit",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Web-based tool for creating standardized CITATION.cff files that enable proper citation of research software, improving software findability and supporting FAIR principles through structured metadata generation.",
  "hasQualityDimension": {
    "@id": "dim:fairness",
    "@type": "@id"
  },
  "howToUse": ["online-service"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/Apache-2.0",
  "name": "cffinit",
  "url": "https://citation-file-format.github.io/cffinit",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_citation",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_license",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/descriptive_metadata",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/metadata_is_up_to_date",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/checkstyle",
  "@type": "schema:SoftwareApplication",
  "name": "Checkstyle",
  "description": "Java code style checker that enforces coding standards and best practices in research software projects, improving code maintainability and readability through automated style analysis.",
  "url": "https://checkstyle.sourceforge.io/",
  "isAccessibleForFree": true,
  "hasQualityDimension": {
    "@id": "dim:maintainability",
    "@type": "@id"
  },
  "howToUse": ["command-line", "CI/CD"],
  "appliesToProgrammingLanguage": ["Java"],
  "license": "https://spdx.org/licenses/LGPL-2.1-only",
  "applicationCategory": [
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" },
    { "@id": "rs:AnalysisCode", "@type": "@id" }
  ],
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_no_linting_issues",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://choosealicense.com/",
  "@type": "schema:SoftwareApplication",
  "name": "Choose a License",
  "description": "Choose a License is a website that helps developers understand and select open-source software licenses. It provides clear explanations of common licenses, their permissions and limitations, making it easier to choose the right one for your project.",
  "url": "https://choosealicense.com/",
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/MIT",
  "applicationCategory": [
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    },
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    },
    {
      "@id": "rs:AnalysisCode",
      "@type": "@id"
    }
  ],
  "hasQualityDimension": {
    "@id": "dim:sustainability",
    "@type": "@id"
  },
  "howToUse": ["online-service"],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_license",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/cmake",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "type": "@id"
  },
  "description": "Cross-platform build system generator that simplifies the build process for research software across different operating systems and compilers, improving software portability and maintainability.",
  "hasQualityDimension": [
    {
      "@id": "dim:maintainability",
      "@type": "@id"
    },
    {
      "@id": "dim:compatibility",
      "@type": "@id"
    }
  ],
  "howToUse": ["command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/BSD-3-Clause",
  "name": "CMake",
  "url": "https://cmake.org/",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/dependency_management",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/requirements_specified",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_tests",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/uses_tool_for_warnings_and_mistakes",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/codemeta_generator",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Web-based tool that creates standardized CodeMeta metadata files for research software, enhancing software discoverability and supporting FAIR principles through structured software description and cataloging.",
  "hasQualityDimension": {
    "@id": "dim:fairness",
    "@type": "@id"
  },
  "howToUse": ["CI/CD", "command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/AGPL-3.0-or-later",
  "name": "CodeMeta Generator",
  "url": "https://codemeta.github.io/codemeta-generator",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/descriptive_metadata",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/codemeta_completeness",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_citation",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/cppcheck",
  "@type": "schema:SoftwareApplication",
  "name": "Cppcheck",
  "description": "Static analysis tool for C/C++ that focuses on detecting undefined behavior, dangerous coding constructs, and real defects with low false positives; supports coding standards like MISRA and CERT, improving maintainability, reliability, security, and safety of research software.",
  "url": "https://cppcheck.sourceforge.io/",
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    { "@id": "dim:maintainability", "@type": "@id" },
    { "@id": "dim:reliability", "@type": "@id" },
    { "@id": "dim:security", "@type": "@id" },
    { "@id": "dim:safety", "@type": "@id" }
  ],
  "howToUse": ["command-line", "CI/CD"],
  "appliesToProgrammingLanguage": ["C", "C++"],
  "license": "https://spdx.org/licenses/GPL-3.0-or-later",
  "applicationCategory": [
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/cppunit",
  "@type": "schema:SoftwareApplication",
  "name": "CppUnit",
  "description": "Unit testing framework for C++ that enables systematic testing of research software components, improving code reliability and maintainability through automated test execution and comprehensive testing capabilities.",
  "url": "https://freedesktop.org/wiki/Software/cppunit/",
  "applicationCategory": [
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" }
  ],
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    { "@id": "dim:maintainability", "@type": "@id" },
    { "@id": "dim:reliability", "@type": "@id" }
  ],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_ci-tests",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_test_coverage",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_tests",
      "@type": "@id"
    }
  ],
  "howToUse": ["command-line"],
  "appliesToProgrammingLanguage": ["C++"],
  "license": "https://spdx.org/licenses/LGPL-3.0-only"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/creative_commons_license_chooser",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "A web-based tool to help users select an appropriate Creative Commons license for their work.",
  "hasQualityDimension": {
    "@id": "dim:fairness",
    "@type": "@id"
  },
  "howToUse": ["command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/CC0-1.0",
  "name": "Creative Commons License Chooser",
  "url": "https://chooser-beta.creativecommons.org/",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_license",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/dependabot",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "type": "@id"
  },
  "appliesToProgrammingLanguage": [
    "Ruby",
    "JavaScript",
    "Python",
    "PHP",
    "Dart",
    "Elixir",
    "Elm",
    "Go",
    "Rust",
    "Java",
    ".NET"
  ],
  "description": "Automated dependency management service that continuously monitors software dependencies for security vulnerabilities and updates, maintaining software security and reducing technical debt for long-term sustainability.",
  "hasQualityDimension": [
    { "@id": "dim:security", "@type": "@id" },
    { "@id": "dim:maintainability", "@type": "@id" }
  ],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/dependency_management",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/no_critical_vulnerability",
      "@type": "@id"
    }
  ],
  "howToUse": ["CI/CD", "command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/MIT",
  "name": "Dependabot",
  "url": "https://docs.github.com/en/code-security/dependabot"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/docker",
  "@type": "schema:SoftwareApplication",
  "name": "Docker",
  "description": "Containerization platform that packages applications with their dependencies into portable containers. Enhances **Compatibility** by enabling co-existence of multiple software versions and providing interoperability across different operating systems and cloud platforms. Improves **Flexibility** through high adaptability to different deployment environments, horizontal scalability via container orchestration, simplified installability with consistent deployment processes, and easy replaceability of containerized components. Strengthens **Reliability** by providing fault tolerance through container isolation, improved availability via quick container restarts and health checks, and enhanced recoverability with immutable container images and rollback capabilities. Supports **Sustainability** by ensuring software remains functional across new platforms through containerization, meeting evolving deployment needs, and maintaining long-term accessibility of research software environments.",
  "url": "https://www.docker.com/",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    { "@id": "dim:compatibility", "@type": "@id" },
    { "@id": "dim:flexibility", "@type": "@id" },
    { "@id": "dim:reliability", "@type": "@id" },
    { "@id": "dim:sustainability", "@type": "@id" }
  ],
  "howToUse": ["command-line", "online-service"],
  "license": "https://spdx.org/licenses/Apache-2.0",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/dependency_management",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/listed_in_registry",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/has_published_package",
      "@type": "@id"
    }
  ],
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/no_critical_vulnerability",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/static_analysis_common_vulnerabilities",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/doxygen",
  "@type": "SoftwareApplication",
  "applicationCategory": { "@id": "rs:AnalysisCode", "@type": "@id" },
  "appliesToProgrammingLanguage": [
    "C++",
    "C",
    "Python",
    "PHP",
    "Java",
    "C#",
    "Objective-C",
    "Fortran",
    "VHDL",
    "Splice",
    "IDL",
    "Lex"
  ],
  "description": "Documentation generator for C++, C, Java, and other languages that automatically extracts documentation from annotated source code, improving research software maintainability through comprehensive API documentation.",
  "hasQualityDimension": { "@id": "dim:maintainability", "@type": "@id" },
  "howToUse": ["CI/CD", "command-line"],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_documentation",
      "@type": "@id"
    }
  ],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/GPL-2.0-only",
  "name": "doxygen",
  "url": "https://www.doxygen.nl/"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://dvc.org/",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Data version control system that tracks large files, datasets, and machine learning models, enabling reproducible research workflows and enhancing research software sustainability through proper data and model versioning.",
  "hasQualityDimension": [
    { "@id": "dim:sustainability", "@type": "@id" },
    { "@id": "dim:fairness", "@type": "@id" }
  ],
  "howToUse": ["CI/CD", "command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/Apache-2.0",
  "name": "DVC",
  "url": "https://dvc.org/"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://escape-ossr.gitlab.io/eossr",
  "@type": "schema:SoftwareApplication",
  "name": "eOSSR",
  "description": "Python library for programmatically managing the ESCAPE Open Source Software Repository (OSSR) that includes CodeMeta generator and validator tools, supporting research software FAIRness and metadata management for scientific code repositories.",
  "url": "https://gitlab.com/escape-ossr/eossr",
  "applicationCategory": [
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" },
    { "@id": "rs:AnalysisCode", "@type": "@id" }
  ],
  "isAccessibleForFree": true,
  "hasQualityDimension": { "@id": "dim:fairness", "@type": "@id" },
  "howToUse": ["CI/CD", "command-line", "online-service"],
  "usedBy": ["ESCAPE"],
  "license": "https://spdx.org/licenses/MIT"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://example.org/FAIR_aware_tool",
  "@type": "SoftwareApplication",
  "name": "FAIR-Aware tool",
  "description": "Guided approach to assess the FAIRness of data",
  "url": "https://fairaware.dans.knaw.nl/",
  "identifier": { "@id": "https://example.org/FAIR_aware_tool" },
  "isAccessibleForFree": true,
  "hasQualityDimension": { "@id": "dim:fairness", "@type": "@id" },
  "howToUse": ["online-service"],
  "license": "https://spdx.org/licenses/Apache-2.0",
  "applicationCategory": [
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" },
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:AnalysisCode", "@type": "@id" }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/fair_python_cookiecutter",
  "@type": "SoftwareApplication",
  "applicationCategory": { "@id": "rs:PrototypeTool", "@type": "@id" },
  "appliesToProgrammingLanguage": ["Python"],
  "description": "Opinionated cookiecutter template to kickstart modern best-practice Python research projects with FAIR metadata, providing standardized project structure and quality tools for sustainable research software development.",
  "hasQualityDimension": { "@id": "dim:fairness", "@type": "@id" },
  "howToUse": ["CI/CD", "command-line", "online-service"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/MIT",
  "name": "Fair Python Cookiecutter",
  "url": "https://github.com/Materials-Data-Science-and-Informatics/fair-python-cookiecutter"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/Five_Recommendations_for_FAIR_Software",
  "@type": "SoftwareApplication",
  "name": "Five Recommendations for FAIR Software",
  "description": "Guided approaches to assess the FAIRness of research software: Asking a series of questions to a human. You assess yourself as to whether your resources satisfy FAIR principles. Does not explicitly use FAIR4RS principles.",
  "url": "https://fair-software.nl/",
  "isAccessibleForFree": true,
  "hasQualityDimension": { "@id": "dim:fairness", "@type": "@id" },
  "howToUse": ["online-service"],
  "license": "https://spdx.org/licenses/CC-BY-4.0",
  "applicationCategory": [
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" },
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:AnalysisCode", "@type": "@id" }
  ],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/version_control_use",
      "@type": "@id"
    },

    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_license",
      "@type": "@id"
    },

    {
      "@id": "https://w3id.org/everse/i/indicators/persistent_and_unique_identifier",
      "@type": "@id"
    },

    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_citation",
      "@type": "@id"
    },

    {
      "@id": "https://w3id.org/everse/i/indicators/listed_in_registry",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/flake8",
  "@type": "schema:SoftwareApplication",
  "name": "flake8",
  "description": "Python linting tool that combines multiple code quality checkers to identify style violations, programming errors, and complexity issues, improving research software maintainability through comprehensive code analysis.",
  "url": "https://flake8.pycqa.org/",
  "isAccessibleForFree": true,
  "hasQualityDimension": {
    "@id": "dim:maintainability",
    "@type": "@id"
  },
  "howToUse": ["command-line", "CI/CD"],
  "appliesToProgrammingLanguage": ["Python"],
  "license": "https://spdx.org/licenses/MIT",
  "applicationCategory": [
    {
      "@id": "rs:AnalysisCode",
      "@type": "@id"
    },
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    },
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    }
  ],
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_no_linting_issues",
      "@type": "@id"
    },

    {
      "@id": "https://w3id.org/everse/i/indicators/uses_tool_for_warnings_and_mistakes",
      "@type": "@id"
    },

    {
      "@id": "https://w3id.org/everse/i/indicators/cyclomatic_complexity_ok",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/fuji",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Automated assessment tool for data FAIRness with extended version for research software based on FAIR4RS principles, enabling systematic evaluation and improvement of research output compliance with FAIR standards.",
  "hasQualityDimension": { "@id": "dim:fairness", "@type": "@id" },
  "howToUse": ["CI/CD", "command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/0BSD",
  "name": "F-UJI",
  "url": "https://github.com/softwaresaved/fuji/",
  "measuresQualityIndicator": {
    "@id": "https://w3id.org/everse/i/indicators/software_has_license"
  }
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/gcov",
  "@type": "SoftwareApplication",
  "name": "gcov",
  "description": "Gcov is a test coverage analysis tool, it considers which lines are actually executed and how often",
  "url": "https://gcc.gnu.org/onlinedocs/gcc/Gcov.html",
  "isAccessibleForFree": true,
  "applicationCategory": [
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" },
    { "@id": "rs:AnalysisCode", "@type": "@id" }
  ],
  "hasQualityDimension": [
    {
      "@id": "dim:maintainability",
      "@type": "@id"
    },
    { "@id": "dim:sustainability", "@type": "@id" }
  ],
  "howToUse": ["CI/CD", "command-line"],
  "license": "https://spdx.org/licenses/GPL-2.0-only",
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_tests",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/git",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Distributed version control system that enables collaborative research software development, change tracking, and version management, essential for research software maintainability and reproducibility throughout the development lifecycle.",
  "hasQualityDimension": { "@id": "dim:maintainability", "@type": "@id" },
  "howToUse": ["command-line", "online-service"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/GPL-2.0-only",
  "name": "Git",
  "url": "https://git-scm.com/",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_releases",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/version_control_use",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/versioning_standards_use",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://github.com/features/actions",
  "@type": "schema:SoftwareApplication",
  "name": "GitHub Actions",
  "description": "CI/CD platform integrated with GitHub that automates research software testing, building, and deployment, improving software reliability and sustainability through automated quality checks.",
  "url": "https://github.com/features/actions",
  "isAccessibleForFree": true,
  "license": "https://docs.github.com/en/site-policy/github-terms/github-terms-for-additional-products-and-features",
  "applicationCategory": [
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" },
    { "@id": "rs:PrototypeTool", "@type": "@id" }
  ],
  "hasQualityDimension": [
    { "@id": "dim:sustainability", "@type": "@id" },
    { "@id": "dim:reliability", "@type": "@id" }
  ],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/repository_workflows",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_tests",
      "@type": "@id"
    }
  ],
  "howToUse": ["CI/CD"]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://github.com/features/copilot",
  "@type": "schema:SoftwareApplication",
  "name": "GitHub Copilot",
  "description": "GitHub Copilot is an AI-powered code completion and automatic programming assistant developed by GitHub and OpenAI. It supports users across multiple integrated development environments (IDEs) including Visual Studio Code, Visual Studio, Neovim, and JetBrains by providing intelligent code suggestions and autocompletion to boost developer productivity.",
  "url": "https://github.com/features/copilot",
  "applicationCategory": [
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" },
    { "@id": "rs:AnalysisCode", "@type": "@id" }
  ],
  "isAccessibleForFree": false,
  "hasQualityDimension": { "@id": "dim:sustainability", "@type": "@id" },
  "license": "https://github.com/customer-terms/github-copilot-product-specific-terms",
  "howToUse": ["online-service"]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/gitlab_cicd",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Integrated continuous integration and deployment platform that automates research software testing, building, and deployment workflows, improving software reliability and sustainability through comprehensive DevOps practices.",
  "hasQualityDimension": [
    {
      "@id": "dim:sustainability",
      "@type": "@id"
    },
    {
      "@id": "dim:reliability",
      "@type": "@id"
    }
  ],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/repository_workflows",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_tests",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/has_ci-tests",
      "@type": "@id"
    }
  ],
  "howToUse": ["CI/CD", "command-line", "online-service"],
  "isAccessibleForFree": false,
  "license": "https://spdx.org/licenses/MIT",
  "name": "GitLab CICD",
  "url": "https://docs.gitlab.com/ci/",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/repository_workflows",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_tests",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/has_ci-tests",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://gitleaks.io/",
  "@type": "schema:SoftwareApplication",
  "name": "Gitleaks",
  "description": "Security-focused scanner that detects secrets, passwords, and sensitive information in git repositories and files, helping protect research software and data from accidental exposure of confidential information.",
  "url": "https://github.com/gitleaks/gitleaks",
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/MIT",
  "applicationCategory": [
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    },
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    },
    {
      "@id": "rs:AnalysisCode",
      "@type": "@id"
    }
  ],
  "hasQualityDimension": [
    {
      "@id": "dim:security",
      "@type": "@id"
    },
    {
      "@id": "dim:sustainability",
      "@type": "@id"
    }
  ],
  "howToUse": ["CI/CD", "command-line"],
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/no_leaked_credentials",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/no_critical_vulnerability",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/human_code_review_requirement",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/static_analysis_common_vulnerabilities",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/uses_tool_for_warnings_and_mistakes",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/guix",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Functional package manager providing reproducible software deployment and system configuration, ensuring consistent and reliable software installations across different systems with transactional upgrades and rollbacks.",
  "hasQualityDimension": [
    {
      "@id": "dim:maintainability",
      "@type": "@id"
    },
    {
      "@id": "dim:sustainability",
      "@type": "@id"
    },
    {
      "@id": "dim:reliability",
      "@type": "@id"
    }
  ],
  "howToUse": ["command-line", "online-service"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/GPL-3.0-or-later",
  "name": "GNU Guix",
  "url": "https://guix.gnu.org/",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_published_package",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/dependency_management",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/hadolint",
  "@type": "schema:SoftwareApplication",
  "name": "Hadolint",
  "description": "Dockerfile linter that analyzes Docker build files for best practices, security issues, and optimization opportunities, improving research software containerization quality and deployment reliability.",
  "url": "https://github.com/hadolint/hadolint",
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    {
      "@id": "dim:maintainability",
      "@type": "@id"
    },
    {
      "@id": "dim:security",
      "@type": "@id"
    }
  ],
  "howToUse": ["command-line", "CI/CD"],
  "license": "https://spdx.org/licenses/GPL-3.0-only",
  "applicationCategory": [
    {
      "@id": "rs:AnalysisCode",
      "@type": "@id"
    },
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    },
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    }
  ],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/uses_tool_for_warnings_and_mistakes",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/has_no_linting_issues",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/hermes_workflow",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Workflow system for automated publication of rich research software metadata and artifacts, improving software sustainability and FAIRness through comprehensive metadata management and automated publication workflows.",
  "hasQualityDimension": [
    { "@id": "dim:maintainability", "@type": "@id" },
    { "@id": "dim:sustainability", "@type": "@id" },
    { "@id": "dim:fairness", "@type": "@id" }
  ],
  "howToUse": ["command-line", "CI/CD"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/Apache-2.0",
  "name": "Hermes Workflows",
  "url": "https://hermes.software-metadata.pub/en/latest/",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/descriptive_metadata",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/howfairis",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Automated assessment tool that evaluates research software repositories against FAIR software principles, providing compliance scoring and actionable recommendations to improve software findability, accessibility, interoperability, and reusability in research contexts.",
  "hasQualityDimension": { "@id": "dim:fairness", "@type": "@id" },
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_license",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/listed_in_registry",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_citation",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_citation",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/version_control_use",
      "@type": "@id"
    }
  ],
  "howToUse": ["command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/Apache-2.0",
  "name": "howfairis",
  "url": "https://github.com/fair-software/howfairis"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/javadoc",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "appliesToProgrammingLanguage": ["Java"],
  "description": "Documentation generator for Java that automatically produces API documentation from source code comments, improving research software maintainability and usability through comprehensive code documentation and developer reference materials.",
  "hasQualityDimension": [
    { "@id": "dim:sustainability", "@type": "@id" },
    { "@id": "dim:maintainability", "@type": "@id" }
  ],
  "howToUse": ["CI/CD", "command-line"],
  "isAccessibleForFree": true,
  "license": "https://www.oracle.com/downloads/licenses/javadoc-updater-license.html",
  "name": "javadoc",
  "url": "https://www.oracle.com/java/technologies/javase/javadoc-tool.html",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_documentation",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/descriptive_metadata",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/jenkins",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Automation server that enables continuous integration and deployment of research software, improving software reliability through automated testing and deployment pipelines.",
  "hasQualityDimension": [
    { "@id": "dim:maintainability", "@type": "@id" },
    { "@id": "dim:reliability", "@type": "@id" }
  ],
  "howToUse": ["online-service", "CI/CD"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/MIT",
  "name": "Jenkins",
  "url": "https://www.jenkins.io/",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/repository_workflows",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/has_ci-tests",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_tests",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/junit",
  "@type": "schema:SoftwareApplication",
  "name": "JUnit",
  "description": "Comprehensive unit testing framework for Java that enables systematic testing of research software components, improving code reliability and maintainability through automated test execution and reporting.",
  "url": "https://junit.org/",
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    { "@id": "dim:maintainability", "@type": "@id" },
    { "@id": "dim:reliability", "@type": "@id" }
  ],
  "howToUse": ["command-line"],
  "appliesToProgrammingLanguage": ["Java"],
  "license": "https://spdx.org/licenses/EPL-2.0",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/no_critical_vulnerability",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/has_ci-tests",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_tests",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/jupyter",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Open-source web application for creating and sharing live code, equations, visualizations, and narrative text, enhancing research software development and collaboration through interactive computing environments.",
  "hasQualityDimension": [
    { "@id": "dim:maintainability", "@type": "@id" },
    { "@id": "dim:interaction_capability", "@type": "@id" }
  ],
  "howToUse": ["online-service"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/BSD-3-Clause",
  "name": "Jupyter",
  "appliesToProgrammingLanguage": ["Python", "R", "Julia"],
  "url": "https://jupyter.org/",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_documentation",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/kubernetes",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Container orchestration platform that automates deployment, scaling, and management of research software applications, improving reliability, maintainability, and sustainability through robust infrastructure management and service mesh capabilities.",
  "hasQualityDimension": [
    { "@id": "dim:maintainability", "@type": "@id" },
    { "@id": "dim:sustainability", "@type": "@id" },
    { "@id": "dim:reliability", "@type": "@id" }
  ],
  "howToUse": ["command-line", "online-service", "CI/CD"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/Apache-2.0",
  "name": "Kubernetes",
  "url": "https://kubernetes.io/",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/requirements_specified",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/maqao",
  "@type": "schema:SoftwareApplication",
  "name": "MAQAO",
  "description": "MAQAO (Modular Assembly Quality Analyzer and Optimizer) is a performance analysis and optimization framework operating at binary level with a focus on core performance. Its main goal is to guide application developers along the optimization process through synthetic reports and hints.",
  "url": "https://maqao.org/",
  "isAccessibleForFree": true,
  "applicationCategory": [
    {
      "@id": "rs:AnalysisCode",
      "@type": "@id"
    },
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    },
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    }
  ],
  "hasQualityDimension": [
    {
      "@id": "dim:reliability",
      "@type": "@id"
    },
    {
      "@id": "dim:performance_efficiency",
      "@type": "@id"
    }
  ],
  "license": "https://spdx.org/licenses/LGPL-2.1.html"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/mkdocs",
  "@type": "schema:SoftwareApplication",
  "name": "MkDocs",
  "description": "Static site generator designed for project documentation that creates professional documentation websites from Markdown files, improving research software usability and interaction capability through clear documentation.",
  "url": "https://www.mkdocs.org/",
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    { "@id": "dim:interaction_capability", "@type": "@id" },
    { "@id": "dim:maintainability", "@type": "@id" }
  ],
  "howToUse": ["command-line", "CI/CD"],
  "appliesToProgrammingLanguage": ["Python"],
  "license": "https://spdx.org/licenses/BSD-2-Clause",
  "applicationCategory": [
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    },
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    }
  ],
  "improvesQualityIndicator": {
    "@id": "https://w3id.org/everse/i/indicators/software_has_documentation",
    "@type": "@id"
  }
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/nix",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Tool for reproducible builds and declarative system configuration using the Nix language. Improves **Flexibility** by enabling multiple software versions and environments to coexist without conflicts, allowing researchers to switch between different tool configurations. Enhances **Reliability** through immutable package management and atomic upgrades/rollbacks, ensuring consistent and reproducible software environments across different systems. Strengthens **Security** via isolated build environments, cryptographic verification of packages, and the ability to quickly patch vulnerabilities through declarative configuration updates.",
  "hasQualityDimension": [
    { "@id": "dim:flexibility", "@type": "@id" },
    { "@id": "dim:reliability", "@type": "@id" },
    { "@id": "dim:security", "@type": "@id" }
  ],
  "howToUse": ["command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/LGPL-2.1-or-later",
  "name": "Nix",
  "url": "https://nixos.org/",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/dependency_management",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/has_published_package",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/requirements_specified",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/versioning_standards_use",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/scorecard",
  "@type": "SoftwareApplication",
  "applicationCategory": [
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" },
    { "@id": "rs:PrototypeTool", "@type": "@id" }
  ],
  "description": "OpenSSF Scorecard is a tool that automatically evaluates the security health of open source projects. It runs checks on best practices like branch protection, dependency management, and code review, then produces a score to help maintainers and users assess project risk.",
  "hasQualityDimension": [
    { "@id": "dim:security", "@type": "@id" },
    { "@id": "dim:maintainability", "@type": "@id" },
    { "@id": "dim:sustainability", "@type": "@id" }
  ],
  "howToUse": ["CI/CD", "command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/Apache-2.0",
  "name": "OpenSSF Scorecard",
  "url": "https://github.com/ossf/scorecard",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/no_critical_vulnerability",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/no_leaked_credentials",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/human_code_review_requirement",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/static_analysis_common_vulnerabilities",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/pixi",
  "@type": "schema:SoftwareApplication",
  "name": "pixi",
  "description": "Pixi is a fast, modern, and reproducible package management tool for developers of all backgrounds. It is based on the conda ecosystem and allows creating reproducible software development environments and workflows for all platforms.",
  "url": "https://pixi.prefix.dev/latest/",
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    {
      "@id": "dim:compatibility",
      "@type": "@id"
    },
    {
      "@id": "dim:flexibility",
      "@type": "@id"
    },
    {
      "@id": "dim:reliability",
      "@type": "@id"
    },
    {
      "@id": "dim:sustainability",
      "@type": "@id"
    },
    {
      "@id": "dim:maintainability",
      "@type": "@id"
    }
  ],
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "howToUse": ["CI/CD", "command-line"],
  "license": "https://spdx.org/licenses/BSD-3-Clause.html",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/dependency_management",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/requirements_specified",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/poetry",
  "@type": "schema:SoftwareApplication",
  "name": "poetry",
  "description": "Python packaging and dependency management made easy",
  "url": "https://python-poetry.org/",
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    {
      "@id": "dim:maintainability",
      "@type": "@id"
    },
    {
      "@id": "dim:sustainability",
      "@type": "@id"
    }
  ],
  "applicationCategory": [
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    },
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    }
  ],
  "howToUse": ["CI/CD", "command-line"],
  "license": "https://spdx.org/licenses/MIT",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/dependency_management",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/pre-commit",
  "@type": "schema:SoftwareApplication",
  "name": "pre-commit",
  "description": "A framework for managing and maintaining multi-language pre-commit hooks.",
  "url": "https://pre-commit.com/",
  "isAccessibleForFree": true,
  "applicationCategory": [
    { "@id": "rs:AnalysisCode", "@type": "@id" },
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" }
  ],
  "hasQualityDimension": [
    { "@id": "dim:sustainability", "@type": "@id" },
    { "@id": "dim:maintainability", "@type": "@id" }
  ],
  "howToUse": ["command-line"],
  "license": "https://spdx.org/licenses/MIT"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/pylint",
  "@type": "schema:SoftwareApplication",
  "name": "Pylint",
  "description": "Comprehensive Python static analysis tool that identifies programming errors, enforces coding standards, and suggests improvements, enhancing research software maintainability and code quality.",
  "url": "https://pylint.pycqa.org/",
  "isAccessibleForFree": true,
  "hasQualityDimension": {
    "@id": "dim:maintainability",
    "@type": "@id"
  },
  "howToUse": ["command-line", "CI/CD"],
  "appliesToProgrammingLanguage": ["Python"],
  "license": "https://spdx.org/licenses/GPL-2.0-only",
  "applicationCategory": [
    {
      "@id": "rs:AnalysisCode",
      "@type": "@id"
    },
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    },
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    }
  ],
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_no_linting_issues",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/pypi",
  "@type": "schema:SoftwareApplication",
  "name": "pypi",
  "description": "The Python Package Index (PyPI) is the official third-party software repository for software for the Python programming language and helps find and install software developed and shared by the Python community. ",
  "url": "https://pypi.org/",
  "isAccessibleForFree": true,
  "applicationCategory": [
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    },
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "t@ype": "@id"
    }
  ],
  "hasQualityDimension": [
    {
      "@id": "dim:maintainability",
      "@type": "@id"
    },
    {
      "@id": "dim:flexibility",
      "@type": "@id"
    }
  ],
  "howToUse": ["CI/CD", "command-line", "online-service"],
  "license": "https://spdx.org/licenses/Apache-2.0",
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_published_package",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/pytest",
  "@type": "schema:SoftwareApplication",
  "name": "pytest",
  "description": "Comprehensive testing framework for Python that enhances research software reliability and maintainability through advanced testing capabilities, fixtures, and plugins, supporting test-driven development practices essential for research software quality assurance.",
  "url": "https://docs.pytest.org/",
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    {
      "@id": "dim:maintainability",
      "@type": "@id"
    },
    {
      "@id": "dim:reliability",
      "@type": "@id"
    }
  ],
  "howToUse": ["command-line", "CI/CD"],
  "appliesToProgrammingLanguage": ["Python"],
  "license": "https://spdx.org/licenses/MIT",
  "applicationCategory": [
    {
      "@id": "rs:AnalysisCode",
      "@type": "@id"
    },
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    }
  ],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_ci-tests",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_tests",
      "@type": "@id"
    }
  ],
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_test_coverage",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://qlty.sh/",
  "@type": "schema:SoftwareApplication",
  "name": "Qlty",
  "description": "Lightweight, modular framework for writing high-quality shell scripts with reusable components and utilities to improve script structure, error handling, and maintainability in computing environments and automation workflows.",
  "url": "https://github.com/qltysh/qlty",
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/BUSL-1.1",
  "applicationCategory": [
    { "@id": "rs:PrototypeTool", "@type": "@id" },
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" },
    { "@id": "rs:AnalysisCode", "@type": "@id" }
  ],
  "hasQualityDimension": { "@id": "dim:maintainability", "@type": "@id" },
  "howToUse": ["CI/CD", "command-line"],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_no_linting_issues",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/uses_tool_for_warnings_and_mistakes",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/static_analysis_common_vulnerabilities",
      "@type": "@id"
    }
  ],
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/no_critical_vulnerability",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/no_leaked_credentials",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/renovatebot",
  "@type": "SoftwareApplication",
  "applicationCategory": {
    "@id": "rs:ResearchInfrastructureSoftware",
    "@type": "@id"
  },
  "description": "Automated dependency management tool or service that regularly monitors software and tool dependencies for security vulnerabilities and updates, maintaining software security and reducing technical debt for long-term sustainability.",
  "hasQualityDimension": [
    { "@id": "dim:security", "@type": "@id" },
    { "@id": "dim:maintainability", "@type": "@id" },
    { "@id": "dim:sustainability", "@type": "@id" }
  ],
  "howToUse": ["CI/CD", "command-line", "online-service"],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/dependency_management",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/requirements_specified",
      "@type": "@id"
    }
  ],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/AGPL-3.0-only",
  "name": "Renovate",
  "url": "https://docs.renovatebot.com/"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/resqui",
  "@type": "schema:SoftwareApplication",
  "name": "resqui",
  "description": "Comprehensive research software quality assessment framework developed by EVERSE that evaluates repositories across all quality dimensions including maintainability, security, FAIRness, and sustainability, providing actionable insights for improving research software throughout its lifecycle.",
  "url": "https://github.com/EVERSE-ResearchSoftware/QualityPipelines",
  "applicationCategory": [
    { "@id": "rs:ResearchInfrastructureSoftware", "@type": "@id" },
    { "@id": "rs:AnalysisCode", "@type": "@id" },
    { "@id": "rs:PrototypeTool", "@type": "@id" }
  ],
  "isAccessibleForFree": true,
  "hasQualityDimension": [
    { "@id": "dim:compatibility", "@type": "@id" },
    { "@id": "dim:fairness", "@type": "@id" },
    { "@id": "dim:flexibility", "@type": "@id" },
    { "@id": "dim:functional_suitability", "@type": "@id" },
    { "@id": "dim:interaction_capability", "@type": "@id" },
    { "@id": "dim:maintainability", "@type": "@id" },
    { "@id": "dim:performance_efficiency", "@type": "@id" },
    { "@id": "dim:reliability", "@type": "@id" },
    { "@id": "dim:safety", "@type": "@id" },
    { "@id": "dim:security", "@type": "@id" },
    { "@id": "dim:sustainability", "@type": "@id" }
  ],
  "measuresQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_license",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_citation",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/has_ci-tests",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/human_code_review_requirement",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/has_published_package",
      "@type": "@id"
    },
    {
      "@id": "https://w3id.org/everse/i/indicators/no_leaked_credentials",
      "@type": "@id"
    }
  ],
  "howToUse": ["command-line"],
  "license": "https://spdx.org/licenses/MIT"
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/REUSE",
  "@type": "SoftwareApplication",
  "name": "REUSE",
  "description": "Automate the declaring of copyright and licensing for software projects with SPDX Tags.",
  "url": "https://reuse.software",
  "isAccessibleForFree": true,
  "applicationCategory": [
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    },
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    }
  ],
  "hasQualityDimension": {
    "@id": "dim:fairness",
    "@type": "@id"
  },
  "license": "https://spdx.org/licenses/GPL-3.0-only",
  "howToUse": ["command-line", "online-service", "CI/CD"],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/software_has_license",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/ruff",
  "@type": "schema:SoftwareApplication",
  "name": "Ruff",
  "description": "High-performance Python linter that quickly identifies code quality issues and style violations, enabling rapid feedback for research software development and improving overall code maintainability.",
  "url": "https://docs.astral.sh/ruff/",
  "isAccessibleForFree": true,
  "hasQualityDimension": {
    "@id": "dim:maintainability",
    "@type": "@id"
  },
  "howToUse": ["command-line", "CI/CD"],
  "appliesToProgrammingLanguage": ["Python"],
  "license": "https://spdx.org/licenses/MIT",
  "applicationCategory": [
    {
      "@id": "rs:AnalysisCode",
      "@type": "@id"
    },
    {
      "@id": "rs:ResearchInfrastructureSoftware",
      "@type": "@id"
    },
    {
      "@id": "rs:PrototypeTool",
      "@type": "@id"
    }
  ],
  "improvesQualityIndicator": [
    {
      "@id": "https://w3id.org/everse/i/indicators/has_no_linting_issues",
      "@type": "@id"
    }
  ]
}

{
  "@context": "https://w3id.org/everse/rs#",
  "@id": "https://w3id.org/everse/tools/scorep",
  "@type": "SoftwareApplication",
  "applicationCategory": { "@id": "rs:AnalysisCode", "@type": "@id" },
  "appliesToProgrammingLanguage": ["C", "C++"],
  "description": "Scalable Performance Measurement Infrastructure for Parallel Codes that provides highly scalable and easy-to-use tool suite for profiling and event trace recording of HPC applications, enabling performance optimization in computational research.",
  "hasQualityDimension": {
    "@id": "dim:performance_efficiency",
    "@type": "@id"
  },
  "howToUse": ["CI/CD", "command-line"],
  "isAccessibleForFree": true,
  "license": "https://spdx.org/licenses/0BSD",
  "name": "Score-P",
  "url": "https://gitlab.com/score-p/scorep"
}

Related skills

Lark MarkdownInstantly turn any markdown file into clean, formatted Lark/Figma-compatible documents without manual reformatting.488k

Lark DocCreate, read, update, summarize, rewrite and manage Feishu/Lark cloud documents directly from agent workflows.401k16.1k

Lark WikiCreate, organize, query, and manage documents, spaces, and members inside Lark (Feishu) knowledge bases directly from AI agent workflows.397k16.1k

Domain ModelingBuild and sharpen a project's domain model: pin down domain terminology in a glossary and record architectural decisions as ADRs.318k202k

Opensource Guide CoachGet expert, attribution-safe guidance on launching and sustaining an open-source project.270k71

Readme I18nMaintain consistent, updatable language selector blocks across every README variant in a multilingual repository.270k71

Documentationdocsgit

About

Catalog Curator by the numbers

Add your badge

What it does

Files

Catalog Curator Workflow

Core Mandates

Standard Procedures

1. Tool Audit & PR Workflow

2. Batch Management

Copilot Instructions: PR Review in This Repository

🟩 1. If the PR Adds or Modifies a Tool/Service JSON in the `data/` Directory

✅ Step 1: Check Inclusion Criteria

✅ Step 2: Review and Suggest Metadata Improvements

Metadata to Review and Improve:

✅ Step 3: Provide Insights for Human Reviewer and PR Author

✅ Optional: Update Suggestion

✅ Output Format

🟨 2. If the PR is Code, Documentation, or Infrastructure Changes

✅ Then:

✅ Final Note

🆕 Tool

Checklist

Research Usage Evidence (at least one required)

Active Maintenance

Lifecycle & Applicability

AGENTS.md

Multi-Agent System: RSE + UI Designer + Catalog Curator

🧠 Shared Identity & Principles

🎯 Shared Core Mission

⚖ {Conflict Resolution Rules (Critical)

🧪 Research Software Engineer

Identity

Core Mission

Critical Rules

Scientific Integrity

Reproducibility

Code Clarity

Safety

Technical Deliverables

Reproducible Function

Config-Driven Execution

Workflow

Success Metrics

🎨 UI Designer

Identity

Core Mission

Critical Rules

Design System First

Accessibility (Mandatory)

Performance-Aware Design

Technical Deliverables

Design Tokens

Component Example

Workflow

Success Metrics

📚 Catalog Curator

Identity

Core Mission

Critical Rules

Data Provenance

Delivery Workflow (Mandatory)

Schema Compliance

Indicator Selection Principles

Proactive Maintenance

🔄 Joint Workflow

Step 1 — Define Scope

Step 2 — System Design

Step 3 — Parallel Work

Step 4 — Integration

Step 5 — Validation

🚨 Global Rules (Non-Negotiable)

🔬 Execution Heuristics

📌 Practical Example (How They Work Together)

🧭 Final Rule

Contribution guidelines

TL;DR

Types of contributions

Quick Start: Add or update a tool

Inclusion criteria