August 14, 2026 · 22 min read

Cite NeuroCUDA in Papers

To cite NeuroCUDA, use the technical report at https://quantaracore.in/neurocuda/paper.pdf for method claims and github.com/Krishnav1/neurocuda plus pip install neurocuda for the software artifact. Keep SpiNNaker-1, Loihi 2, GPU, FPGA HLS, and Akida as separate evidence classes. This page is the citation and integrity guide, not the product hub.

BibTeX, PDF URL, GitHub, PyPI, and an honest label table so a Methods section names the compiler you ran without promoting a 2-neuron smoke test into ResNet-on-chip.

This page vs nearby URLs: this URL is how to cite NeuroCUDA correctly. /neurocuda is the product hub (including a short Technical report block). /blog/reproduce-neurocuda-results is how to match the table. /blog/neurocuda-docker is the container HowTo. Google should index this page for the citation query, not as a duplicate of the hub PDF paragraph.

Authors search cite neurocuda after they already converted a checkpoint. They need a URL a journal will accept, a BibTeX block a .bib file can ingest, and a sentence they are allowed to write about SpiNNaker, Loihi, FPGA, and Akida. They do not need another product pitch. The failure mode is copying the hub's Technical report section, then writing "deployed to neuromorphic silicon" in the abstract because a 2-neuron EBRAINS job exists. That sentence is how a careful compiler gets treated as marketing.

NeuroCUDA is an open-source PyTorch-to-SNN compiler. Install with pip install neurocuda. Source is MIT at https://github.com/Krishnav1/neurocuda. The conversion call is snn, meta = neurocuda.convert(model, calib_loader). This post is the citation plus integrity guide: what to cite, how to cite it, what labels are honest, and what README, PyPI, and journals should link. Author: Krishna Santosh Varma, QuantaraCore Technologies LLP.

How to cite NeuroCUDA correctly

Treat NeuroCUDA as two citable objects that travel together. The first object is the technical report. The second object is the software you actually executed. FORCE11 software citation principles say a paper that used a tool should name the tool, the version, the authors, and a persistent locator. A PDF without a commit is not a reproduction. A GitHub clone without the table is not a method claim. When you cite neurocuda in a submission, put both in the bibliography and both in the Methods paragraph.

The report URL is stable and should be the scholarly locator:

https://quantaracore.in/neurocuda/paper.pdf

Full title as printed on the hub: NeuroCUDA: An Integrated PyTorch-to-Spiking-Network Conversion Pipeline with Verified Residual-Graph NIR Execution. Author: Krishna Santosh Varma. Institution: QuantaraCore Technologies LLP. Date on the hub: June 2026. License of the software: MIT.

The software locators are:

• GitHub: https://github.com/Krishnav1/neurocuda
• PyPI: https://pypi.org/project/neurocuda/
• Install: pip install neurocuda or pip install neurocuda[all]
• Product hub: https://quantaracore.in/neurocuda

If a reviewer asks "which NeuroCUDA," the answer is a triple: PDF revision date, PyPI version, git SHA. Log all three the same way you would log PyTorch and CUDA. The reproduce NeuroCUDA results page is the protocol for matching numbers. This page is the protocol for naming what you matched.

Paper citation versus software citation

A paper citation answers: what method and what published table. A software citation answers: what bytes ran on my machine. Journals still collapse those two into one \cite{}. That collapse is how "we used NeuroCUDA" starts meaning "we claim every backend on the hub." Split them in prose even if the style file only has one entry type.

Software citation is not optional because the API can move. snn, meta = neurocuda.convert(...) returns metadata that belongs in a lab notebook. If you discard meta and only paste an accuracy number, a reviewer cannot tell which thresholds, which T, or which backend produced the row. Cite the software, then archive the meta object next to the checkpoint.

Paper citation is not optional because GitHub default branches move. A clone from 2027 is not automatically the June 2026 table. The PDF is the snapshot of claims. The repo is the snapshot of code. You need both, the same way a biology paper cites a protocol and a reagent catalog number.

BibTeX for the technical report

Use this block for the scholarly object. @techreport matches a self-hosted institutional report. If a venue forbids that type, @misc with the same URL is acceptable. Do not invent an arXiv id that does not exist.

@techreport{varma2026neurocuda,
  author      = {Varma, Krishna Santosh},
  title       = {NeuroCUDA: An Integrated PyTorch-to-Spiking-Network
                 Conversion Pipeline with Verified Residual-Graph
                 NIR Execution},
  institution = {QuantaraCore Technologies LLP},
  year        = {2026},
  month       = jun,
  url         = {https://quantaracore.in/neurocuda/paper.pdf},
  note        = {Technical report. MIT-licensed compiler:
                 https://github.com/Krishnav1/neurocuda}
}

ACM Reference Format style in prose: Krishna Santosh Varma. 2026. NeuroCUDA: An Integrated PyTorch-to-Spiking-Network Conversion Pipeline with Verified Residual-Graph NIR Execution. Technical Report. QuantaraCore Technologies LLP. https://quantaracore.in/neurocuda/paper.pdf.

BibTeX for the software

Use this block for the artifact. Fill version and commit from the run you actually executed, not from memory.

@software{neurocuda_software,
  author  = {Varma, Krishna Santosh},
  title   = {NeuroCUDA},
  url     = {https://github.com/Krishnav1/neurocuda},
  license = {MIT},
  year    = {2026},
  version = {PUT_PIP_VERSION_HERE},
  note    = {PyPI: https://pypi.org/project/neurocuda/.
             Install: pip install neurocuda.
             Commit: PUT_GIT_SHA_HERE}
}

Record the version in the paper body, not only in the .bib file:

import neurocuda, subprocess
print("neurocuda", neurocuda.__version__)
print("sha", subprocess.check_output(
    ["git", "rev-parse", "HEAD"], text=True).strip())

If you installed from PyPI and never cloned, log pip show neurocuda and the wheel filename. If you used an editable clone, log the SHA. Mixing an editable install with a PyPI version string is a citation bug. The pip install neurocuda guide covers local wheels. This page only cares that the string you print is the string you cite.

Honest label table (copy into a paper appendix)

This table is the reason this URL exists. If you cite neurocuda and then flatten every backend into "neuromorphic deployment," you have cited the name and discarded the integrity rule. Paste the Allowed sentence, not the Forbidden sentence.

SpiNNaker detail lives on NeuroCUDA SpiNNaker physical silicon: two independent SUCCESS runs on two boards at Manchester, 2 SpikeSourceArray inputs, 2 IF_curr_exp outputs, identical spike counts. That is a hardware path confirmation. It is not the ResNet-18 CIFAR-10 row. The CIFAR-10 row is a GPU/CPU software result. Mixing those two rows in one sentence is the most common integrity failure when people cite the compiler.

Loihi detail lives on PyTorch to Loihi 2 without Lava and Loihi 2 without Lava. The compile target is a simulator. Intel Lava being archived does not convert a simulator into a chip. If your paper needs physical Loihi, you need an INRC board and a job you can name. NeuroCUDA does not supply that job as of this writing.

FPGA honesty belongs on NeuroCUDA FPGA HLS. Generated C++ is a compiler artifact. A bitstream is a place-and-route artifact on a named part (for example an Alveo or a Zynq). Until a bitstream, a board, and a job ID exist, write PoC. Akida honesty belongs on Akida BrainChip NeuroCUDA. Field context for chips is neuromorphic chips guide. Field context for CUDA-as-a-term is neuromorphic CUDA. None of those pages license a stronger claim than this table.

What journals, README, and PyPI should link

Link policy is part of citation integrity. A README that only says "pip install" with no PDF teaches users to treat numbers as folklore. A PyPI page that only says "ANN to SNN" with no label table teaches users to overclaim backends. A journal Methods section that only says "we used NeuroCUDA" with no URL teaches reviewers to Google a trademark collision with cuDNN. Put the same four locators in all three places.

Journals and camera-ready PDFs

Primary scholarly URL: https://quantaracore.in/neurocuda/paper.pdf. Secondary software URL: https://github.com/Krishnav1/neurocuda. Product definition: https://quantaracore.in/neurocuda. Integrity companion (this page): https://quantaracore.in/blog/cite-neurocuda. Reproduction protocol: https://quantaracore.in/blog/reproduce-neurocuda-results.

Do not make a launch post, a LinkedIn thread, or a Docker Hub badge the bibliographic object. Those are discovery surfaces. The camera-ready PDF should survive a reviewer who is offline except for the two URLs in the bibliography. If the venue allows a Software Availability statement, use it:

Software Availability. NeuroCUDA is MIT-licensed at
https://github.com/Krishnav1/neurocuda and installable with
pip install neurocuda. Method and tables:
https://quantaracore.in/neurocuda/paper.pdf. We ran version
VERSION (commit SHA). Backend labels follow
https://quantaracore.in/blog/cite-neurocuda.

If the venue wants a DOI and one does not exist yet, keep the HTTPS PDF URL. Do not mint a fake DOI. A working HTTPS locator beats an invented identifier.

GitHub README

The README should link, in this order: product hub, paper PDF, PyPI, this citation guide, the reproduce page, and the install guide. It should not hide the honest labels behind a "multi-backend" adjective. A badge that says Docker 26GB is fine on the robotics section. A badge that implies a tiny official compiler image is not, because the public Dockerfile is a ROS2 Jazzy plus Gazebo environment. See NeuroCUDA Docker for that distinction. README citation is how most students first cite neurocuda incorrectly: they copy a backend list and drop the qualifiers.

Recommended README footer:

## Cite
Technical report: https://quantaracore.in/neurocuda/paper.pdf
Software: this repository (MIT) and https://pypi.org/project/neurocuda/
Citation + integrity labels: https://quantaracore.in/blog/cite-neurocuda
Reproduce: https://quantaracore.in/blog/reproduce-neurocuda-results

PyPI project page

PyPI should link GitHub, the hub, the PDF, and this guide. The project description should say pip install neurocuda and should not say "runs on Loihi / SpiNNaker / Akida / FPGA" as a flat list. PyPI is where a CI bot will scrape a one-line summary. That one line must survive being quoted without the rest of the README. Honest one-liner: "PyTorch-to-SNN compiler (QCFS + BPTT). GPU/CPU software backends; Loihi 2 IF simulator; SpiNNaker-1 smoke test; FPGA HLS PoC; Akida not claimed physical."

Home page field: https://quantaracore.in/neurocuda. Repository field: GitHub. Documentation field: this citation guide plus the convert HowTo at convert PyTorch to SNN.

What to write in Methods (copy-paste, then fill blanks)

A Methods paragraph that names the compiler without naming T, seed, split, and backend is not citable even if the bibliography is perfect. Fill every bracket.

We converted a trained ReLU PyTorch checkpoint to an SNN with
NeuroCUDA (Varma, 2026), installed via pip install neurocuda
version [VERSION], commit [SHA]. Conversion used
snn, meta = neurocuda.convert(model, calib_loader) with
in-distribution calibration data, then BPTT fine-tuning and
neurocuda.compile(snn, target="[gpu|cpu|loihi2_sim]").
Timesteps T=[T]. We evaluated the full [DATASET] test set
over [N] seeds. We cite GPU/CPU accuracy as software-backend
results, not as neuromorphic-silicon accuracy. SpiNNaker-1
physical evidence in the NeuroCUDA project is a 2-neuron
smoke test (EBRAINS jobs #420148, #420186), not this model.
Loihi 2 here is an IF-neuron simulator, not Loihi silicon.
FPGA HLS is a C++ PoC, not a bitstream. Physical Akida is
not claimed.

If you exported NIR, add one sentence from the export PyTorch to NIR protocol and quote the 0.000000 ResNet-18 check only if you reran that check. If you only converted a small CNN, do not paste the ResNet residual-graph identity result as if it were yours.

If you used ROS2, cite the architecture page /neurocuda-ros2 and, if you used the published container, the Docker guide. A robot demo does not upgrade GPU accuracy into silicon accuracy. If you used Colab, cite NeuroCUDA Google Colab as the runtime, not as a different compiler.

QCFS is not NeuroCUDA. If calibration method matters to the claim, cite Bu et al., ICLR 2023, and the explainer at QCFS ANN to SNN. If thresholds failed to move, that is a bug page (QCFS threshold not learning), not a citation of the compiler as empty. Batch-norm folding and timestep choice have their own jobs: batchnorm folding SNN and SNN timesteps explained. Cite those when those knobs are the contribution. Cite NeuroCUDA when the compiler is the contribution.

How to cite convert() and meta without sounding like an ad

The public API is short. Short APIs get over-cited as magic. Write the call, then write what it did not do.

import neurocuda
snn, meta = neurocuda.convert(model, calib_loader)
neurocuda.finetune(snn, train_loader)
neurocuda.compile(snn, target="gpu")  # or "cpu" or "loihi2_sim"
# optional: neurocuda.to_nir(snn, "model.nir")

convert is QCFS calibration, folding, and IF replacement on a trained ANN. It is not a from-scratch SNN trainer. Comparisons that belong on other URLs: snnTorch vs NeuroCUDA, NeuroCUDA vs SpikingJelly, NeuroCUDA vs NIRTorch. If your paper trained spikes from random init, you probably should not cite NeuroCUDA as the trainer. If your paper converted a checkpoint, you should not cite snnTorch as the converter.

meta is the place to put thresholds, T, and conversion diagnostics in a supplement. Archive it. A paper that reports 94.61% without T=32 is citing a headline, not a result. A paper that reports 99.88% on a 1,000-event subset is not citing the N-MNIST row. Full-test, multi-seed is part of the label "GPU numbers," the same way "not ResNet-on-chip" is part of the SpiNNaker label.

Common citation mistakes

1. Citing cuDNN. NeuroCUDA is not NVIDIA cuDNN. Disambiguation lives on the hub and neuromorphic CUDA. If a copy editor expands CUDA, restore the product name.
2. Citing the hub Technical report section as if it were this guide. The hub tells you the PDF exists. This page tells you how to cite without mixing evidence classes.
3. Citing a blog launch post as the paper. Discovery post, not the table.
4. Flattening backends. "GPU, CPU, Loihi, SpiNNaker, FPGA, Akida" as one comma list in Related Work.
5. Promoting the smoke test. Jobs #420148 and #420186 are real. They are small. Say so.
6. Omitting version. pip install neurocuda without a version is a moving target.
7. Borrowing numbers you did not rerun. Quote the PDF as prior work, or rerun via the reproduce protocol. Do not imply your CIFAR subset is the published 94.61%.
8. Citing Docker as a tiny compiler image. The public Dockerfile is ROS2 Jazzy plus Gazebo. See NeuroCUDA Docker.
9. Citing Colab as silicon. Colab is a hosted NVIDIA GPU.
10. Citing energy without a meter. Sparsity is not joules. GPU watts are not Loihi watts.

Reviewer checklist you can paste into a cover letter:

• PDF URL in the bibliography
• GitHub or PyPI plus version/SHA in Software Availability
• Backend sentences match the honest label table
• T, seeds, and full-test stated for any accuracy number
• QCFS cited separately if the method is discussed
• No Akida physical claim, no FPGA bitstream claim, no Loihi silicon claim, no SpiNNaker ResNet claim unless new evidence exists

Worked examples: three sentences that are allowed

Conversion paper. "We converted a trained ResNet-18 with NeuroCUDA (pip install neurocuda, version X, commit Y; technical report at quantaracore.in/neurocuda/paper.pdf). Evaluation is a GPU software backend at T=32 on the full CIFAR-10 test set. We do not claim SpiNNaker, Loihi silicon, FPGA bitstream, or Akida."

Robotics paper. "Perception used a NeuroCUDA-converted SNN inside ROS2 Jazzy (neurocuda-ros2). Inference ran on GPU inside the published ROS2 container. Physical SpiNNaker evidence in the NeuroCUDA project remains a 2-neuron smoke test (jobs #420148, #420186) and is not this robot experiment."

Related-work paragraph. "ANN-to-SNN compilers such as NeuroCUDA (Varma, 2026) convert trained PyTorch checkpoints with QCFS and BPTT. Training libraries such as snnTorch and SpikingJelly start from spikes. We cite NeuroCUDA for conversion, not as a neuroscience simulator (see GeNN/Brian2 on neuromorphic CUDA)."

Those three sentences do more integrity work than a paragraph that repeats the hub Technical report block. If you only needed the PDF link, you would already have it from /neurocuda. You opened this URL because citation is where overclaims start.

What this citation guide does not replace

It does not replace the reproduce protocol. It does not replace the convert HowTo. It does not replace silicon, FPGA, or Akida status pages. It does not replace a DOI if one is later minted. It does not bless citing this blog post as the primary scholarly object. When in doubt, the PDF carries the table, GitHub carries the code, and this page carries the labels.

Install reminder, because every citation still has to be runnable: pip install neurocuda. Source: github.com/Krishnav1/neurocuda. License: MIT. Author: Krishna Santosh Varma.

Frequently asked questions

Cite now: paper.pdf · pip install neurocuda · GitHub · Product hub · labels on this page