A pipeline reads left to right: a dataset, a query against it, a transform or two, and a viewer at the end. Pick any card to see its sockets, its settings and the card it draws on the canvas.
The legend below illustrates the most important elements you will find on a node.
Hover a label to see a short description.
Whether the card’s result is current. A glyph as well as a colour, so it reads without telling the hues apart; the stripe down the left edge repeats it.
Double-click to rename. The name is saved with the workflow; the node’s type underneath it does not change.
Folds the settings and socket rows away, giving the space to what the card draws. Wires stay connected — the sockets move onto the header.
Folds the whole card down to its header. Unlike ☰, nothing below the header is kept.
The header is the node’s category — green dataset, blue query. The stripe down the left edge is the run state, readable at a zoom where the badge is not.
Attaches a user-supplied edge list of pre, post, weight. Connectivity below this card is then answered from the file rather than the server.
The age of this dataset’s downloaded neuron table, which is kept for a month. Click to drop it and fetch again.
What the node reports about itself. Amber warns and the result stands; red means there is no result. The inspector lists the rest.
Colour, shape and the socket label all give the type — here, a Dataset. A wire only connects sockets whose types match; dragging one dims the rest.
Runs this node and any stale nodes above it, not the whole graph. Disabled when the result is current, and ■ while a run is going.
Opens the result full size over the canvas. Double-clicking the drawing on the card does the same.
Docks the result beside the canvas, where it stays while you work on other cards. One node at a time.
Opens this node’s help document. Present only on node types that have one written.
Typed for the value it accepts. A required input left unwired is why a card reports that it has nothing to work on.
Which one the wire leaves from decides what the rest of the graph sees. Hover a socket to preview the value on it.
Settings that live in the inspector rather than on the card. Click to select the node and open it; any that have been changed are counted.
+ page selects this page and + all every match; the count clears the selection. It leaves by the Selected port and is saved with the workflow.
Nothing matches . Try a socket type — matrix, skeletons — or a setting like hops.
The same 119 nodes as the grid above, written out in one page — grouped the way a pipeline runs, so it can be read straight through or searched with the browser's own find. Each entry names what the node takes and hands on, and whether it runs as you type or waits for Run.
Where the data comes from. One node per published connectome, plus a custom deployment.
dataset.bancAnnotations? → Datasetruns live
Adult female fly brain and ventral nerve cord.
The public BANC segmentation read through CAVE. It exposes the full brain-and-nerve-cord volume, and the neuron table is the public cell list published alongside the stack.
annotation.caveTableDataset?, Annotations? → Annotationsruns on Run
Neuron labels from an annotation table inside a CAVE datastack. A `cell_type` column arrives renamed `type`, the name Coda reads a cell type from.
Reads a CAVE annotation table and hands it to a Dataset as its labels. Name the datastack; wire the Dataset input to read from a different datastack only (wiring both ways is a cycle). Set Pivot on for a one-row-per-(neuron, kind, value) table. The output is ordinary neuron table data, so Filter or Sort can edit the chain before the Dataset.
cave.tableInfoDataset? → Columnsruns on Run
What one CAVE table is: its description, its row counts and its columns.
Four reads about one table of a CAVE datastack, gathered onto one card: its registered schema and the description its publisher wrote, how many rows it holds, and the columns a query actually returns — sampled from one real row, so `pt` shows up as the pt_position_x/y/z, pt_supervoxel_id and pt_root_id a query gives you rather than as the bound point the schema declares. The two row counts on the card are both true and disagree by up to a third; the card says which is which. It also accepts a view, but a view that aggregates cannot be sampled quickly — CAVE builds the whole result before taking one row off it — so the node warns before it waits.
dataset.catmaid→ Datasetruns live
Any CATMAID project, configured by hand.
The escape hatch for a CATMAID server Coda ships no node for — a lab instance, or a second project on one it does know. Type the server URL and pick a project from the list the server answers with; project ids are per-instance, so the list is the only way to know which number is which volume. Reading a public instance needs no credential, but a server behind a login or basic auth wants a row under Connections ▸ CATMAID before the list appears — credentials there are per host, since two instances are two unrelated accounts.
dataset.caveAnnotations? → Datasetruns live
Any CAVE datastack configured by hand.
For CAVE datastacks Coda ships no node for. Name the global server that lists the datastack (H01 is on global.brain-wire-test.org), the datastack, and — since nothing in a datastack marks one table as the neurons — that table and its root-id column. Each deployment has its own sign-in. Materializations expire, so pin one you have checked.
dataset.neuprint→ Datasetruns live
Configure a neuPrint dataset by hand.
The escape hatch for a dataset Coda ships no preset for: a release newer than this build, a private dataset, or a neuPrint instance somewhere else entirely. Type the server and the dataset id exactly as that server names it, version included. Note that Server here means a neuPrint deployment, not the Base URL override under Connections — the two are different settings and naming one does not set the other.
dataset.mock.opticlobe→ Datasetruns live
Synthetic optic-lobe-like connectome generated in the browser. No token needed.
A synthetic optic lobe, generated in the browser with the columnar repetition a real one has. Nothing is fetched and no token is needed — it is deterministic from a seed, so a graph built on it gives the same answer on any machine. It is what the Workflow Wizard’s demo workflows and the guided tours run on, and the right place to try a pipeline before pointing it at a real volume.
dataset.descriptionDataset →runs live
What a dataset covers, who made it and how to cite it, as its publisher states it.
A credit card, and the text on it is the publisher’s rather than ours — neuPrint ships a markdown blurb per dataset naming the project, its companion viewers and the papers to cite, which nothing else in Coda renders. It arrives already wired whenever you add a dataset node, because a connectome is years of somebody’s reconstruction work published with a request for attribution, and a picker labelled “MaleCNS” gives no hint of that. Delete it and it stays deleted; Add ▸ Dataset ▸ Description brings it back.
dataset.catmaid.fafb→ Datasetruns live
Early manual reconstructions in an female fly brain. Published data hosted by VFB.
A few thousand hand-traced neurons on the same image volume as FlyWire. Hosted by the Virtual Fly Brain at https://catmaid-fafb.virtualflybrain.org/.
dataset.fib19→ Datasetruns live
Partial reconstruction of a female fly’s visual system: medulla, lobula and lobula plate.
A partial reconstruction covering portions of the fly medulla, lobula, and lobula plate to reveal connectivity patterns in the visual motion detection pathway.
annotation.flyTableAnnotations? → Annotationsruns on Run
Neuron labels from a FlyTable base. A `cell_type` column arrives renamed `type`, the name Coda reads a cell type from.
FlyTable is the LMB’s SeaTable deployment, where FlyWire’s live cell typing lives. It downloads whole bases (the column-selection endpoint is not browser-readable), cached once per base per session. The output is ordinary neuron table data, so a Table node shows what you got, and Filter or Sort can tidy it before the Dataset.
dataset.flywireAnnotations? → Datasetruns live
Whole adult female fly brain (optic lobes + central brain).
Public FlyWire segmentation read through CAVE, so version is a materialization number. Cell annotations download once per dataset and search locally—first query waits, rest are instant. Meshes, synapses and skeletons work, the skeletons only on materialization 783, which is the one that publishes them. Paths and per-region counts do not; nodes that need them decline rather than fail.
annotation.googleSheetAnnotations? → Annotationsruns on Run
Neuron labels from a shared Google Sheet, read through its CSV export URL. A `cell_type` column arrives renamed `type`, the name Coda reads a cell type from.
Reads a Google Sheet that needs no login — Share as anyone-with-link ▸ Viewer. Paste the URL into Sheet; Tab selects a different tab by its numeric gid. The output is an ordinary neuron table, so Filter or Sort can edit it before the Dataset.
dataset.hemibrain→ Datasetruns live
Approximately half a central brain of an adult female fly.
Approximately one hemisphere of the central brain (with bits of the right optic lobe). Rich annotations: cell type, class, cell body fibre, soma radius, hemilineage, etc.
dataset.catmaid.l1→ Datasetruns live
Central nervous system of a first-instar fly larva. Densely reconstructed brain, sparse elsewhere. Published data hosted by VFB.
The larval connectome: 5,013 hand-traced neurons across the whole first-instar central nervous system, brain to abdominal neuromeres, hosted by Virtual Fly Brain at https://l1em.catmaid.virtualflybrain.org/. Unlike FAFB this instance meta-annotates nothing, so a neuron’s type is its own name and its large bag of annotations shows as Additional tags.
cave.tablesDataset? → Tablesruns on Run
Every annotation table and view a CAVE datastack publishes.
Lists what is actually in a CAVE datastack, which is otherwise something you have to know before you can ask: nothing in a datastack marks one table as the neurons or another as the cell types, so this is where the names for CAVE table and CAVE table info come from. Tables and views are separate things on separate endpoints and the Kind column says which — worth knowing, because the view is often the useful one (FlyWire aggregates its connectivity into valid_connection_v2, and no table holds that). Names only, by design: a description per table would be a request per table, and CAVE table info is that request.
dataset.malecns→ Datasetruns live
Whole central nervous system of an adult male fly — brain and ventral nerve cord.
The largest fly connectome published so far: 167k proofread neurons across brain and nerve cord, so a circuit can be followed from a sensory neuron to the motor neurons driving muscles.
dataset.manc→ Datasetruns live
Nerve cord of a male adult fly.
The ventral nerve cord on its own: motor neurons, the premotor circuits driving them, and the descending neurons arriving from the brain.
dataset.minnie65Annotations? → Datasetruns live
A public mouse visual cortex volume from the MICrONS collaboration.
The public MICrONS Minnie65 segmentation read through CAVE. Version is a materialization number, and the neuron table is the stack’s published cell list.
dataset.mushroombody→ Datasetruns live
Reconstruction of the mushroom body’s alpha lobe.
Dense reconstruction of the alpha (vertical) lobe of the mushroom body in a male Drosophila. One of the earliest fly connectomes, contains 983 neurons.
dataset.ngsourceLayers? → Datasource, Layersruns live
Read meshes, skeletons or region shells from a neuroglancer precomputed URL.
A single neuroglancer source — the string in a layer’s Source box — with two uses. Its Datasource output is something the Meshes, Skeletons and ROI Meshes nodes can fetch from, so a bucket no connectome server knows about is still usable. A source that publishes segment properties can also be browsed and queried by name; one that does not takes its ids from an Input IDs node. Its Layers output plugs into the Neuroglancer node’s Extra layers socket, which is how a brain shell, a second segmentation or somebody’s own annotations get into that scene — chain these nodes to add more than one. Paste any of the three spellings and the card says what it found at the other end.
dataset.opticlobe→ Datasetruns live
The right optic lobe: medulla, lobula and lobula plate with bits of the central brain and the lamina
One optic lobe: medulla, lobula and lobula plate with bits of the central brain and the lamina. This is part of the MaleCNS dataset and was released before the full dataset. Mostly kept as reference for the early papers that used it.
annotation.seaTableAnnotations? → Annotationsruns on Run
Neuron labels from a SeaTable base. A `cell_type` column arrives renamed `type`, the name Coda reads a cell type from.
The same node as FlyTable pointed at cloud.seatable.io, which is the hosted service rather than the LMB’s deployment — two unrelated accounts, so each needs its own token. Use this for a base of your own; use FlyTable for the community annotations.
Ask a dataset a question. These reach the network, so they go stale and wait for Run.
neuron.adjacencyDataset, Sources, Targets → Matrix, Linksruns on Run
Synapse counts from one neuron set onto another, as a matrix and a link table.
Synapse counts from one neuron set onto another, as a matrix for the Heatmap and the same connections long for everything else — Build Network above all, which a matrix could not reach before. Two inputs rather than one because the question is nearly always “A onto B”, and pushing both through a single collection would lose exactly the grouping that makes the picture readable. Links holds one row per non-zero cell: a matrix cell is 0 where nothing was found, and keeping those would make a complete graph of zero-weight links. Its columns are source, target and weight, which are the names Build Network asks for — set Target and Weight there, since its pickers take the first column that fits rather than the one that matches. Feed the matrix through Normalize first if the counts are dominated by whichever type happens to be numerous.
neuron.connectivityDataset, Neurons → Connections, Neuron Setruns on Run
Fetch synaptic partners for the incoming neurons, one or more hops out. Rows are `preId`, `preType`, `postId`, `postType`, `weight`, `hop` and `direction`; a region split adds `roi`, and `Normalize` adds `weightNorm` and `weightTotal`.
Synaptic partners, one or more hops out. Connections is an edge list: every row is preId → postId oriented the way the synapse points, so Build Network works with nothing to think about. Neuron Set is the same result as neurons — seeds plus every partner reached — which is what Adjacency takes. Partners decides whether a fragment counts as one.
neuron.rawCypherDataset → Resultruns on Run
Run a custom Cypher query against a neuPrint dataset. Returns the results as a table.
Run a custom Cypher against a neuPrint dataset. Data is returned as an ordinary table and everything downstream works normally, with one caveat: the server decides the shape of the result, so the column pickers are empty until the first run and empty again after a reload. Queries are sent as typed, against a shared production Neo4j that takes read-only ones only.
neuron.exploreDataset → Hits, Selected, Allruns on Run
Browse every neuron in a dataset. Fuzzy search across all fields, per-field filters, and a picker.
Entry point when you don’t know what to ask for. Loads the dataset’s entire neuron table once and searches it locally as you type — fast after the initial download. Three outputs: Hits for the query, Selected for ticked neurons, and All as an ordinary table for grouping and charting.
neuron.findNeuronsDataset → Neuronsruns on Run
Search a dataset for neurons, by any field the dataset publishes.
The workhorse query: narrow to the neurons you mean, one filter row at a time. The field list is the dataset’s own — a neuPrint dataset offers status and size, a FlyWire datastack offers super_class. Rows combine with AND, and “is one of” takes several values, which is how you say OR. With no filters it returns no neurons: these run against a live server.
neuron.idsFromLabelDataset, Labels? → Neuronsruns on Run
Resolve cell type or other labels back to the neurons carrying them.
Resolve labels to neurons carrying them — the inverse of Find Neurons. Default to exact match because labels usually come from text people copied (a type column, a groupBy roll-up, a paper), and turning SMP001(a) into a regex would lose the literal parentheses.
neuron.influenceDataset, Neurons, Candidates? → Influence, Transfersruns on Run
Score every neuron by how strongly it drives, or is driven by, a set of neurons. Columns are `influence`, `influenceLog`, `hops` and `isSeed`; scoring per query adds `queryId` and `queryType`.
How strongly one neuron drives another through every path at once rather than along one route — the influence score of Bates et al. Seed the neurons you care about, walk upstream, and everything that reaches them comes back ranked. Bounded by hops rather than solved over the whole connectome, so every score is a lower bound the node puts a number on.
neuron.inputIdsDataset?, IDs? → Neuronsruns on Run
A list of neuron IDs, typed or pasted, as a table.
A list of neuron IDs you already have — from a paper, a spreadsheet, a colleague. Paste them in any form; brackets and newlines are separators. Wire a Dataset to get full rows and a count of IDs it never heard of; unwired it just emits the IDs as a one-column table.
neuron.meshesDataset, Neurons → Meshesruns on Run
Fetch surface meshes for the incoming neurons.
Neuron surface meshes; where they come from varies by source. **Detail** spends a triangle budget among the levels a source publishes, and does nothing where there is only one — **Downsample** reduces the geometry itself, anywhere. A collection carries only the fetch’s own attributes, so use Carry fields for anything else.
zapbench.neuronTracesNeurons → Matrixruns on Run
Calcium-imaging traces from ZapBench for the fish2 neurons that carry a zapbenchId.
Reads the released ZapBench calcium traces for the neurons in a fish2 table that carry a zapbenchId, as a matrix for the Heatmap or Reduce Matrix. A read is priced in 512-cell blocks of the array, not in neurons — about 16 MiB a block over the whole recording — and Condition is the only setting that makes it smaller.
neuron.pathsDataset, Sources, Targets → Network, Layout, Pathsruns on Run
Find the strongest routes from one set of neurons to another. The Paths table is `rank`, `source`, `target`, `hops`, `bottleneck` and `path`, plus `bottleneckNorm` when normalizing.
Not “what is wired to this?” but “how does this reach that?” — the strongest feed-forward routes from sources to targets, ranked by their weakest link rather than by a sum, since a chain is only as strong as its narrowest step. Collapse types traverses the type-level graph, which is usually the circuit somebody means. Three outputs: the pruned network, a layout for it, and one row per route.
neuron.roiCompletenessDataset → Completenessruns on Run
How completely each region of the dataset has been reconstructed: traced synapses against the total present.
How completely each region has been reconstructed as a percentage of pre- and postsynapses associated with proofread neurons.
neuron.roiConnectivityDataset → Matrix, Linksruns on Run
Region-to-region connectivity for the whole dataset, as a matrix and a table.
Region-to-region connectivity for the whole dataset, precomputed on neuPrint’s side, so a whole connectome answers in a few hundred kilobytes. Emits a matrix for the Heatmap and a long table for everything else. The table carries both of neuPrint’s numbers and Cells picks which fills the matrix; weight is scaled in a way the server does not document, so the legend names the measure it drew.
neuron.roiCountsDataset, Neurons → Countsruns on Run
Pre/post synapse counts per ROI for the incoming neurons.
Where these neurons put their synapses by region: one row per neuron per ROI, with pre and post separate. Long form composes with Group By and Pivot without needing a separate reshape. Region counts nest—each synapse is counted multiple times—so summing all rows roughly doubles the true total.
neuron.roiMeshesDataset → Volumesruns on Run
Fetch the 3D shells of a dataset’s neuropil regions.
The 3D shape of the dataset’s neuropils, as meshes on a wire — so the 3D View can draw an arbour inside the region it innervates. Pick regions by name, or leave the picker empty for the set that tiles the volume. Each shell is a separate request and a whole primary set runs to tens of megabytes, so this waits for an explicit Run.
neuron.skeletonsDataset, Neurons → Skeletonsruns on Run
Fetch centerline tracings for the incoming neurons.
Centerline tracings for the incoming neurons — encode both the 3D shape and topology of the cell. Coordinates come out in nanometres, so a skeleton and a mesh of the same neuron sit in the same space. Some datasets have more than one place to get a skeleton. A collection carries only the fetch’s own attributes, so use Carry fields for anything else you want to filter or colour by.
neuron.synapsesDataset, Neurons → Pointsruns on Run
Fetch synapse locations as a 3D point cloud.
Synapse locations as a 3D point cloud, one point per synapse with its polarity in the attribute table — and its partner where the data source carries one. Drawn in the same space as skeletons and meshes, so a scene can colour neurons by cell type and their synapses by direction at once. This is the node that turns “these two are connected” into “and here is where”. Backends count synapses differently, so Rows says whether a point is a connection or a site.
neuron.synapsesBetweenDataset, Sources?, Targets? → Pointsruns on Run
Fetch the synapses from one set of neurons onto another as a 3D point cloud.
Where two populations actually connect: every synapse from the Sources onto the Targets, one point per synapse connection, narrowed at the server rather than fetched for one side and filtered. Wire only Sources for everything they synapse onto, or only Targets for everything onto them — the open side then counts published neurons unless Include fragments is on. Each point carries its source as neuronId and its target as partnerId, so counting points per pair gives the Connectivity weight; Location picks whether a point sits at the presynaptic or the postsynaptic site.
zapbench.neuronsDataset, Cells? → Neuronsruns on Run
The fish2 neurons matched to ZapBench cells — from a Heatmap selection or a list.
Looks up the fish2 neurons whose zapbenchId matches a set of ZapBench cells, for Skeletons or Meshes. Wire a Heatmap’s Selected Rows into Cells — a downsampled row’s label is read as every cell it averages — or type cell ids. About one cell in eight has no EM neuron; those are counted, not errors. Wire it to a fish2 Dataset.
zapbench.traces→ Matrixruns on Run
Activity for every ZapBench cell, or for cells you list — the overview to select cells from.
Reads the ZapBench recording starting from its cells: every cell at a reduced Scale, or listed cell ids at full resolution, as a matrix for the Heatmap. Shift-drag rows on the expanded Heatmap and wire Selected Rows into ZapBench to Neurons. Rows are in activity order, and a row’s label lists the cells it averages. Quarter scale over the whole recording reads about 144 MB.
Reshape what came back — filter, join, aggregate, pivot, build a network.
neuron.attachAttributesGeometry, Table → Geometryruns live
Join a table’s columns onto skeletons, meshes or points. A carried column replaces a same-named one and keeps its place, rather than being suffixed.
Joins a table onto the attributes that skeletons, meshes or points carry, matched on a column you pick, so what a graph computes (a Cut Tree cluster, a Reduce Matrix statistic, an uploaded CSV) can colour or split a scene. With no columns picked it carries every column; an item the table does not mention keeps its geometry and carries nulls.
net.buildEdges, Node attrs? → Networkruns live
Turn an edge table into a network of nodes and links. The columns you pick are renamed: links carry `source`, `target`, `weight` and `edges`, and nodes carry `id`, `degreeIn`, `degreeOut`, `weightIn` and `weightOut` — those are the names downstream pickers see.
Turn an edge table into a network: nodes, links plus associated properties including derived ones such as in and out degree/weight. Both halves carry an ordinary attribute table, so colouring by cell type is a column picker.
neuron.cleanMeshesMeshes → Meshesruns on Run
Strip internal membrane, cap holes, decimate and smooth mesh surfaces.
Four repairs an EM mesh usually wants, in the order they compose: strip the invaginated membrane folded into the cell, cap what is left open, decimate to a fraction of the faces, and smooth. Stripping internals is the one that changes a number rather than a picture — a raw segmentation mesh has far more surface inside it than around it, so any area or volume measured from one is wrong until this has run. It is also by far the slowest, being a ray cast per face.
neuron.cleanSkeletonsSkeletons → Skeletonsruns on Run
Heal, smooth and re-sample skeletons before measuring or comparing them.
Four repairs a traced skeleton usually wants, in the one order they compose: reconnect its fragments, smooth the tracing jitter out, then either re-sample it to an even node spacing or keep every Nth node. Re-sampling is what most morphometrics want in front of them, since anything averaged per node is otherwise weighted by how finely each neurite was traced. Distances are micrometres, and the node count changes while the neuron count never does.
cluster.clustersToNeuronsClusters, Neurons? → Neuronsruns live
Put cluster numbers back onto the neurons they belong to. `cluster`, `order` and `size` ride along, and a column whose name the neuron table already uses is suffixed `_c`.
Cut Tree gives cluster numbers for leaf names, not neurons. This maps those clusters back onto the neurons they came from, so Neuroglancer can colour by cluster, Filter can isolate a group, or Group By can count. Wire the original neuron table and set "Match on" to what NBLAST used for "Label by".
core.combineColumnsTable → Tableruns live
Make one column out of several — the first with a value wins. The result takes the name in `Into` (`type` by default), backfilling that column in place when it is one of the picked ones and suffixing any other column of that name `_2`.
Make one column out of several. The columns are tried in the order you pick them and the first one holding a value wins, so cell_type then hemibrain_type means "the hemibrain type where there is no cell type". Null and blank count as the same absence. Naming the result after one of the columns you picked backfills it in place; any other name adds a column. The default name is type, which is what Coda reads a cell type from — so this is how an annotation file whose types are spread over several columns becomes one a dataset can use.
compare.connectivityEdges 1, Labels 1, Edges 2, Labels 2 → Comparison, Countsruns live
Put the same type-to-type connection side by side across two or more connectomes. Columns are `preLabel`, `postLabel`, then `weight_<name>` and `present_<name>` for each dataset, named by its `Name` param.
Takes each dataset’s edge list plus its labels from Match Cell Types, rewrites both ends into the shared label space and sums per type pair, so one row reads “LC4 to DNp01 is 30 synapses here and 6 there”. Read the present columns before the weights: 0 is a real absence, empty means the type is missing there.
cluster.cutTree → Clusters, Treeruns live
Take groups out of a merge tree, by count or by distance. The Clusters table is `label`, `cluster`, `order` and `size`.
Cut a tree into groups by count (exactly N clusters), by distance threshold, or — for two connectomes clustered together — wherever a group is lopsided, so every group draws from both brains. Cheap, just union-find and no Python, so you can retry it while looking at the dendrogram. Clusters joins back onto neurons; Tree carries the cut for Dendrogram to colour branches by group.
core.dedupeTable → Tableruns live
Drop repeated rows, comparing on the chosen columns.
Drop rows that repeat. Name the columns to compare on, or leave empty to compare whole rows for exact duplicates. Keep decides which row survives: first, last, or none at all—only rows nobody disagrees about. Keeps whole rows unchanged; unlike Group By, nothing is aggregated.
neuron.distanceQuery, Target? → Matrixruns on Run
Measure how far apart neurons are in space, or how much of one lies close to the other, as a matrix.
Measures how far apart neurons are: the closest approach, the mean or median separation, the distance between centroids, or how much cable or surface of one lies within a given distance of the other. Wire one set of skeletons or meshes for an all-by-all, or a second for one group against another. The averages are weighted by cable or by surface, so resampling upstream does not move them.
core.editTableTable → Tableruns live
Overwrite values in the rows a rule matches.
Override values in a table. Each rule names the rows to change — an Explore query like type==LC4 status==Traced, or blank for all of them — then the column to write and what to put in it; naming a column the table does not have creates it. A filter it cannot resolve switches its own rule off rather than editing more rows than you meant.
core.embedMatrix?, Features?, Neighbours?, Annotations? → Embeddingruns on Run
Lay out a similarity matrix or feature table in 2D with UMAP.
UMAP in the browser: a score matrix, a table of feature vectors or a table of nearest neighbours becomes two coordinates per neuron, ready for a Scatter Plot. It preserves who is near whom, so distance between clusters means nothing, and it is stochastic — the Seed is part of the picture. Wire Neighbours from NBLAST k-NN to skip the all-by-all matrix.
net.filterNetwork, Seed? → Networkruns live
Cut out the part of a network around a selection.
Picks a set of nodes and keeps what is near them: the selection itself, everything within a number of hops, or the whole connected component it sits in. Built for reading Match Cell Types’ Network port, where the graph is thousands of nodes and the unit worth looking at is one component — that is what the matcher decides on, so a component is the answer to both “why did these correspond?” and “why did those not?”. Name the nodes with a condition on any node column, or wire a table of ids, or both; the two are unioned. Every link with both ends in the result is kept. Build Network’s degree and weight columns are recomputed against the surviving links, so a size encoding describes the picture; a column some other producer derived — the neuron counts on Match Cell Types’ label nodes — is carried through unchanged and still describes the whole graph.
core.filterTableTable → Tableruns live
Keep rows matching a condition on one column.
Keep the rows matching one condition. The operator list follows the column’s type — pick a number and you get ≥, ≤, between; pick text and you get contains and matches — which is schema propagation doing something visible. It is cheap, so the result re-computes as you type a threshold, with nothing waiting for Run.
core.groupByTable → Tableruns live
Collapse rows into groups and aggregate one or more value columns. The result carries the group columns, a row count named `n`, and one aggregate per value column renamed `<agg>_<column>` — so summing `weight` gives `sum_weight`, not `weight`.
Collapse rows into groups and aggregate — synapses per cell type, mean size per class. Pick several value columns and you get one aggregate each, sum_pre beside sum_post; the aggregation itself is one choice for all of them. The output schema is computed rather than copied, so switching sum to mean renames every aggregate and downstream pickers follow before anything re-runs. n rides along.
core.joinLeft, Right → Tableruns live
Annotate the left table with matching rows from the right table. A right-hand column colliding with a left-hand name is suffixed, `_r` by default.
Annotate the left table with matching rows from the right. Join type decides which rows survive: left keeps every left row, inner only matches, outer all rows, right every right row. Right-hand columns that collide get a suffix rather than being dropped. Chain for more tables.
core.landmarkTransformLandmarks → Transformruns live
Build a spatial transform from a table of matched landmark coordinates.
Turns a six-column table — three coordinates before, three after — into a transform that Transform Neurons and Mirror Neurons can use in place of the registrations Coda ships. Pair it with Upload Table or Table from URL to bring in your own registration, or one from navis-flybrains that this build predates.
cluster.linkageMatrix → Tree, Orderedruns on Run
Cluster a score matrix into a merge tree.
Perform hierarchical/agglomerative clustering on a distance or similarty matrix. This is the usual next step after NBLAST, and works on any square matrix over one population. Can be wired into a Dendrogram, Cut Tree, or Heatmap node to see the groups and their scores.
compare.matchTypesDataset 1, Dataset 2, Pass Through? → Labels 1, Labels 2, Report, Networkruns on Run
Work out which cell types correspond between two or more connectomes.
Builds the type-to-type correspondence needed for cross-brain comparison: which cell types in one connectome are the same cells as which in another.
neuron.mirrorNeurons, Warp? → Mirroredruns on Run
Flip skeletons, meshes or points to the other side of the brain. The attribute table gains a `mirrored` column.
Reflect neurons across the midline of the space they were fetched in, so a left neuron can be compared with a right one — by eye or by NBLAST, neither of which can see past the fact that the two are simply in different places. The space is read off the geometry, so there is nothing to configure.
neuron.nblastQuery, Target? → Scoresruns on Run
Score how alike neurons are in shape, as a matrix.
Compare neurons by shape rather than by connectivity, scoring every pair on how well one neuron’s arbor lies along the other’s. Wire one set of Skeletons for an all-by-all — the usual way in — or a second set to score one group against another. The result is a matrix, ready for a Heatmap or a clustering.
neuron.nblastKnnQuery, Target? → Matchesruns on Run
Find each neuron’s most similar neurons, as a table of matches. Columns are `queryId`, `targetId`, `rank` and `score`.
A version of NBLAST that gives you the top-k matches for each query neuron. Each row is one match — neuron, neighbour, rank and score — so Build Network turns it straight into a similarity graph. The shortlist that makes this cheap is approximate; the scores are exact. With a Target wired, a neuron in both sets matches itself at 1.00 and spends one of its k places doing so.
neuron.nblastMatchesMatrix → Matchesruns on Run
Pull each neuron’s best matches out of a score matrix, as a table. Columns are `query`, `target`, `rank` and `score`, or `query` and `matches` when counting — note that NBLAST k-NN calls the same pair `queryId` and `targetId`.
Turns a score matrix into the long table every other node wants: one row per match, with the neuron, its match, the rank and the score. Take the top N per neuron, everything above a cutoff, or just the counts so you can pick a cutoff first. Works on any matrix, not only NBLAST’s — and note that the “within %” cutoff is a band around each neuron’s own best match rather than the top few percent overall.
net.centralityNetwork → Network, Node stats, Summaryruns on Run
Betweenness, closeness, PageRank and communities for a network’s nodes. Each measure switched on adds its own column: `betweenness`, `closeness`, `pagerank`, `eigenvector`, `community`.
Adds centrality columns to a network’s nodes: betweenness and harmonic closeness from a shortest-path sweep, PageRank, eigenvector centrality and Louvain communities. Expensive by nature — the sweep walks every link once per source node — so it runs only on Run, and Sample trades an exact answer for a much faster one. The network passes through carrying the new columns.
core.normalizeMatrix → Matrixruns live
Rescale matrix values by row, column, global max, or log.
Rescale a matrix by row, by column, against the global maximum, or logarithmically. Raw synapse counts are dominated by whichever cell type happens to be numerous, so row fraction is usually what turns an unreadable connectivity matrix into a picture — each row then reads as “where does this type send its output”, which is the question being asked.
neuron.partnerVectorsConnections, Neurons?, Labels? → Vectorsruns live
Turn a connectivity edge list into one feature vector per query neuron, ready to compare.
Reshapes a Connectivity result into the long form Similarity Matrix reads: one row per neuron and partner, with upstream and downstream kept apart as separate features. It aggregates as it goes, so no Group By and no Pivot in between. Wire Labels from Match Cell Types to compare across brains.
core.pivotTable → Matrix, Tableruns live
Reshape a long table into a matrix of rows × columns, as a matrix and a wide table. The wide table's columns are the distinct values found in the Columns field, so nothing can name them until it has run.
Reshape a long table into rows × columns — the step between a connectivity result and a heatmap. Emits both shapes of the same pivot: a Matrix for heatmaps and normalization, the same thing wide as a Table for sorting, filtering, and export — they never disagree.
neuron.pointsInVolumesPoints, Volumes → Inside, Outsideruns on Run
Split a point cloud by the meshes enclosing it, adding a `roi` column naming each point’s volume — written over a same-named column rather than beside it.
Tests every point of a cloud against a set of meshes and hands back both halves — the points inside some volume, and the rest — with a column naming which volume each one landed in. It is the only route from a synapse cloud to the region a synapse is in: neuPrint, CAVE and CATMAID all publish synapse coordinates with no region attached. The volumes need not be neuropils; a set of neuron meshes on the same socket asks which synapses lie inside another cell. Where volumes overlap the first on the wire wins, and the node says how many points that decided.
core.qualifyIdsTable → Tableruns live
Tag a neuron id with the dataset it came from, or take that tag off again. A tagged id reads `dataset:id` and its column becomes text, so filters, joins and lookups downstream have to match that form.
Rewrites an id column to dataset:id, which is what lets two connectomes share one table without neuron 12345 in one being mistaken for neuron 12345 in the other — the shape co-clustering needs before Stack Tables. Strip it again on the way back out. The tagged value is deliberately no longer a valid neuron id, so anything that would query it refuses loudly instead of fetching the wrong neuron; only qualify where two datasets actually meet.
core.reduceMatrixMatrix → Tableruns live
Aggregate a matrix’s rows or columns into one table row each. The result is `label` and one column per statistic you tick — a second tick adds a column — and `Prefix` renames them all, so `zap` gives `zap_mean`.
Turns a matrix into a table with one row per matrix row, or per column, carrying the statistics you tick: mean, median, sd, min, max, sum, n. It is the way from a trace or similarity matrix to a per-neuron number you can sort, join or colour a scene by. Non-finite cells are skipped, so an all-NaN row comes out null rather than zero.
core.relabelTable, Mapping → Tableruns live
Rewrite a column through a two-column mapping table. The result takes the name in `Into`, or rewrites the column in place when that is empty; any other column already holding the name is suffixed `_2`.
Rewrite one column by looking each value up in a mapping table: pick the column to rewrite, then the mapping's key and value columns. Leave Result empty to rewrite in place, or name a column to add one beside it. Unmatched is the setting to think about — it defaults to leaving an uncovered value empty, so unmapped values cannot pass for mapped ones.
core.renameTable → Tableruns live
Give one or more columns a different name. A column that merely already held a target name is suffixed `_2` rather than overwritten.
Give one or more columns a different name, leaving their values, dtypes and units alone. Mostly for making somebody else’s table speak Coda’s vocabulary: the id column has to be called neuronId before a table can meet a Neurons socket, and the cell typing has to be called type before connectivity rows, Explore Dataset chips and Neuron Profile roll-ups can read it — which is why renaming a column onto neuronId promotes the table to Neurons, and renaming neuronId away demotes it. Nothing here refuses: a row naming a column the table does not have renames nothing and says so, and two rows aiming at one name suffix the second rather than dropping a column.
core.sampleTable → Tableruns live
Keep a subset of the rows: the top, the bottom, every Nth, or a random draw.
Cut a table down to a manageable size: the top, the bottom, every Nth row, or a random draw. The random mode takes a seed and the draw is reproducible from it, so a figure made from a sample can be remade — which is the whole reason the seed is a visible parameter rather than a hidden one. The other three modes ignore the seed entirely and cost nothing when it changes.
core.selectTable → Tableruns live
Keep only the chosen columns, in the chosen order.
Keep only the columns you name, in the order you name them. Mostly for tidying a table before export or before a chart, where forty columns of neuPrint metadata get in the way of the four that matter. An empty selection means every column, so an unconfigured node passes its input through rather than emitting nothing.
neuron.selectNeuronsGeometry, Neurons → Geometryruns live
Keep only the skeletons or meshes whose ids appear in a neuron table. Columns are untouched — the geometry arrives with the attributes it already had.
Takes a collection of skeletons or meshes and a table of neurons, and keeps the geometry whose ids the table names — so a Cut Tree cluster, an NBLAST shortlist or a Connectivity result can pick what a 3D View draws without re-fetching anything. Filtering the neuron table before the Skeletons or Meshes node is cheaper where that is still possible; this is for geometry that has no table left in front of it, or a subset chosen from something measured off the geometry itself. Ids the collection has no geometry for are counted and reported, never refused.
core.selectOneItems → Itemruns live
Step through a table, skeletons or meshes and emit one element at a time.
Step through a collection one element at a time — the manual For each. Explore Dataset → Select One → Skeletons → 3D View. Stepping is free (arrows move the card), Use this commits (re-runs downstream). Live mode couples browsing and committing.
cluster.selectedToNeuronsSelected, Neurons? → Neuronsruns live
Turn a Dendrogram selection into neurons. The selection’s columns ride along, and one whose name the neuron table already uses is suffixed `_c`.
A Dendrogram selects branch names, not neurons. This turns those names back into the clustered neurons, ready for Neuroglancer, a 3D view, or Skeletons. Wire the original neuron table and set "Match on" to what NBLAST used for "Label by"; if it was neuron id (the default), leave Neurons unwired.
core.similarityFeatures → Matrixruns on Run
Compare every observation with every other over its features, as a similarity or distance matrix.
Turns a table of features, calculates similarities or distances between them and returns it as a square similarity matrix for e.g. Linkage or Heatmap takes.
core.sortTable → Tableruns live
Order rows by a column, optionally keeping only the top N.
Order rows by a column, and optionally keep only the first N of them. Top N is what turns a sort into “the twenty strongest partners”, which is most of what a sort is used for here. Nulls sort last whichever direction you choose, so a missing value never displaces a real one at the top of the list.
neuron.splitNeuronsNeurons → Matching, Restruns live
Split skeletons or meshes in two by their attributes: the matches, and the rest.
Stack Neurons run backwards: it asks the attribute table a question and hands back both answers, so one row on the stack’s own source column takes a scene apart again. Reach for it instead of filtering twice with opposite conditions — the negation of several ANDed rows is not one condition. With no filters nothing matches.
neuron.stackInput 1, Input 2 → Neuronsruns live
Combine several sets of skeletons, meshes or points into one collection.
The geometry counterpart of Stack Tables: several collections end to end, with their attribute tables stacked alongside. This is how neurons from two or more datasets reach one 3D View — transform each into a shared space first, then stack them and colour by the source column. Every input must be the same kind, in the same units and the same space.
core.stackInput 1, Input 2 → Tableruns live
Combine two tables vertically, keeping every column either of them has.
The vertical counterpart of Join: where that one widens a table with columns, this lengthens it with rows. Every column survives — a column only one side has is null-filled for the other. But a column the two sides genuinely disagree on (number vs text) is refused by name rather than reconciled.
neuron.synapseEdgesPoints → Edgesruns live
Count a synapse point cloud into a connectivity edge list — `preId`, `postId` and a `weight` that is the number of synapses, under the same column names Connectivity emits. Needs a cloud carrying a partner column, which Synapses Between has and a plain Synapses cloud on neuPrint or CATMAID does not.
Counts a synapse cloud into an edge list: one row per connected pair, with weight the number of synapses between them. It is what turns "here is where they connect" back into "how strongly" — so a cloud narrowed by Points in Volumes gives connectivity restricted to one neuropil, which no backend answers directly. Split by takes extra columns, so splitting on the region column gives one row per pair per region in a single card. The control to read before running is Orientation: a Synapses Between cloud is already oriented, while a plain Synapses cloud says which end its neuron is in a polarity column, and counting that one without flipping merges a neuron’s inputs and outputs.
neuron.synblastQuery, Target? → Scoresruns on Run
Score how alike neurons are by where their synapses sit, as a matrix.
Compare neurons by their synapses rather than by their shape: for each connector, how far away the nearest connector of the same polarity on the other neuron is. Wire one set of Synapses for an all-by-all, or two to score one group against another. Two cells with the same arbor that talk to different partners score low here and high on NBLAST, which is the reason to run both.
neuron.xformNeurons, Transform? → Transformedruns on Run
Move skeletons, meshes or points into JRC2018U, the shared template space.
Put neurons from different brains into one coordinate system, so they can be drawn together or compared by NBLAST — neither of which works while two reconstructions sit in unrelated spaces. One landmark transform per dataset, straight into JRC2018U. Mirror before transforming, not after.
core.unpivotTable → Tableruns live
Fold wide columns into one name column and one value column. The two are named by `Name into` and `Value into` — `name` and `value` unless you say otherwise.
Fold a wide table into a long one: pick the columns to fold and each becomes rows, with the column name in one new column and the cell in another. This is the direction Pivot does not go, and it is what makes an already-pivoted CSV usable — Group By, Filter Table and every chart that colours by a category want the value in one column. The columns you do not fold are repeated on every row it produces, so leaving Keep empty keeps the rest of the table as it is. Note that it does not undo a Pivot: a pivot aggregated several rows into each cell, and unfolding gives one row back rather than the several.
cave.updateRootIdsTable, Dataset → Tableruns on Run
Repoint stale CAVE root ids at a materialization, using their supervoxel ids.
Root ids drift when proofreading touches a segment, leaving annotation tables out of sync with the materialization. This node repairs them by looking up what each stale id’s supervoxel became and rewriting only stale entries. Unedited tables cost one staleness check and no further lookups.
Draw it. Every viewer passes its input through, so it can sit anywhere in the chain.
out.viewer3dSkeletons?, Meshes?, Points?, Volumes? → Selectedruns live
Render skeletons, meshes and synapses in 3D, with data-driven colour.
Skeletons, meshes, synapse points and neuropil volumes in one 3D scene, each with its own colour encoding — so neurons can be coloured by cell type while their synapses are coloured by polarity, inside the region they innervate. Only one socket needs filling. Everything arrives in nanometres, so geometry from different queries lines up.
out.barChartTable → Tableruns live
Bar chart of one numeric column, grouped by a category and optional series.
One numeric column, grouped by a category, optionally split into a series. The ordinary end of a Group By, and the fastest way to turn “synapses per partner type” into something you can read. Every knob on it is presentational, so restyling never marks anything stale.
out.distributionTable → Table, Selectedruns live
Box plot or violin plot of a numeric column, split by an optional group.
Quartiles, whiskers and outliers for one numeric column, one box per group — and a violin over the same axis when the shape matters more than the summary, since two very different distributions can share a five-number summary. Whisker rule, log axis and how many groups to draw are all settings; clicking a box sends that group’s rows on as Selected.
out.datasetSummaryDataset →runs live
What is in a dataset: neuron counts, how they are classified, and how completely each region is traced.
High-level summary of what’s in the dataset: neuron counts, annotations, reconstruction completeness and so on. What can be shown depends on the input dataset.
out.dendrogramTree, Annotations? → Tree, Selectedruns live
Draw a merge tree, select branches of it, and name its leaves from an annotation table.
A diagram of the hierarchical relationship between objects. Typically an output from hierarchical clustering (see linkage). Wire a neuron table to Annotations to label the leaves by cell type — or by anything else the table carries — without changing the tree. Expand the card to scroll-zoom into a big one; the names come back as there is room.
out.describeTable → Table, Summaryruns live
Per-column summary of a table: how much is filled in, and the numeric spread. Its columns are `column`, `dtype`, `non_nulls`, `nulls`, `non_zero`, `unique`, `min`, `q1`, `median`, `q3`, `max` and `mean` — snake_case, unlike the rest of Coda.
Summarises a table one row per column — the dtype, how many values are present, how many are missing, how many are distinct, and for numeric columns the non-zero count, the five-number spread and the mean. The table itself passes straight through, and the summary leaves by a second port as ordinary data you can sort, filter or export. Text and boolean columns get the counts and nothing else, and so does the neuronId column: a mean neuron id identifies no neuron, and on an 18-digit id it would not even be arithmetic over the ids.
out.flowChartNetwork → Network, Selectedruns live
Draw a small network as a feed-forward circuit diagram: labelled boxes in layers, arrows weighted by connection strength.
The circuit diagram of a feed-forward pathway — boxes in columns, arrows as thick as the connection is strong, the synapse count on them. Made for the dozen nodes a shortest-path result comes back with, where the Network Viewer’s force layout has nothing to arrange. Feedback connections are drawn dashed rather than hidden.
out.heatmapMatrix, Annotations? → Matrix, Selected Rows, Selected Columnsruns live
Render a matrix as a heatmap, and name its rows and columns from an annotation table.
A matrix drawn as a grid of coloured cells — the natural end of Adjacency or Pivot. Sequential for counts and fractions, diverging when zero is a meaningful middle. Wire a neuron table to Annotations to name the axes by cell type rather than by root id. The Order tab sorts by total, name, one row or column, or clustering — and the named, filtered, sorted matrix is what the node outputs.
out.histogramTable → Table, Selectedruns live
Distribution of one numeric column, binned, optionally split into series.
One numeric column binned into bars — the fastest way to see whether a score, a synapse count or a cable length is bimodal, skewed or all one number. Bins are chosen by the Freedman–Diaconis rule unless you set a count; a log axis, a cumulative curve and percent or density scaling are all there. Click a bar to send those rows on as Selected, which is how you pull out a tail.
net.metricsNetwork → Network, Node stats, Summaryruns live
Graph statistics for a network: degree, clustering, components, density.
Graph statistics for a network. Per node: in/out degree and strength, local clustering, k-core and connected component. Per graph: density, degree spread, reciprocity, transitivity, degree assortativity and the component sizes. The network passes through carrying every per-node metric, so a viewer downstream can colour or size by them with no extra wiring.
out.networkNetwork, Layout? → Network, Selectedruns live
Node-link view of a network, with data-driven colour and size.
Draw an interactive network diagram: neurons or types as discs, connections as links, laid out by force, layers, a circle or a grouped ring. Colour and size are data-driven through the styling panel, and what you click leaves by the Selected port. Note that its three filters — minimum link weight, top N nodes, hide isolated — change what the node returns rather than only what it draws.
out.neuroglancerDataset, Neurons?, Extra layers? → Linkruns live
View neurons in the dataset's own neuroglancer scene.
View neurons in the dataset’s own published neuroglancer scene — the EM volume, the region meshes and the synapse layers that scene already carries, with your neurons added to it. Emits a URL that works both as a viewer and as a shareable link, and the card embeds it. Every setting is inspector-only, so the embed keeps the space somebody opened the node for.
out.profileDataset, Neurons → Neurons, Currentruns live
Inspect one neuron at a time: identity, partners by type, regions, transmitter and shape. Set Group by to a column and it profiles whole groups instead — one cell type per page, every number a mean with a spread across the members.
Inspect one neuron at a time: identity, partners by type in both directions, synapses by region, transmitter, and a 3D view. Set Group by to a column and it pages those groups instead — a cell type, a hemilineage, a cluster — every number a mean with its spread. Paging is free; pinning sends what you are looking at, a whole type when grouped, out of the Current port and marks the graph stale.
out.topologyDataset, Neurons → Neurons, Current, Morphometricsruns on Run
Measure one neuron’s arbour and see where its partners synapse onto it. Morphometrics is one row per neuron — `cableLength`, `nodes`, `branchPoints`, `endPoints`, `maxStrahler` and more — and splitting axon from dendrite adds `splitStatus`, `cableAxon`, `cableDendrite` and their synapse counts.
Morphometrics for the neurons you feed it — cable length, branch points, Strahler order, tortuosity — beside a 3D view of the cell, and a partner list that lights up exactly where a chosen partner synapses onto the arbour. Turning on Split axon/dendrite runs navis’s synapse flow centrality and adds per-compartment columns, which is the one control here that costs a download and marks the graph stale; everything else you can touch is free.
out.neuronbridgeDataset, Neurons → Neurons, Pinnedruns live
Page through neurons and see the light-microscopy images NeuronBridge matched to each — split-GAL4 and MCFO lines, best image per line. Pin matches to send them downstream.
Finds driver lines for EM neurons. For the neuron on screen, shows NeuronBridge’s precomputed colour-depth matches from FlyLight’s split-GAL4 and MCFO collections, one tile per line at its best image, with the rest one click away. Covers hemibrain, male CNS, MANC, FlyWire and BANC. Paging is free; ☆ pins a match to the Pinned port.
out.pieTable → Table, Selectedruns live
Pie or donut chart: shares of a whole, one slice per category.
Composition as a ring or a wheel — one slice per category, sized by a value column or by row count when none is picked. The tail past eight slices folds into one residual rather than taking a ninth colour, and clicking a slice sends its rows on as Selected. It answers “what fraction” well and “which is bigger” badly; for the latter use a Bar Chart.
out.rankTable → Table, Selectedruns live
Plot a numeric column against its rank on log axes, with the cumulative share of the total beside it — a Pareto or rank-abundance chart.
A heavy-tailed column read as an ordering: value against rank on log axes, with the running share of the total underneath. Made for influence scores, degree and centrality, where a bar chart draws a thousandfold difference as a barely visible one. The share is of the values rather than of the rows, so it answers "the top twenty carry 60%" — and it is withheld, with a reason, on a column that can go negative.
out.roisDataset →runs live
The dataset's neuropils drawn together in a named anatomical plane, coloured by how completely each is traced.
Neuropils drawn together on a fixed anatomical plane — frontal, dorsal or lateral — that can be exploded to separate overlapping regions. Various coloring options including reconstruction completeness.
out.sankeyTransfers → Table, Selectedruns live
Draw layered flow as bands whose width is the quantity — a Sankey or alluvial diagram, from a table of layer, source, target and value.
Layered flow drawn as bands whose width is the quantity: where something came from, what it passed through, and how much. Wire it to an Influence node’s Transfers port and it needs no configuration. Because the mark claims that what arrives at a node also leaves it, the caption measures how far from true that is on your data rather than assuming it — a flow of synapse counts does not conserve, and the figure says so instead of pretending.
out.scatterTable → Table, Selectedruns live
Plot two numeric columns against each other, with colour, size and shape.
Two numeric columns against each other with colour, size and shape as encoding channels — seaborn’s scatterplot, rendered to canvas for large datasets. Lasso to select points as output; log axes and linear trends available.
out.tableTable → Table, Filteredruns live
A table widget to load your data into. Allows sorting and per-column filtering.
Lets you inspect any tabular data: rows and columns, sortable, paged and exportable as CSV. Like every viewer here it passes its input straight through, so it can be dropped into the middle of a chain without breaking anything downstream. Sorting is view-only and costs no run; the per-column filters under the headers are not, and what they keep leaves by the second port.
Outside the pipeline: bring your own table, write a file, leave a note on the canvas.
flow.collectResult → Collectedruns live
Stack what each pass of a For Each produced into one value.
The exit of a For Each loop: it folds each pass’s result onto the last, so a loop that fetches one neuron at a time hands on the whole collection. Everything wired after it runs once, on the finished total, which is what makes it the boundary of the loop. Tables stack like Stack Tables and geometry like Stack Neurons, so passes that carry different columns fill with null rather than losing them.
out.copyIdsNeurons → Neuronsruns live
Copy the incoming neuron ids to the clipboard, ready to paste elsewhere.
Puts the ids of whatever neurons are wired to it on the clipboard, in the shape the thing you are pasting into wants — one per line for a list, comma-separated and quoted for a Python or R literal. It is a tap, so it passes the neurons on unchanged and can sit mid-chain; the button is the only trigger, because a browser refuses a clipboard write that no one clicked for.
out.downloadValue → Valueruns on Run
Write the incoming value to a file, on every run or on demand.
Save whatever is connected to a file — CSV for tables, SWC for skeletons, OBJ for meshes, SVG or PNG for an upstream chart.
flow.forEachItems → Itemruns on Run
Run everything downstream once per element, or once per group.
Runs everything wired after it once per element — a row, a skeleton, a mesh, or every element sharing a value of a column. Pair it with Download to write a file per neuron, or with Collect to stack the results into one value. Only one element is ever in memory, which is what makes a set too large to load still possible to save. Start it with the card’s Run loop button, not Run.
core.tableFromUrl→ Tableruns on Run
Fetch a CSV from a URL and read it as a table. A chosen id column is renamed `neuronId` and a chosen type column `type`.
Fetch a CSV from a URL — the reproducible counterpart to Upload Table. A colleague opening your .coda.json re-fetches and gets the same data. Trade-off: will not work on disk-only files, behind logins, or on hosts that send no CORS headers. Bump Refresh to re-fetch when the remote file changes.
note.textruns live
A block of text on the canvas — what a graph is for, in words. Markdown.
A block of markdown on the canvas: what a graph is for, why this threshold, what the chart at the end is meant to show. It is not part of the pipeline — no sockets, never evaluated, never counted as stale — which is exactly what makes it safe to leave anywhere. Double-click to edit, Escape to abandon the edit; drag it anywhere in read mode.
core.uploadMesh→ Volumesruns live
Bring in your own region meshes — OBJ, STL or PLY — as Volumes the 3D View can draw.
Your own neuropil shells: OBJ, STL or PLY, one mesh per file and named after it. The output is the same Volumes ROI Meshes produces, so everything downstream takes it unchanged. Set Units to whatever the file is in. Meshes live in this browser rather than in the graph, so a workflow sent to a colleague arrives without them.
core.uploadTable→ Tableruns live
Bring in a CSV of your own — annotations, cell types, an embedding. A chosen id column is renamed `neuronId` and a chosen type column `type`.
Your own CSV: annotations, cell types, embeddings. The only node with no inputs and no backend. Rows live in this browser, not in the graph — a .coda.json sent to a colleague arrives without them. The card shows which file is missing if you need to pick it again.