Hello again. In the previous lesson, you learned to treat a proposed edit as an evidence claim: trace the relevant process through adjacent EM sections, then use the 3D reconstruction to test whether the proposed connection fits the neuron’s overall morphology.
Now you will carry out the safer of the two core proofreading operations: repairing a well-supported false split. In FlyWire terms, this is a merge. You will connect two currently disconnected segmented objects only after establishing that they are parts of the same biological neurite.
The goal is not to “make the mesh look continuous.” It is to make one bounded, evidence-backed change, then confirm that FlyWire recorded the intended connection.
What a false-split repair actually changes
A false split occurs when automated segmentation assigns one biological neuron to two separate current segments. In the 2D EM imagery, the neurite is continuous; in the segmentation, it stops and restarts as two different objects.

The word add can be slightly misleading. You are not drawing new pixels, filling a gap manually, or changing the underlying EM data. You are instructing FlyWire to join the selected pieces of its segmentation. At the implementation level, the merge changes how existing supervoxels are grouped into a current reconstructed object.
That has two practical implications:
- The click location matters. Each click identifies existing segmented material. A click on a nearby but different neurite can introduce a false merge.
- Root identifiers can change. Do not assume that the pre-edit root ID of your “main” neuron remains the ID you will use afterward. Re-resolve and record the resulting object after the edit.
A merge is appropriate only when your earlier verification supports this statement:
The disconnected candidate is a continuation of the target neurite, not merely a nearby structure.
Typical clues that lead you to investigate a false split include:
- a branch ends abruptly in the 3D reconstruction;
- a thin process seems to disappear, then a compatible fragment appears nearby;
- a large dendritic arbor has a suspicious empty gap;
- in 2D, one membrane-enclosed process continues across slices while its segmentation color or object membership changes.
A gap is a reason to inspect, not a reason to merge. Dense neuropil provides many nearby fragments that can look tempting but belong to other cells.
Set up a bounded, reversible-minded work area
Before pressing any edit shortcut, make the candidate case easy to revisit and hard to confuse with neighboring structures.
Record a minimal pre-edit note:
| Field | What to record |
|---|---|
| Location | Dataset coordinates and, where available, a share link |
| Target | The root or visible branch you consider the trusted main neuron |
| Candidate | The disconnected segment you intend to attach |
| Claim | “False split: these two objects are one continuous neurite” |
| 2D evidence | The membrane and interior continuity observed across adjacent sections |
| 3D evidence | Why the joined morphology makes sense globally |
| Expected result | A single continuous branch, with no other nearby segment affected |
Then prepare the visual context:
- Return to the precise junction or gap you inspected.
- Keep the EM imagery visible enough to see boundaries, not just colored overlays.
- Make the segmentation overlay transparent enough that it does not hide a membrane.
- In 3D, reduce distracting neighboring objects where practical.
- Identify a trusted point on the existing target branch and a trusted point inside the intended candidate fragment.
Avoid placing either point directly on an ambiguous boundary. If you cannot confidently say which segmented object lies under the cursor, pause and inspect more slices.
Safety rule: a merge should confirm an already supported biological interpretation. Do not use a sequence of trial merges to discover which fragment “looks right” after the fact.
Use FlyWire’s merge operation
The original FlyWire 101 guide describes the core interaction: enter merge mode with M, click the unfinished branch, then click the nearby disconnected segment to fuse it. Interface labels and post-edit rendering can evolve, so use the mode confirmation shown by your current FlyWire interface rather than clicking speculatively if a shortcut does not behave as expected.
Read the “Merging and Splitting” section of FlyWire 101 on the FlyWire blog for the platform’s basic merge interaction and its stated post-edit behavior.
In the “Merging” subsection, read from the paragraph beginning “Let’s start with merging” through the paragraph immediately before “Splitting.” Focus on the order of the two selections: first the unfinished target branch, then the segment to fuse. The guide also describes what may appear after a merge; treat this as a reminder to reload and inspect the actual result, not as evidence that the biological decision was correct.
The controlled merge sequence
Use the following sequence on an authorized proofreading task or practice environment.
-
Return to your verified location.
Confirm again that the two visible objects are disconnected in the current segmentation and that the EM evidence supports continuity. -
Choose the first point on the target neuron.
Pick a point well inside the trusted existing branch, preferably near the broken endpoint but not at an unclear interface. -
Enter merge mode.
Press M while the FlyWire viewer has keyboard focus. Confirm that the interface indicates merge mode before making a selection. -
Click the target branch.
This selects segmented material belonging to the neuron you are extending. -
Click the candidate segment.
Select a point clearly within the intended disconnected continuation. The candidate should be the specific fragment you verified through the EM stack, not simply the nearest visible object in 3D. -
Wait for FlyWire to process the operation.
The older FlyWire 101 workflow notes that a dark or black region can appear after an edit and recommends refreshing. If your current interface signals completion differently, follow its displayed status. Do not repeatedly click or issue a second merge while the first request is unresolved. -
Refresh or reload if required, then recover the edited view.
Navigate back using your saved coordinates or link. Verify that the two formerly separate pieces now resolve as one reconstructed object.
The operation is small in interface terms—two deliberate selections—but broad in consequence: it changes the reconstruction available to later viewers and analyses.

In the proofreading figure, red and green are a visualization convention for the edit comparison. They are not biological labels and should never substitute for checking the EM volume.
Immediate validation: did the intended merge occur?
A successful tool response does not finish the task. You now need to distinguish three separate questions:
- Did FlyWire execute a merge?
- Did it merge the intended two components?
- Does the resulting reconstruction still agree with the biological evidence?
Begin locally in 2D. At the original gap, inspect a short sequence of sections on both sides. The overlay should now assign the two portions to the same reconstructed object, while the underlying EM imagery should still show the same membrane-consistent continuation that justified the edit.
Then look in 3D at two scales:
- Local scale: Is the new connection located where you intended? Is there an unexpected bridge into a neighbor?
- Whole-arbor scale: Does the formerly missing fragment now extend the target’s trajectory plausibly? Has the reconstruction gained an implausibly large or differently oriented appendage?
You are not yet doing a full audit of every downstream morphological consequence; that comes later in the module. At this stage, make sure the merge is visible, bounded, and biologically consistent at the original evidence site.
Three outcomes after the edit
| Outcome | Interpretation | Immediate response |
|---|---|---|
| Expected merge | The correct target and candidate now belong to one object, and the local EM evidence still supports continuity. | Record the resulting root and mark the case as merged. |
| Unexpected scope | More material changed than expected, or the wrong neighboring segment appears attached. | Stop editing. Record what occurred and move to recovery rather than attempting compensating clicks. |
| No visible change or unclear state | The operation may not have completed, the display may be stale, or the selected material was not what you thought. | Refresh, return to the saved location, and inspect object membership before doing anything else. |
The critical discipline in the middle row is to avoid “fixing the fix” immediately. A series of unverified compensating edits becomes difficult to reason about. First establish the actual state, then use the recovery workflow covered later in this module if necessary.
A practical one-case workflow
For your first real merge, keep the scope deliberately small: one target neuron, one candidate fragment, one documented decision.
Before the merge
- Confirm the case is a false split rather than a false merge.
- Trace from trusted target material into the candidate through adjacent EM sections.
- Inspect the expected connection in 3D.
- Save coordinates or a share link.
- Note the two current object identifiers if they are visible.
- State what you expect to become continuous.
During the merge
- Enter merge mode deliberately.
- Select only one trusted point in the target and one in the candidate.
- Wait for completion; do not stack operations.
After the merge
- Reload if necessary.
- Return to the exact site.
- Verify local overlay membership and EM continuity.
- Check the resulting branch in 3D.
- Record the post-edit root identifier or other current object reference.
- Write a one-line result, such as:
“Merged target branch with disconnected continuation at recorded location; inspected across adjacent sections and in 3D; resulting branch follows expected trajectory.”
This workflow resembles a small production change: a defined precondition, one bounded action, and a post-deployment check against the original acceptance criteria. That mindset is especially useful when a visually simple edit changes a shared, versioned reconstruction.
When not to merge
Do not proceed when the candidate is merely plausible. Leave the case unchanged or seek review if any of the following applies:
- the apparent continuation disappears in damaged, missing, or misaligned imagery;
- a membrane may separate the target and candidate at the supposed junction;
- several fragments are equally plausible candidates;
- the candidate’s caliber or trajectory changes in a way you cannot explain;
- the 3D connection would create a long detour or attach to a clearly unrelated arbor;
- you cannot identify the exact segmented material that your click would select.
Thin neurites can be especially difficult because they may be pinched between larger structures or almost invisible in the EM imagery. That difficulty does not lower the evidence threshold. A well-documented unresolved gap is preferable to an attractive but unsupported merge.
Key takeaways
- Repairing a false split means performing a merge between two disconnected existing segmentation components.
- A merge adds no new image data; it changes the grouping of existing supervoxels, so the selected points and the resulting root identity matter.
- Use M mode only after adjacent-section EM evidence and 3D morphology support one specific target–candidate connection.
- Select points well inside known target and candidate material, not on ambiguous interfaces.
- After processing, reload if needed and verify the result in both 2D EM and 3D.
- If the result is unexpected, stop rather than making immediate compensating edits.
Next, you will handle the complementary operation: removing an incorrectly attached segment to repair a well-supported false merge.
Can't find a good explanation? Sign up and we'll make it for you
Sign up