OSCR

SKOOTS: Skeleton-Oriented Object Segmentation for Mitochondria in High-Resolution Cochlear EM Datasets.

Code ↔ Paper

15 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 15 matches · 1 of them tie a paragraph to a whole file without given lines: a weak match, whose lines are not tinted
  1. [1] § Materials and Methods › Training Procedure ↔ bism/config/config.py, lines 44 to 69 · score 0.85 · cosine annealing, weight decay, AdamW, loss function, schedule, GPU · Report a mismatch
  2. [2] § Materials and Methods › Accuracy and Morphology Metrics ↔ skoots/validate/__main__.py, lines 19 to 152 · score 0.82 · F1 score, ground truth instance, instance intersection, FP, TP, recall · Report a mismatch
  3. [3] § Materials and Methods › Training Procedure ↔ skoots/config.py, lines 57 to 102 · score 0.81 · cosine annealing, weight decay, AdamW, schedule, GPU, optimizer · Report a mismatch
  4. [4] § Materials and Methods › Anisotropy ↔ skoots/lib/skeleton.py, lines 51 to 123 · score 0.78 · Euclidean distance, closest skeleton, Embedding vectors, Formally, smooth, Anisotropic · Report a mismatch
  5. [5] § Materials and Methods › Model Architecture ↔ bism/backends/unext.py, lines 15 to 68 · score 0.72 · convolution computational block, normalization layer, layer scale, GeLU, activation, kernel · Report a mismatch
  6. [6] § Materials and Methods › Segmentation Mask Inference ↔ skoots/lib/flood_fill.py, lines 13 to 122 · score 0.68 · flood fill, skeleton mask, copies, replacement, ID, crops · Report a mismatch
  7. [7] § Materials and Methods › Segmentation Deep‐Learning Architecture Comparison ↔ bism/modules/convnext_block.py, lines 9 to 71 · score 0.62 · PyTorch, ConvNext blocks, faster, channels · Report a mismatch
  8. [8] § Results › SKOOTS Enables More Accurate Mitochondria Segmentation Compared to Other Automated Approaches ↔ skoots/validate/__main__.py, lines 19 to 152 · score 0.61 · F1 score, segmentation errors, recall, IoU, intersection, Dice · Report a mismatch
  9. [9] § Materials and Methods › 3D Rendering ↔ skoots/validate/stats.py, lines 30 to 48 · score 0.60 · marching cubes algorithm, spacing, meshes, anisotropy · Report a mismatch
  10. [10] § Materials and Methods › Anisotropy ↔ skoots/lib/vector_to_embedding.py, lines 129 to 163 · score 0.60 · vector fields, spatial dimensions, Formally, pixel, Embedding, predicted · Report a mismatch
  11. [11] § Materials and Methods › Ground Truth Skeleton Calculation for Training ↔ skoots/lib/skeleton.py, lines 51 to 123 · score 0.57 · binary mask, ground truth, nonzero, instance mask, anisotropy, pixel · Report a mismatch
  12. [12] § Results › Skeleton Embedding Allows for Segmentation of Mitochondria ↔ skoots/lib/flood_fill.py, lines 13 to 122 · score 0.56 · efficient flood fill, skeleton mask, SKOOTS · Report a mismatch
  13. [13] § Materials and Methods › Data Pre‐processing and Augmentation for Training ↔ bism/train/merged_transform.py, the whole file · a weak match · score 0.55 · randomly inverting, flipping, shearing, noise, brightness, augmentations · Report a mismatch
  14. [14] § Results › Skeleton Embedding Allows for Segmentation of Mitochondria ↔ skoots/lib/eval.py, lines 158 to 231 · score 0.54 · flood fill, unlabeled skeletons, instance mask, efficiency, embedding, vectors · Report a mismatch
  15. [15] § Results › Skeleton Embedding Allows for Segmentation of Mitochondria ↔ skoots/lib/eval.py, lines 158 to 231 · score 0.50 · efficient flood fill, unlabeled skeleton, embedding, vectors, mask, segmentation · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 152 lines · 4.8 KB · MIT · 2 matches

  1. import argparse
  2. import logging
  3. import os.path
  5. import matplotlib.pyplot as plt
  6. import torch
  8. from skoots.validate.lib import (
  9. get_segmentation_errors,
  10. mask_iou,
  11. accuracies_from_iou,
  12. f1_score,
  13. mask_dice,
  14. mask_soft_cldice,
  15. )
  16. from skoots.validate.utils import imread
  19. def main() -> None:
  20. """
  21. Runs validation stats on two isntance masks. GT was manually calculated, pred is predicted by an algorithm
  23. :param gt:
  24. :param pred:
  25. :return:
  26. """
  27. parser = argparse.ArgumentParser(description="SKOOTS Training Parameters")
  28. parser.add_argument(
  29. "--ground_truth", type=str, help="Path to ground truth instance mask"
  30. )
  31. parser.add_argument(
  32. "--predicted", type=str, help="Path to ground truth instance mask"
  33. )
  34. parser.add_argument(
  35. "--log",
  36. type=int,
  37. default=3,
  38. help="Log Level: 0-Debug, 1-Info, 2-Warning, 3-Error, 4-Critical",
  39. )
  40. args = parser.parse_args()
  42. _log_map = [
  43. logging.DEBUG,
  44. logging.INFO,
  45. logging.WARNING,
  46. logging.ERROR,
  47. logging.CRITICAL,
  48. ]
  49. logging.basicConfig(
  50. level=_log_map[args.log],
  51. format="[%(asctime)s] bism-eval [%(levelname)s]: %(message)s",
  52. )
  54. gt_path, pred_path = args.ground_truth, args.predicted
  56. # Load model
  57. if os.path.exists(gt_path) and os.path.exists(pred_path):
  58. file_without_extension = os.path.splitext(pred_path)[0]
  59. gt, pred = imread(gt_path), imread(pred_path)
  61. gt = gt[:, 50:-50, 50:-50, 5:-5]
  62. pred = pred[:, 50:-50, 50:-50, 5:-5]
  64. logging.debug(f"Ground Truth Shape: {gt.shape}, Predicted Shape: {pred.shape}")
  65. else:
  66. raise RuntimeError(f"{os.path.exists(gt_path)=}, {os.path.exists(pred_path)=}")
  68. # sent to device for speed
  69. device = "cuda" if torch.cuda.is_available() else "cpu"
  71. gt = gt.to(device)
  72. pred = pred.to(device)
  74. print("Calculating Segmentation Errors...")
  75. over_segmentation_rate, under_segmentation_rate = get_segmentation_errors(gt, pred)
  77. print("Calculating Instance Intersection over Union...")
  78. iou = mask_iou(gt, pred)
  79. dice = mask_dice(gt, pred)
  80. cldice = mask_soft_cldice(gt, pred)
  82. print("Calculating Accuracy Statistics...")
  83. tfp = [accuracies_from_iou(iou, thr / 100) for thr in range(100)]
  84. precision = [(tp / (tp + fp)) for (tp, fp, fn) in tfp]
  85. recall = [(tp / (tp + fn)) for (tp, fp, fn) in tfp]
  86. f1 = [f1_score(*a) for a in tfp]
  88. # Precision
  89. _x = torch.arange(0, 100).numpy()
  90. fig = plt.figure()
  91. plt.plot(_x, precision, "k-")
  92. plt.title("Precision")
  93. plt.xlabel("Threshold (%)")
  94. plt.ylabel("Score")
  95. plt.tight_layout()
  96. plt.savefig(f"{file_without_extension}_precision.png", dpi=300)
  97. plt.close()
  99. # Recall
  100. _x = torch.arange(0, 100).numpy()
  101. fig = plt.figure()
  102. plt.plot(_x, recall, "k-")
  103. plt.title("Precision")
  104. plt.xlabel("Threshold (%)")
  105. plt.ylabel("Score")
  106. plt.tight_layout()
  107. plt.savefig(f"{file_without_extension}_recall.png", dpi=300)
  108. plt.close()
  110. # F1
  111. _x = torch.arange(0, 100).numpy()
  112. fig = plt.figure()
  113. plt.plot(_x, f1, "k-")
  114. plt.title("F1 Score")
  115. plt.xlabel("Threshold (%)")
  116. plt.ylabel("Score")
  117. plt.tight_layout()
  118. plt.savefig(f"{file_without_extension}_f1.png", dpi=300)
  119. plt.close()
  121. print("Writing File...")
  122. with open(f"{file_without_extension}_accuracy_stats.csv", "w") as file:
  123. file.write(f"Ground Truth File: {gt_path}\n")
  124. file.write(f"Predicted File: {pred_path}\n")
  125. file.write(f"Over Segmentation Rate: {over_segmentation_rate}\n")
  126. file.write(f"Under Segmentation Rate: {under_segmentation_rate}\n")
  127. file.write(
  128. f"thr,true_positive,false_positive,false_negative,precision,recall,f1\n"
  129. )
  130. i = -1
  131. for (tp, fp, fn), _precision, _recall, _f1 in zip(tfp, precision, recall, f1):
  132. i += 1
  133. file.write(f"{i / 100},{tp},{fp},{fn},{_precision},{_recall},{_f1}\n")
  135. print(f"File Written: {file_without_extension}_accuracy_stats.csv")
  137. with open(f"{file_without_extension}_intersection_over_union.csv", "w") as file:
  138. file.write(f"Ground Truth File: {gt_path}\n")
  139. file.write(f"Predicted File: {pred_path}\n")
  140. file.write(f"Average IOU: {iou.max(1)[0].mean().item()}\n")
  141. file.write(f"Average Dice: {dice.max(1)[0].mean().item()}\n")
  142. file.write(f"Average clDice: {cldice.max(1)[0].mean().item()}\n")
  143. file.write(f"gt_label,best_iou,best_dice,best_cldice\n")
  145. for i, u in enumerate(gt.unique()):
  146. if u == 0:
  147. continue
  148. file.write(
  149. f"{u},{iou[i - 1, :].max().item()},{dice[i - 1, :].max().item()},{cldice[i - 1, :].max().item()}\n"
  150. )
  152. print(f"File Written: {file_without_extension}_intersection_over_union.csv")

__main__.py at commit 10a9dcc, under MIT · at the source

Overview

Authors: Christopher J Buswinka1,2,3, Richard T Osgood1,2, Hidetomi Nitta1, Artur A Indzhykulian1,2,3
ORCID iDs: Christopher J Buswinka, Richard T Osgood, Artur A Indzhykulian
  1. Eaton Peabody Laboratories, Mass Eye and Ear, Boston, MA, USA
  2. Department of Otolaryngology, Head and Neck Surgery, Harvard Medical School, Boston, MA, USA
  3. Speech and Hearing Biosciences and Technology graduate Program, Harvard University, Cambridge, MA, USA
Institutions: Massachusetts Eye and Ear Infirmary (United States); Harvard University (United States)
Journal: Advanced science (Weinheim, Baden-Wurttemberg, Germany), volume 13, issue 32, article e17738
Dates: received 11 September 2025; accepted 19 March 2026; published online 31 March 2026; in print June 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1002/advs.202517738 · PMID 41915849 · PMCID PMC13252615 · OpenAlex W7147340999
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: histology / microscopy (modality), human (organism)
Methods: Machine learning, fMRI & imaging
Keywords: aminoglycoside, hair cell, instance segmentation, machine learning, mitochondria
MeSH: Cochlea*, Image Processing, Computer-Assisted*, Imaging, Three-Dimensional*, Microscopy, Electron*, Mitochondria*, Algorithms, Animals, Humans, Volume Electron Microscopy (* major topic)
Topic: Advanced Electron Microscopy Techniques and Applications (Structural Biology, Biochemistry, Genetics and Molecular Biology), according to OpenAlex
Funding: NIDCD NIH HHS (DC021795, R01 DC020190, DC017166, T32 DC000038, DC000038, R01 DC017166, DC020190); National Science Foundation (1541959); National Institute on Deafness and Other Communication Disorders (DC021795, DC000038, DC017166, DC020190)
Citations: cited by 3 papers (Europe PMC); 65 references in the paper

Abstract

Segmenting individual instances of mitochondria from imaging datasets can provide rich quantitative information, but manual segmentation is prohibitively time‐consuming—prompting the development of automated algorithms based on deep neural networks. Existing solutions for various segmentation tasks are optimized for either: high‐resolution three‐dimensional imaging, relying on well‐defined object boundaries (e.g., whole neuron segmentation in volumetric electron microscopy datasets); or low‐resolution two‐dimensional imaging, boundary‐invariant but poorly suited to large 3D objects (e.g., whole‐cell segmentation of light microscopy images). However, there is a middle ground that challenges current segmentation tools: large 3D objects with ambiguous boundaries, such as mitochondria in whole‐cell 3D electron microscopy datasets. To address this, we developed Skeleton‐Oriented Object Segmentation (SKOOTS)—a novel, general‐purpose 3D segmentation framework for efficiently segmenting densely packed, morphologically complex objects. SKOOTS is fast, accurate, and memory‐efficient, and can be applied to segment mitochondria and other structures in both 3D light and electron microscopy datasets. By combining skeleton‐based instance segmentation with a scalable embedding approach, SKOOTS bridges a key gap in existing segmentation strategies and enables biologically meaningful, large‐scale analysis of 3D biomedical imaging data. We demonstrate this by segmenting >15 000 mitochondria from cochlear hair cells and supporting cells across experimental conditions in under 2 h on a consumer‐grade PC, enabling downstream morphological analysis that revealed subtle structural changes following aminoglycoside exposure. SKOOTS is fully open‐source, easy to retrain, and designed to support diverse datasets, making it broadly accessible to the research community.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

Its files are read in the Code ↔ Paper reader above, with 15 matches between paragraphs and lines of code.

indzhykulianlab/bism

License: MIT
State: the link answers, verified on 31 October 2026
Evidence: files inventoried
Commit: c37b165742795f942071c7b31af734f5193cefc5, 23 March 2023
Languages: Python (58)
Size: 66 files, 58 scripts
Software Heritage: archived
Found in: the text, “Model Architecture”
Holds: README, license file, environment (setup.cfg, setup.py), tests
Not found: CITATION.cff, continuous integration, documentation
Tools: PyTorch (43 files), NumPy (5 files), scikit-image (3 files), Matplotlib (1 file), SciPy (1 file)
Availability: 2 checks, the latest on 31 October 2026: the link answers
  • 31 October 2026: the link answers
  • 30 September 2026: the link answers
60 files
At the source: github.com/indzhykulianlab/bism

indhzkyulianlab/bism

License: none: the authors keep all their rights
State: the link is dead, verified on 31 October 2026
Evidence: found in the paper
Software Heritage: not archived
Found in: the text, “Segmentation Approach Validation”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Availability: 2 checks, the latest on 31 October 2026: the link is dead
  • 31 October 2026: the link is dead
  • 30 September 2026: the link is dead
At the source: github.com/indhzkyulianlab/bism

indzhykulianlab/skoots

License: MIT
State: the link answers, verified on 31 October 2026
Evidence: files inventoried
Commit: 10a9dcc66c2211dd59422bcc68c3d64ea70798e0, 4 May 2023
Languages: Python (35), Jupyter (8)
Size: 79 files, 43 scripts
Software Heritage: archived
Found in: “Data Availability Statement”
Holds: README, license file, environment (requirements.txt, setup.cfg, setup.py, skoots/train/setup.py), documentation, 8 notebooks
Not found: CITATION.cff, tests, continuous integration
Tools: PyTorch (30 files), NumPy (9 files), scikit-image (9 files), Matplotlib (3 files), Numba (1 file), SciPy (1 file)
Availability: 2 checks, the latest on 31 October 2026: the link answers
  • 31 October 2026: the link answers
  • 30 September 2026: the link answers
45 files
At the source: github.com/indzhykulianlab/skoots

The paper's code and data availability statement is in the Data section.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 3 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 101 scripts, each with its path and the digest of its content;
  • 15 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Data Availability Statement

Code outlining SKOOTS segmentation is freely available here: https://github.com/indzhykulianlab/skoots, while training scripts, model construction, and augmentation are found here: https://github.com/indzhykulianlab/bism. SKOOTS documentation is publicly hosted here: https://skoots.readthedocs.io.

Reproduced under the paper's license (CC BY), from the paper cited above.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 5 keywords, 9 MeSH terms, 3 funders, 60 references.

Cite

This paper

Buswinka, C. J., Osgood, R. T., Nitta, H., & Indzhykulian, A. A. (2026). SKOOTS: Skeleton-Oriented Object Segmentation for Mitochondria in High-Resolution Cochlear EM Datasets. Advanced science (Weinheim, Baden-Wurttemberg, Germany), 13(32), e17738. https://doi.org/10.1002/advs.202517738

BibTeX

@article{buswinka2026skoots,
author = {Buswinka, Christopher J and Osgood, Richard T and Nitta, Hidetomi and Indzhykulian, Artur A},
title = {{SKOOTS: Skeleton-Oriented Object Segmentation for Mitochondria in High-Resolution Cochlear EM Datasets}},
journal = {Advanced science (Weinheim, Baden-Wurttemberg, Germany)},
year = {2026},
month = mar,
volume = {13},
number = {32},
pages = {e17738},
publisher = {Wiley},
issn = {2198-3844},
doi = {10.1002/advs.202517738},
url = {https://doi.org/10.1002/advs.202517738},
pmid = {41915849},
pmcid = {PMC13252615}
}

RIS

TY - JOUR
AU - Buswinka, Christopher J
AU - Osgood, Richard T
AU - Nitta, Hidetomi
AU - Indzhykulian, Artur A
TI - SKOOTS: Skeleton-Oriented Object Segmentation for Mitochondria in High-Resolution Cochlear EM Datasets
T2 - Advanced science (Weinheim, Baden-Wurttemberg, Germany)
J2 - Adv Sci (Weinh)
PY - 2026
DA - 2026/03/31
VL - 13
IS - 32
SP - e17738
SN - 2198-3844
PB - Wiley
DO - 10.1002/advs.202517738
UR - https://doi.org/10.1002/advs.202517738
LA - en
ER -

CSL-JSON

{
"id": "10.1002/advs.202517738",
"type": "article-journal",
"title": "SKOOTS: Skeleton-Oriented Object Segmentation for Mitochondria in High-Resolution Cochlear EM Datasets",
"container-title": "Advanced science (Weinheim, Baden-Wurttemberg, Germany)",
"author": [
{
"family": "Buswinka",
"given": "Christopher J"
},
{
"family": "Osgood",
"given": "Richard T"
},
{
"family": "Nitta",
"given": "Hidetomi"
},
{
"family": "Indzhykulian",
"given": "Artur A"
}
],
"container-title-short": "Adv Sci (Weinh)",
"volume": "13",
"issue": "32",
"page": "e17738",
"DOI": "10.1002/advs.202517738",
"PMID": "41915849",
"PMCID": "PMC13252615",
"ISSN": "2198-3844",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/advs.202517738",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
31
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.7554/elife.76120 [code]
Binary and analog variation of synapses between cortical pyramidal neurons.
Journal: eLife
In common: scikit-image, PyTorch, SciPy, 2 other tools, histology / microscopy, 6 references
[2] doi:10.1016/j.isci.2025.114507 [code]
A distribution-aware semi-supervised pipeline for cost-effective neuron segmentation.
Journal: iScience
In common: scikit-image, PyTorch, SciPy, 2 other tools, 5 references
[3] doi:10.1016/j.crmeth.2025.100989 [code]
Efficient cell-wide mapping of mitochondria in electron microscopic volumes using webKnossos.
Journal: Cell reports methods
In common: Numba, scikit-image, PyTorch, 3 other tools, histology / microscopy, 3 references
[4] doi:10.1242/jcs.261950 [code]
Gut Analysis Toolbox - automating quantitative analysis of enteric neurons.
Journal: Journal of cell science
In common: Numba, scikit-image, PyTorch, 3 other tools, 3 references
[5] doi:10.1038/s41592-024-02226-5
RoboEM: automated 3D flight tracing for synaptic-resolution connectomics.
Journal: Nature methods
In common: histology / microscopy, 5 references
[6] doi:10.1038/s41592-022-01711-z [code]
Local shape descriptors for neuron segmentation.
Journal: Nature methods
In common: scikit-image, PyTorch, SciPy, 2 other tools, 3 references
[7] doi:10.1038/s41592-022-01624-x [code]
SyConn2: dense synaptic connectivity inference for volume electron microscopy.
Journal: Nature methods
In common: Numba, scikit-image, PyTorch, 3 other tools, histology / microscopy, 2 references
[8] doi:10.1371/journal.pcbi.1013115 [code]
RETINA: Reconstruction-based pre-trained enhanced TransUNet for electron microscopy segmentation on the CEM500K dataset.
Journal: PLoS computational biology
In common: scikit-image, PyTorch, SciPy, 2 other tools, histology / microscopy, 2 references
[9] doi:10.1038/s41586-025-08790-w [code]
Functional connectomics spanning multiple areas of mouse visual cortex.
Journal: Nature
In common: Numba, scikit-image, PyTorch, 3 other tools, 2 references
[10] doi:10.1038/s41592-024-02426-z [code]
CAVE: Connectome Annotation Versioning Engine.
Journal: Nature methods
In common: scikit-image, SciPy, Matplotlib, 1 other tool, 3 references

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.1002/advs.202517738.svg)](https://openscicode.org/badge/doi/10.1002/advs.202517738)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1002/advs.202517738.svg
   :target: https://openscicode.org/badge/doi/10.1002/advs.202517738
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1002/advs.202517738"><img src="https://openscicode.org/badge/doi/10.1002/advs.202517738.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.