August 14, 2026 · 24 min read

NeuroCUDA Akida Status

NeuroCUDA Akida is NOT SUPPORTED. BrainChip Akida is real neuromorphic silicon and MetaTF is BrainChip's toolchain, but NeuroCUDA has no Akida job ID and does not claim physical Akida. Convert on GPU or CPU with pip install neurocuda, export NIR, then use MetaTF if you have Akida. Source on GitHub: https://github.com/Krishnav1/neurocuda.

This is an honest support status page. It does not describe the Akida chip family, invent a backend, or treat a GitHub slogan as silicon evidence.

This page vs nearby URLs: this URL answers only whether NeuroCUDA can drive BrainChip Akida. /blog/neuromorphic-chips-guide is the chip field guide (Loihi, SpiNNaker, Akida, NorthPole, Innatera). Loihi 2 guide is simulator equations, not Akida. SpiNNaker silicon is the only physical neuromorphic smoke test. Google should index this URL for the support-status query, not as a second chip encyclopedia.

People type NeuroCUDA Akida when they have seen both names in the same sentence and want a deploy path. That search is reasonable. BrainChip ships a real neuromorphic processor. NeuroCUDA is a real PyTorch-to-SNN compiler. The mistake is treating adjacency in a paragraph as a compiled backend. This page exists so that search, papers, and procurement notes stop making that leap.

The answer is short enough to put in a paper footnote and long enough to prove. NeuroCUDA Akida is not a product feature. If you cannot point at a backend module, a compile target string, a MetaTF call, and a job identifier on Akida silicon, you do not have support. NeuroCUDA currently has none of those for Akida. Saying that clearly is the unique job of this URL.

NeuroCUDA Akida is NOT SUPPORTED

Start with the claim you can copy into a review response. NeuroCUDA Akida: NOT SUPPORTED. That sentence is the status. Everything else on this page is evidence for why the sentence is true and what you should do instead.

The NeuroCUDA package on PyPI installs with pip install neurocuda or pip install neurocuda[all]. Source is MIT licensed at github.com/Krishnav1/neurocuda. After install, the public compile targets that exist in the backend package are GPU, CPU, SpiNNaker, Loihi-family simulators, BrainScaleS, and NIR bridging. There is no akida.py in neurocuda/backends/. There is no target="akida" documented as a shipped backend. There is no MetaTF Python import in the compiler path.

Absence is the proof. Support would look like the SpiNNaker path: a backend file, a PyNN or vendor script, and a job ID from a board. Support would look like the GPU path: a compile target, a published accuracy table, and a reproduce script. Akida has none of that in NeuroCUDA. Until those artifacts exist in public, the honest label remains NOT SUPPORTED.

import neurocuda
print(neurocuda.list_backends())
# Expect GPU, CPU, and documented simulators / export paths.
# Do not expect an Akida backend. If a future release adds one,
# it will ship with a job ID and a backend module. This page
# will change only after that evidence is public.

If a tutorial, slide, or vendor comparison table shows neurocuda.compile(snn, target="akida"), that snippet is invented. Do not paste it into a paper. Do not paste it into a grant. Inventing a target string is how status pages get ignored and how later readers think silicon was demonstrated.

What BrainChip Akida actually is

Honesty about NeuroCUDA does not require pretending Akida is fictional. BrainChip Akida is a commercially sold neuromorphic processor aimed at edge vision, keyword spotting, and similar always-on workloads. It is event-based rather than a strict biological spiking core in the Loihi sense. BrainChip's software stack for mapping models onto that silicon is MetaTF. Those facts belong to BrainChip's documentation and to the field guide at neuromorphic chips in 2026.

This page will not retell process node, neuron counts, or market positioning. Repeating the chip encyclopedia here would cannibalize the field guide and would hide the only question this URL owns: can NeuroCUDA drive that chip today? It cannot. If you arrived here because you wanted a Loihi versus Akida versus SpiNNaker comparison, leave this article and open the chips guide. If you arrived because you wanted a compiler status, stay.

MetaTF is not NeuroCUDA. MetaTF is BrainChip's toolchain. It converts models in BrainChip's supported frameworks toward Akida deployment, including on-chip incremental learning features that BrainChip documents. Using MetaTF requires BrainChip's SDK, their model constraints, and usually their hardware or an official emulator they provide. None of that is wrapped by pip install neurocuda. Installing NeuroCUDA does not install MetaTF. Exporting NIR does not emit a MetaTF project.

Researchers sometimes assume that "neuromorphic compiler" means "every neuromorphic logo in the README." That is the CUDA-era wish, not the 2026 evidence. Neuromorphic software is still fragmented. Intel-facing work uses Lava remnants or equation simulators. Manchester-facing work uses sPyNNaker and EBRAINS. BrainChip-facing work uses MetaTF. NeuroCUDA sits in the PyTorch conversion seat and currently hands off with NIR, GPU, CPU, a Loihi simulator, and a SpiNNaker smoke test. Akida remains on the BrainChip side of that fence.

What people searching NeuroCUDA Akida actually need

The search NeuroCUDA Akida is almost never a request for another chip datasheet. It is a request for a pipeline. The person already has a trained PyTorch checkpoint, or they are about to convert one, and they want to know whether the converted SNN can land on an Akida board they own, hope to buy, or saw in a paper. The useful answer is a sequence that does not lie about the last hop.

That sequence is: convert and validate on GPU or CPU, optionally measure sparsity and timesteps, export a NIR graph, then - only if you actually possess Akida and MetaTF - continue inside BrainChip's tools. NeuroCUDA's job ends at a validated spiking network plus a portable graph. BrainChip's job begins at MetaTF. There is no hidden third compiler in the middle that NeuroCUDA forgot to advertise.

If you do not have Akida hardware, stop after GPU or CPU validation. Publish those numbers as software-backend results. If you do have Akida hardware, you still must not attribute MetaTF success to NeuroCUDA. Attribute conversion to NeuroCUDA. Attribute Akida execution to MetaTF and to the board you ran. Split the credit the way the tools actually split the work.

This is the same honesty rule used for Loihi and FPGA, just applied to a chip NeuroCUDA has not touched. Loihi 2 in NeuroCUDA is a simulator. FPGA in NeuroCUDA is HLS C++ generation. Akida in NeuroCUDA is neither simulator nor generator. It is a gap. Gaps are allowed. Marketing around gaps is not.

Shipped NeuroCUDA backends versus Akida

Status pages fail when they only shout a negative. Contrast is how a reader trusts the negative. Here is the August 2026 evidence matrix for NeuroCUDA, with Akida in the same table so it cannot hide.

Read the SpiNNaker row next to the Akida row. That is the template for a future Akida claim. Two independent SUCCESS jobs on two boards, with spike counts, firmware versions, and a result file in the repo, turned SpiNNaker from a slogan into a citable smoke test. Details live on NeuroCUDA SpiNNaker physical silicon. Akida has no analogue of #420148. Until it does, do not write "NeuroCUDA on Akida" in a results section.

Read the Loihi row as a second warning. Simulator evidence is real evidence of a kind, and it is still not silicon. The PyTorch to Loihi 2 guide explains that NeuroCUDA checks IF math against Intel's published equations. That is more than Akida currently has, and it is still labeled simulator only. If even Loihi - which has equation-level checks - is not called silicon, Akida - which has no NeuroCUDA path at all - cannot be called supported.

Read the FPGA row as a third warning. Generating C++ is not running a bitstream. The dedicated write-up is NeuroCUDA FPGA HLS. Do not collapse FPGA PoC, Loihi sim, SpiNNaker smoke tests, and Akida absence into one "multi-chip" sentence. Reviewers who have been burned by neuromorphic marketing will unpack that sentence and reject the paper.

HowTo: convert, export NIR, then vendor tools

This HowTo is the honest substitute for a missing Akida backend. It is not a claim that the last step is automated. It is the sequence people searching NeuroCUDA Akida actually need.

Step 1: Install NeuroCUDA

Use a virtualenv. Install PyTorch first so the CUDA or CPU wheel matches your machine. Then install NeuroCUDA. NIR extras often live behind the [all] extra, so use that if the next step is export.

python3 -m venv .venv
source .venv/bin/activate
pip install -U pip
pip install torch torchvision
pip install neurocuda
pip install neurocuda[all]
python -c "import neurocuda; print(neurocuda.__version__)"

Package page: pypi.org/project/neurocuda. Local install details: pip install neurocuda guide. Hosted GPU: NeuroCUDA on Google Colab. Container path when it ships as its own article: NeuroCUDA Docker. None of those environments magically add Akida.

Step 2: Convert the PyTorch checkpoint on GPU or CPU

Load a trained ReLU torch.nn.Module. Prepare an in-distribution calibration loader. Call convert, then compile to a backend that actually exists.

import torch
import neurocuda

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = torch.load("ann_checkpoint.pth", map_location=device)
model.eval()

snn, meta = neurocuda.convert(model, calib_loader)
neurocuda.compile(snn, target="gpu")   # or target="cpu"
# neurocuda.compile(snn, target="akida")  # NOT SUPPORTED - do not uncomment

Full conversion API, QCFS, BPTT, and evaluation: convert PyTorch to SNN. Timestep choice (T=8/16/32) is a separate decision and belongs on SNN timesteps explained when you need the accuracy versus latency tradeoff rather than a chip name. Reproduction of published GPU/CPU numbers: reproduce NeuroCUDA results.

Validate on the same software backend you compiled. Record ANN versus SNN accuracy. Record sparsity if you need an event-driven argument later. Those figures remain GPU or CPU figures. They do not become Akida figures because you hope to run MetaTF next week.

Step 3: Export NIR as the handoff file

NIR is the Neuromorphic Intermediate Representation, a vendor-neutral spiking graph. NeuroCUDA writes it with neurocuda.to_nir. Definition: what is NIR. Command path: export PyTorch to NIR.

neurocuda.to_nir(snn, "model.nir")
# Keep the file, the convert metadata, and the GPU/CPU scores together.
# A .nir file is not a MetaTF project and not an Akida binary.

Export is the correct handoff because it does not pretend NeuroCUDA speaks Akida. A later researcher with MetaTF, a custom importer, or a future NeuroCUDA release can start from the graph. Today, that later step is outside NeuroCUDA. If NIR import into MetaTF is not documented by BrainChip for your graph dialect, you may still be blocked. That blockage is a vendor-toolchain problem, not proof that NeuroCUDA "almost" supports Akida.

Step 4: Continue in MetaTF only if you have Akida

If you do not have a board, an official BrainChip emulator, and a MetaTF license or install, stop. You already have a converted SNN and a NIR file. That is a complete NeuroCUDA result.

If you do have those BrainChip pieces, open MetaTF and follow BrainChip's conversion and quantization rules. Expect to reshape layers, restrict operators, and re-validate accuracy on their path. Do not assume a NeuroCUDA IF network is a drop-in Akida network. Akida's event-based convolution is not the same object as NeuroCUDA's integrate-and-fire replacement of ReLU. You may need an architecture that MetaTF accepts, which can mean a different model than the ResNet you converted for GPU.

When MetaTF succeeds on a board, write it up as: NeuroCUDA converted and validated on GPU; MetaTF deployed to Akida; board serial or job identifier; accuracy on that board. When MetaTF fails, write that failure up as a MetaTF or architecture constraint, not as a NeuroCUDA bug, unless convert itself was wrong on GPU.

Evidence standard: job IDs or it did not happen

NeuroCUDA adopted a blunt rule after the SpiNNaker runs. Physical neuromorphic claims need identifiers a third party can look up or a result file a third party can hash. SpiNNaker-1 has job #420148 (13 July 2026, board 10.11.242.169, 43 chips) and job #420186 (17 July 2026, board 10.11.196.49, 48 chips). Both returned SUCCESS with matching spike counts on a 4-neuron PyNN network. That is a smoke test, not ResNet silicon accuracy, and it is still infinitely more than Akida currently has in this repo.

There is no Akida job ID in the NeuroCUDA GitHub repository, the technical report at quantaracore.in/neurocuda/paper.pdf, or this website. There is no board IP, no firmware string, no MetaTF version pin, and no spike log from an Akida chip. Therefore there is no physical Akida claim. If a slide deck shows an Akida photo next to a NeuroCUDA logo, the photo is decoration.

The same standard rejects "we could deploy to Akida because NIR is portable." Portability is a format property. Deployment is a runtime property. NIR portability is documented on the NIR pages. Akida runtime is not documented for NeuroCUDA. Mixing the two is how intermediate representations get over-claimed across the field, not only in this project.

GitHub slogans are not backends

Repository descriptions sometimes list many neuromorphic names in one breath: Loihi, SpiNNaker, Akida, FPGA, GPU, CPU. Marketing copy compresses a roadmap and a wish list into a single clause. This status page decompresses that clause.

Inspect the tree. neurocuda/backends/ contains GPU, CPU, SpiNNaker, Loihi, Loihi2 Lava helpers, BrainScaleS, and NIR bridge modules. It does not contain Akida. Search the repo for MetaTF or BrainChip integration code and you will not find a compiler backend. A description line that includes the word Akida without a module is not support. This article is the public errata for that confusion.

If you maintain forks, course notes, or awesome-lists, link this URL rather than repeating the compressed description. Linking the chips guide instead would send readers into architecture comparisons they did not ask for. Linking the product hub at /neurocuda is fine for install and published GPU numbers. Linking here is required when the question is Akida support.

What would be required to change this status

A future NeuroCUDA release can flip this page from NOT SUPPORTED to a narrower honest label. The bar is the same bar SpiNNaker already met, plus whatever BrainChip requires legally and technically.

• A backend module in the public repo, with a documented target string, not a comment in a README
• A MetaTF or BrainChip SDK integration that a third party can run, including version pins
• At least one public job identifier or board log showing spikes or classifications on physical Akida silicon
• A clear split between emulator results and silicon results
• An update to the cite NeuroCUDA labels so papers stop copying the old negative

Until those exist, do not pre-announce support in abstracts. Do not write "targets include Akida" in a contributions bullet. Do not put Akida in a multi-backend deviation table. Empty columns look like missing homework. Missing columns look like honesty.

If you are a collaborator with Akida access and you want to help, the useful contribution is a job log and a minimal network, not a new slogan. Open an issue on GitHub with the evidence, not with a request to add the logo first.

What you must not write in papers

Citation hygiene for NeuroCUDA lives on cite NeuroCUDA. The Akida-specific prohibitions are listed here so they cannot be missed.

• Do not write that NeuroCUDA deploys to BrainChip Akida.
• Do not write that NeuroCUDA was validated on physical Akida silicon.
• Do not invent job IDs, board names, or MetaTF wrapper functions.
• Do not treat GPU accuracy, SpiNNaker smoke tests, or Loihi simulation as Akida results.
• Do not treat NIR export as Akida compilation.
• Do not treat FPGA HLS C++ as a stand-in for Akida (different vendor, different artifact, still not a bitstream).
• Do not cite this page as evidence that Akida is unsupported by BrainChip. Akida is unsupported by NeuroCUDA.

Allowed sentences include: "We converted the ANN to an SNN with NeuroCUDA on GPU." "We exported NIR." "Akida deployment, if any, used BrainChip MetaTF and is outside NeuroCUDA." "NeuroCUDA Akida support is documented as NOT SUPPORTED as of 2026-08-14." Those sentences survive review.

Field context without over-claim lives on neuromorphic CUDA for the GPU simulation versus compiler distinction, and on the chips guide for hardware. Use those URLs for background. Use this URL for the support bit.

Related gaps that are not this page

FPGA HLS is a different gap with a different artifact. NeuroCUDA can generate HLS C++ and related estimates. That is still not a synthesized bitstream and still not Akida. Read NeuroCUDA FPGA HLS if your search was actually about programmable logic.

Loihi without Lava is a different gap with a simulator. Read PyTorch to Loihi 2 and Intel Lava archived alternative if your search was about Intel's stack.

Conversion quality is a different job. If accuracy dropped, you need the convert HowTo or the QCFS and timestep pages, not an Akida flag. If you cannot reproduce the published GPU table, you need reproduce NeuroCUDA results.

Keeping those jobs on separate URLs is how this site avoids cannibalizing itself. The chips guide remains the encyclopedia. This page remains the status bit. Please do not merge them in a scrape or a "complete NeuroCUDA hardware" roundup that quietly upgrades NOT SUPPORTED into "targets Akida."

Frequently asked questions

Start now: pip install neurocuda · GitHub · Product hub · PDF report · status remains NeuroCUDA Akida NOT SUPPORTED