SNAX: Multidomain Research Artifacts

• SNAX is a cross-domain label representing distinct research artifacts in astrophysics, NLP, neuromorphic machine learning, and computer architecture.
• In astrophysics, SNaX standardizes X-ray light curves of young supernovae using energy-band homogenization for uniform analysis across instruments.
• In other domains, SNAX underpins an ADE extraction benchmark, a JAX-based spiking neural network simulation framework, and a hardware–software integration platform for multi-accelerator systems.

“SNAX” denotes several unrelated research artifacts whose shared name masks substantial differences in domain, methodology, and technical purpose. In the arXiv record, the term refers most prominently to four lines of work: the Supernova X-ray Database, written as SNaX, a curated astrophysical repository of young-supernova X-ray light curves (Ross et al., 2017, Nisenoff et al., 2020); SNAX as a benchmark for robustness to speculation and negation in adverse-drug-event extraction from social media (Scaboro et al., 2022); SNNAX, often shortened to “SNAX,” a JAX/Equinox framework for simulating and training spiking neural networks (Lohoff et al., 2024); and SNAX as an open-source hardware–software co-development framework for heterogeneous multi-accelerator systems, later also serving as the integration platform for a precision-scalable Microscaling datapath (Antonio et al., 20 Aug 2025, Cuyckens et al., 9 Nov 2025). The common acronym therefore functions less as a single concept than as a cross-domain label attached to databases, benchmarks, software stacks, and accelerator platforms.

1. Nomenclature and scope

The arXiv literature uses closely related spellings—SNaX, SNAX, and SNNAX—for distinct systems. The following summary reflects the usages explicitly documented in the cited papers.

Name	Domain	Primary function
SNaX	Astrophysics	Database of supernova X-ray light curves
SNAX	NLP / pharmacovigilance	Benchmark for negation and speculation in ADE extraction
SNNAX	Neuromorphic ML	JAX-based framework for spiking neural networks
SNAX	Computer architecture	HW–SW framework for heterogeneous multi-accelerator clusters

In astrophysics, SNaX expands to Supernova X-ray Database and targets published X-ray observations of young supernovae (Ross et al., 2017). In natural-language processing, SNAX expands to Speculations and Negations for ADE extraction and is an adversarial benchmark for adverse-drug-event extraction under non-factual linguistic contexts (Scaboro et al., 2022). In neuromorphic computing, SNNAX means Spiking Neural Networks in JAX, though the paper notes that it is often shortened to “SNAX” (Lohoff et al., 2024). In computer architecture, SNAX names an open-source integrated framework for accelerator-centric clusters built around a hybrid coupling scheme and an MLIR-based compiler (Antonio et al., 20 Aug 2025).

This multiplicity is not merely lexical. Each artifact embodies a different research pattern: curation and standardization in observational astronomy, robustness evaluation in biomedical NLP, differentiable simulation infrastructure for SNNs, and compiler-assisted hardware integration for embedded AI systems. A plausible implication is that references to “SNAX” in technical discussion require domain qualification to avoid serious ambiguity.

2. SNaX in astrophysics: the Supernova X-ray Database

In astrophysics, SNaX is a moderated, interactive repository of X-ray observations of young supernovae, designed to make published X-ray light curves easy to find, compare, analyze, and download (Ross et al., 2017). It was launched with a special emphasis on Type IIn supernovae and is being expanded to include all core-collapse supernovae for which X-ray data have been published. The database focuses on the temporal evolution of X-ray flux and luminosity from days to years after outburst, covering the interval in which shock interaction with circumstellar material is brightest and most diagnostic of progenitor mass loss and environment (Ross et al., 2017).

The scientific rationale is that X-ray emission from young supernovae—whether thermal bremsstrahlung and line emission or non-thermal inverse Compton and synchrotron emission—traces post-shock density, shock regime, and circumstellar structure. Used together with spectra and multi-wavelength data, these measurements can constrain progenitor mass-loss histories, density profiles, kinematics, and abundances (Ross et al., 2017). By the time of the original SNaX paper, the number of X-ray-detected supernovae had grown to more than 60, making manual aggregation across instruments and publications increasingly difficult; SNaX was introduced as a central, curated resource that also homogenizes flux measurements into a common comparison band (Ross et al., 2017).

For each observation, SNaX stores count rates, X-ray flux, associated errors, and the energy band in which the flux was measured. For each supernova, it stores overview parameters including distance, explosion or outburst epoch, and coordinates, which are then used to calculate luminosities and ages uniformly across entries. Luminosity is computed as $L_X = 4\pi D^2 F_X$, using a single adopted distance for each object (Ross et al., 2017). The database also computes and stores the age at observation, enabling direct light-curve construction.

A defining design choice is energy-band homogenization. Published supernova fluxes are reported in many instrument-specific bands, including 0.2–2, 0.4–2, 0.5–8, 2–8, 2.4–10, and 0.2–10 keV. SNaX converts most datapoints to a common 0.3–8 keV band, chosen as the overlapping, practical band for Chandra, XMM-Newton, and Swift-XRT, so that light curves can be directly compared across objects and observatories (Ross et al., 2017). Conversions are performed automatically using HEASARC PIMMS with stored model parameters such as $N_H$, $kT$, or photon index $\Gamma$. Conceptually, the standardized flux is represented as

$$F_{0.3\text{–}8\ \mathrm{keV}}=\int_{0.3}^{8} S(E)\,dE .$$

When only count rates are available, SNaX uses the assumed model and instrument response to convert count rate to flux through $F_X = CR \times CF$ (Ross et al., 2017).

The database explicitly records caveats attached to this standardization. PIMMS-based conversions assume solar abundances and single-component spectral models; they do not encode detailed abundance patterns or multiple spectral components. In some cases, moderators download and refit data, especially for high-resolution Chandra or XMM-Newton observations, to recompute the 0.3–8 keV flux. Multiple published models for the same dataset are retained, and moderator recomputations are marked clearly (Ross et al., 2017). This balance between standardization and provenance preservation is central to the database’s scientific utility.

3. SNaX interface, curation, and long-term maintenance

SNaX exposes a flexible web interface that supports searching by supernova name, type, host galaxy, explosion date, age since outburst, luminosity bounds, and satellite or instrument used (Ross et al., 2017). Results can be sorted by any displayed parameter and expanded to reveal all datapoints and associated citations, with NASA ADS bibcodes embedded in the interface. Users can overlay multiple supernovae on a single plot, include or exclude specific datapoints, display upper limits, and customize axis type, axis ranges, titles, legend placement, legend columns, and plot size. Both plots and underlying data are downloadable, and tabular exports are available as CSV or TSV. Searches performed through the web interface can also be reproduced through a JSON-returning API (Ross et al., 2017).

The database is intentionally moderated. Submissions are uploaded through a web form using a CSV template, parsed server-side, previewed, and then stored in a duplicate staging structure pending moderator review. If a submission passes integrity and formatting checks, it is promoted to the main database; when possible, standardized 0.3–8 keV conversion is performed at that stage (Ross et al., 2017). Moderators also ingest literature proactively, adding published X-ray supernova fluxes and, where feasible, computing missing standardized fluxes.

The backend is a MySQL relational database with a PHP/JavaScript interface and plotting via the flot library built on jQuery (Ross et al., 2017). Its core tables comprise a supernova table, an observation table, a measurement table, and a model table, together with calculated fields such as age at observation and luminosity from the adopted distance (Ross et al., 2017). Because SNaX enforces a single adopted distance and explosion date per object, its luminosities may differ from values in individual papers that assumed alternative distances.

A later research note documents infrastructure work aimed at long-term stability. The service was updated from PHP5 to PHP7, received security updates including cross-site scripting hardening, and was moved to a new server while preserving the established workflow for end users (Nisenoff et al., 2020). The note emphasizes that SNaX remains a curated, publicly accessible repository of X-ray measurements of supernovae and invites continued data download and spreadsheet-based contribution by astronomers with published X-ray supernova measurements (Nisenoff et al., 2020). This maintenance paper is significant because it frames SNaX not only as a scientific database but also as a sustained community resource whose reliability depends on software-stack modernization and moderation continuity.

The main limitations are likewise explicit. SNaX ingests published data with ADS entries, excludes poster-only results, and cannot incorporate light curves that appear in papers without tabulated values. Band conversions remain constrained by single-component, solar-abundance assumptions, upper limits are ignored in regression fits, and asymmetric errors are simplified to lower bounds for fitting purposes (Ross et al., 2017). Planned expansions include continued addition of published X-ray supernova data beyond Type IIn, broader instrument coverage, and eventual inclusion of reduced X-ray spectra in FITS format when the community begins publishing spectral files more routinely (Ross et al., 2017).

4. SNAX in pharmacovigilance: a benchmark for negation and speculation

In biomedical NLP, SNAX denotes a benchmark and dataset for Speculations and Negations in ADE extraction from social media (Scaboro et al., 2022). Its purpose is to stress-test adverse-drug-event extraction systems on English tweets containing non-factual contexts, specifically negation and speculation. The benchmark addresses a practical pharmacovigilance problem: systems that extract ADE mentions from user-generated content often treat symptom mentions as positive signals even when the post denies or questions a drug–event relation, thereby generating spurious downstream alerts (Scaboro et al., 2022).

SNAX partitions tweets into four classes: A, containing ADEs; X, not containing ADEs; N, explicitly negating an ADE; and S, speculating about or questioning an ADE (Scaboro et al., 2022). The benchmark draws on SMM4H ADE datasets as its base source. Real N and S examples were recovered by pre-filtering the SMM4H classification corpus with cue-word lists and then manually retaining only those cases where the cue applied to an ADE relation. Artificial N and S examples were also created by expert annotators through controlled edits to ADE-containing tweets from SMM4H’19. The paper reports 251 artificial N tweets and 227 artificial S tweets, with more speculative edits discarded for lack of consensus, suggesting that speculation is harder to construct unambiguously than negation (Scaboro et al., 2022).

The dataset supports token-level BIO tagging for ADE span extraction. However, in N and S posts used for robustness testing, ADE spans are not considered factual targets, so any predicted ADE overlapping these texts is counted as a false positive (Scaboro et al., 2022). SNAX itself does not include scope annotations for negation or speculation; instead, scope is provided by auxiliary detectors trained on the BioScope corpus.

Evaluation in the benchmark centers on four state-of-the-art ADE extraction systems framed as token-level BIO sequence taggers: BERT, SpanBERT, PubMedBERT, and EnDR-BERT (Scaboro et al., 2022). Performance is measured with SMM4H relaxed span-level precision, recall, and F1,

$$R = \frac{TP + 0.5 \times Par}{TP + Par + FN}, \qquad P = \frac{TP + 0.5 \times Par}{TP + Par + FP}, \qquad F1 = \frac{2PR}{P + R},$$

while robustness is quantified through false-positive counts per class (Scaboro et al., 2022). Each reported metric is averaged over five runs.

The benchmark’s empirical result is that baseline ADE extractors are fragile to negation and speculation. False positives concentrate especially in negated contexts; for example, in the baseline setting BERT has 209.8 total false positives, of which 74.0 occur in class N, while EnDR-BERT has 189.8 total false positives, of which 60.6 occur in class N (Scaboro et al., 2022). The paper then evaluates two robustness strategies. The first is data augmentation with synthetic N and S examples, which reduces false positives substantially while typically improving precision and slightly lowering recall. For example, EnDR-BERT’s N-class false positives fall from 60.6 to 15.2 when trained with N augmentation, and its total false positives fall from 189.8 to 99.0 when trained with both N and S augmentation (Scaboro et al., 2022). The second is post-hoc model combination, where ADE spans overlapping predicted negation or speculation scopes are suppressed using regex-based or BERT-based detectors. This can remove about 50% of excess predictions for negation and up to 80% for speculation, though often with a sharper recall penalty (Scaboro et al., 2022).

The pipeline formulation is explicit. Given text $t$, an ADE extractor outputs substrings $A(t)=\{a_1,\dots,a_n\}$, while negation and speculation detectors output scope substrings. Filtered sets are defined by excluding ADE spans that overlap any negation or speculation scope:

$$A \circ N(t)=\{a_j \in A(t)\mid \forall n_i \in N(t),\ a_j \cap n_i = \varnothing\},$$

$N_H$0

The relative reduction in false positives is computed as

$N_H$1

This makes SNAX not just a test set but a methodological vehicle for measuring factuality robustness in social-media pharmacovigilance (Scaboro et al., 2022).

Its limitations are also clear: the benchmark is Twitter-only and English-only, many N and S training examples are synthetic, no in-dataset scope annotations are provided, and robustness is inferred from false-positive distributions rather than evaluated through a direct factuality metric (Scaboro et al., 2022). The paper therefore proposes joint learning of ADE extraction and factuality as a future direction. This suggests that SNAX occupies a transitional position in the literature: it exposes a weakness in existing systems and supplies practical mitigation strategies, but does not yet close the modeling gap between span extraction and factuality reasoning.

5. SNNAX (“SNAX”) in neuromorphic machine learning

In neuromorphic ML, SNNAX—often shortened to “SNAX”—is a JAX-based framework for simulating and training spiking neural networks with PyTorch-like intuitiveness and JAX/XLA execution speed (Lohoff et al., 2024). The paper positions it between two families of SNN tooling: biology-first simulators such as NEST, Brian2, and GeNN, which emphasize biological fidelity and reproducibility but lack differentiability and mainstream ML training pipelines, and ML-oriented SNN libraries such as snnTorch, Norse, SpikingJelly, SINABS, Rockpool, Spyx, and Slax, which make different trade-offs in speed, event-driven versus clock-driven simulation, recurrent support, and deployment pathways (Lohoff et al., 2024).

SNNAX is built on Equinox, which represents parameterized modules as callable PyTrees and thereby keeps models directly compatible with JAX transformations without requiring the additional scaffolding associated with Haiku or Flax (Lohoff et al., 2024). The framework relies on jax.jit for compilation, jax.vmap for batching, and jax.pmap together with array sharding for multi-device execution. All modules are immutable PyTrees and execution uses pure step functions, so JAX transformations compose cleanly. State handling is explicit but abstracted: spiking networks are treated as recurrent networks with internal states such as membrane potential and synaptic traces, and SNNAX provides initialization and update mechanisms while leaving the internal state accessible (Lohoff et al., 2024).

The paper formulates the general discrete-time SNN update as

$N_H$2

where $N_H$3 aggregates per-neuron states, $N_H$4 are spikes or activities, and $N_H$5 is the discontinuous threshold function (Lohoff et al., 2024). Although the framework is demonstrated with leaky integrate-and-fire neurons, the state-update abstraction is intentionally agnostic to neuron complexity. The paper also presents typical continuous-time LIF dynamics and their Euler discretization, together with exponential synapses and surrogate derivatives for the threshold function (Lohoff et al., 2024).

A central technical contribution is support for step-by-step simulation of the entire network, which enables arbitrary recurrent connectivity across layers and is contrasted explicitly with layer-by-layer execution in Spyx and Rockpool (Lohoff et al., 2024). This design favors biologically plausible models and algorithms such as e-prop, although it may be slower on strictly feed-forward architectures than approaches that unroll jax.lax.scan in a more feed-forward-optimized manner. To mitigate memory costs associated with long sequences and backpropagation-through-time, the framework uses JAX’s gradient checkpointing and forward-mode automatic differentiation (Lohoff et al., 2024).

Training treats SNNs as RNNs over time and uses BPTT via JAX automatic differentiation. The example objective aggregates output spikes across time,

$N_H$6

and then applies softmax cross-entropy to the resulting class scores (Lohoff et al., 2024). Surrogate gradients replace the derivative of the Heaviside function with smooth approximations such as piecewise-linear or sigmoid-based forms, and the framework allows custom surrogate definitions and custom gradient rules (Lohoff et al., 2024). The user-facing API includes convenience structures such as snnax.Sequential, snnax.SequentialRecurrent, and GraphStructure for arbitrary feedback topologies.

Performance claims are deliberately scoped. The paper reports execution-time comparisons for LIF-based MLP and CNN benchmarks on a single RTX 4090 GPU with batch size 32, and describes SNNAX as competitive “without the need for writing custom CUDA code” (Lohoff et al., 2024). At the same time, it acknowledges that layer-by-layer libraries can outperform it on pure feed-forward workloads because SNNAX prioritizes recurrence support over that optimization. This makes the framework most significant not as a universal fastest SNN library, but as a JAX-native research environment for algorithmic exploration with recurrent structure, flexible automatic differentiation, and minimal PyTree-based boilerplate (Lohoff et al., 2024).

6. SNAX as a hardware–software framework for heterogeneous accelerators

In computer architecture, SNAX is an open-source hardware–software co-development framework for efficient multi-accelerator systems (Antonio et al., 20 Aug 2025). Its central architectural idea is a hybrid coupling scheme that separates control and data paths: control is loosely coupled and asynchronous, while data access is tightly coupled through a shared scratchpad memory and TCDM interconnect (Antonio et al., 20 Aug 2025). The motivation is to avoid the shortcomings of both tightly coupled accelerators that stall host CPUs and loosely coupled DMA-driven accelerators that incur data-movement overheads and require substantial manual orchestration.

On the control side, lightweight RISC-V integer cores act as management units and offload work to accelerators through a uniform CSR interface using a valid–ready register-mapped protocol. The “fire-and-forget” model allows cores to configure accelerators and then proceed without blocking, while double-buffered control registers hide setup latency by preloading the next configuration during ongoing execution (Antonio et al., 20 Aug 2025). On the data side, all accelerators access a shared multi-banked scratchpad memory directly through a configurable TCDM interconnect, enabling single-cycle reads and writes and eliminating inter-accelerator DMA round-trips (Antonio et al., 20 Aug 2025). Data streamers with autonomous address generation, FIFO buffering, and hardware loop support sustain cycle-by-cycle feeds into accelerators and reduce the impact of memory conflicts.

The software stack, SNAX-MLIR, ingests ML workloads, maintains a hardware-aware intermediate representation, and automates device placement, static scratchpad allocation, asynchronous scheduling, and accelerator programming (Antonio et al., 20 Aug 2025). The compiler emits RISC-V code that uses only uniform CSR read and write operations; accelerator-specific ISA extensions are not required. System management tasks such as buffering, DMA scheduling, and barrier insertion are thus handled at compile time, yielding deterministic execution without an operating system (Antonio et al., 20 Aug 2025). This design positions SNAX as both a platform and a methodology: hardware interfaces are standardized so that compiler automation can reason globally about memory placement, synchronization, and overlap of compute with data transfer.

The paper’s developer workflow reflects this co-design philosophy. Integrating a new accelerator requires defining a CSR register map and TCDM-attached data interfaces, providing compiler descriptors for supported kernels and streamer capabilities, adapting the datapath, generating the configured cluster, compiling the workload through SNAX-MLIR, and then deploying the generated RISC-V binaries (Antonio et al., 20 Aug 2025). This indicates that SNAX is meant not only for users of a fixed accelerator platform but for designers constructing customized accelerator clusters.

Quantitative evaluation is reported for a low-power heterogeneous SoC synthesized in TSMC 16 nm at 800 MHz. The paper studies a baseline single RISC-V32I core, then adds a GeMM accelerator and a max-pool accelerator. Adding GeMM yields a 152× throughput boost for convolution relative to the RISC-V-only baseline, adding the max-pool accelerator adds 6.9× more throughput for pooling bottlenecks, and pipelined producer–consumer execution across GeMM, max-pool, FC on RISC-V, and DMA yields an additional 3.18× improvement over layer-by-layer sequential execution (Antonio et al., 20 Aug 2025). The tiled matrix-multiply roofline sweep reaches up to 92% PE utilization at high arithmetic intensity and uses 79% of available AXI bandwidth on average in low-arithmetic-intensity, memory-bound cases (Antonio et al., 20 Aug 2025). The abstract summarizes the overall system-level outcome as more than 10× improvement in neural network performance compared with other accelerator systems while maintaining more than 90% accelerator utilization in full-system operation (Antonio et al., 20 Aug 2025).

The paper also states explicit trade-offs. Tight data coupling requires tailored streamers and TCDM sizing, increasing area for ports and FIFOs, while compile-time scheduling limits dynamic reactivity because workloads are fixed to preserve determinism (Antonio et al., 20 Aug 2025). Future work includes richer synchronization primitives, adaptive scheduling, larger hierarchical scratchpads, QoS-aware arbitration, and stronger multi-tenant isolation (Antonio et al., 20 Aug 2025). In that sense, SNAX is best understood as a deterministic, compiler-managed embedded AI substrate rather than a general-purpose heterogeneous runtime.

7. SNAX as an integration platform for precision-scalable Microscaling datapaths

A later paper uses SNAX as the integration platform for an 8×8 array of precision-scalable Microscaling MACs intended to support both training and inference in a unified NPU fabric (Cuyckens et al., 9 Nov 2025). Here SNAX is no longer only the cluster framework of the earlier work; it is the concrete control, memory, and streaming substrate into which the MX tensor core is embedded. The platform description is correspondingly more specific: a single RV32IMAFD Snitch core orchestrates the accelerator via CSR writes, a 128 KiB shared scratchpad memory is 32-banked and fully crossbar-connected, and a DMA engine provides 512-bit peak transfer bandwidth between external memory and the scratchpad (Cuyckens et al., 9 Nov 2025).

The accelerator itself is an 8×8 2D mesh of 64 precision-scalable MX MAC units, followed by a SIMD quantization unit (Cuyckens et al., 9 Nov 2025). Three CSRs control the main mode parameters: one selects MX precision, one sets accumulation depth, and one sets tile dimension. Separate streamers feed the two input matrices using programmable address-generation units, and the paper adds dynamic channel gating so that the streamer activates only the channels required by the current precision mode: 1 channel for MXINT8, 4 for MXFP8, 3 for MXFP6, and 4 for MXFP4 (Cuyckens et al., 9 Nov 2025). This is presented as a way to reduce both energy and bank contention.

At the arithmetic level, the paper proposes a hybrid precision-scalable reduction tree. L2 produces a 28-bit product sum, while accumulation uses early alignment of the FP partial sum to the product sum. A selective-extension multiplexer exploits the observation that two 24-bit extensions are never simultaneously required, reducing the normalization input width from what would otherwise drive a 77-bit normalization datapath to a 53-bit normalization datapath (Cuyckens et al., 9 Nov 2025). Error analysis relative to FP64 shows that quantization error in the final MX result dominates addition error down to approximately 13 bits for MXFP8 E4M3 at 64×64, leading the design to choose a 16-bit mantissa for stored partial sums as a conservative operating point (Cuyckens et al., 9 Nov 2025).

The system-level operating point is GlobalFoundries 22FDX, 0.8 V, typical-typical corner, at 500 MHz (Cuyckens et al., 9 Nov 2025). Throughput follows directly from 64 MACs and the number of operations per MAC per cycle: 64 GOPS for MXINT8, 256 GOPS for MXFP8/6, and 512 GOPS for MXFP4 (Cuyckens et al., 9 Nov 2025). Reported energy efficiencies are 657 GOPS/W for MXINT8, 1438–1675 GOPS/W for MXFP8/6, and 4065 GOPS/W for MXFP4 (Cuyckens et al., 9 Nov 2025). Across ResNet-18 and Vision Transformer training in FP8 E4M3 and inference in INT8 at batch size 32, temporal utilization is 94.41%–99.51%, which the paper attributes to the combination of CSR control, dynamic streamers, and scratchpad bandwidth (Cuyckens et al., 9 Nov 2025).

This integrated design highlights an important continuity between the two hardware SNAX papers. The earlier framework paper presents SNAX as a reusable HW–SW substrate for multi-accelerator systems (Antonio et al., 20 Aug 2025); the later MX paper demonstrates that the same substrate can host a markedly different datapath whose challenges center on mixed-precision accumulation, quantization, and training–inference mode switching (Cuyckens et al., 9 Nov 2025). A plausible implication is that SNAX’s uniform CSR control and tightly coupled scratchpad abstraction are intended to be general enough to support not only conventional kernel accelerators such as GeMM and max-pool engines, but also more specialized arithmetic fabrics with mode-dependent streaming requirements. In that respect, the MX study functions as an existence proof for SNAX as an extensible accelerator-integration platform rather than only a single system instance.