This post does that three ways on one photo: potrace one color at a time, VTracer with its paths regrouped by color, and imagetracerjs in Node. Every number comes from running the scripts below. At the end I cover what color layers can't do, and why splitting by color is not the same as splitting by element (text, subject, background).

Setup: VTracer, potrace and imagetracerjs versions

Versions used, all on macOS:

• VTracer 0.6.15 from PyPI (the current stable pip install vtracer), plus 1.0.0a4 in a second virtualenv
• potrace 1.16 (brew install potrace)
• imagetracerjs 1.2.6 and pngjs (npm i imagetracerjs pngjs)
• Pillow 13.0.0, NumPy 2.5.4, Python 3.13, and rsvg-convert from librsvg 2.63.2 to render SVGs back to pixels for checking

The image is a CC0 photo of a hot air balloon over water by Bessi on Pixabay, downscaled from 1920×1307 to 960×654. It's a hard case on purpose. Most of the frame is a smooth blue gradient, the balloon's red covers well under 1% of the pixels, and the water reflects that red.

What does VTracer output by default?

VTracer is an open source raster-to-vector converter from visioncortex, written in Rust, with bindings for Python and Node. The source is on GitHub, the Python package is on PyPI, and a web demo lets you try settings before writing code. Its default color mode traces the image as stacked color clusters:

import vtracer
vtracer.convert_image_to_svg_py('balloon.png', 'vtracer-default.svg', colormode='color')

That ran in 0.08 s and wrote 551,045 bytes. The file is a flat list of paths, each with its own fill:

<!-- Generator: visioncortex VTracer 0.6.12 -->
<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="960" height="654">
<path d="M0 0 C316.8 0 633.6 0 960 0 ..." fill="#2D394C" transform="translate(0,0)"/>
...

(The comment says 0.6.12 even though pip installed 0.6.15.) The other two tools are no different. With numberofcolors: 8, imagetracerjs wrote 2,463 paths and no groups, though it can tag each path with its color layer (more on that below). potrace only handles one color per run. Its output is a single <g fill="#000000"> holding the black pixels of a black-and-white bitmap.

So the layer structure comes from a step you add yourself: pick a fixed palette, then put every path of a given palette color into one group.

Why quantize first, and what can the palette lose?

Bitmap, 8-color quantized bitmap, and the potrace-traced SVG with one <g> per color. Photo: Bessi (Pixabay), CC0, via Wikimedia Commons.

A layer per color only works if the number of colors is small and fixed, so the first step is color quantization: reducing the image to K colors. The quantizer decides what your layers will be, and on this photo the common choices dropped the balloon's red.

I asked Pillow for 8 colors with each method and dithering off. MEDIANCUT and FASTOCTREE spent all eight on shades of blue. The red went into the nearest blue bucket, so in those palettes the balloon has no layer of its own. MAXCOVERAGE with kmeans=3 kept two reds (#76273E and #C45B6E) next to six blues. Without the k-means pass, MAXCOVERAGE picked a mix that included pure black, near-white, teal and brown.

The 8-color palettes Pillow picks for this photo. Only MAXCOVERAGE keeps any red.

The lesson: print the palette before you trace. If a color you care about covers a small share of the image, a quantizer that weights by pixel count will merge it away. imagetracerjs's built-in quantizer had the same blind spot: its 8 colors were all blues.

Route 1: potrace, one color at a time

Potrace by Peter Selinger traces a two-color bitmap into smooth curves. It reads PBM, PGM, PPM and BMP. To get a colored, layered SVG, you run it once per palette color on a mask of that color, then wrap each result in a <g>:

# trace_layers.py, core loop (the full script adds argparse and writes the <svg> wrapper)
q = img.quantize(colors=8, method=Image.Quantize.MAXCOVERAGE,
                 dither=Image.Dither.NONE, kmeans=3)
idx, pal = np.array(q), q.getpalette()
order = [i for _, i in sorted(q.getcolors(), reverse=True)]   # biggest color at the bottom

def potrace(mask):
    with tempfile.TemporaryDirectory() as tmp:
        pbm = Path(tmp) / 'mask.pbm'
        Image.fromarray(~mask).convert('1').save(pbm)          # potrace traces BLACK pixels
        svg = subprocess.run(['potrace', '--svg', '--flat', '--turdsize', '4',
                              str(pbm), '-o', '-'], capture_output=True, text=True).stdout
    transform = re.search(r'<g transform="([^"]+)"', svg).group(1)
    d = ' '.join(re.findall(r'<path d="([^"]+)"', svg))
    return transform, d

layers = []
for pos, i in enumerate(order):
    color = '#%02X%02X%02X' % tuple(pal[3*i:3*i+3])
    mask = idx == i
    if not cutout:                                   # stacked: extend under the layers above
        mask = mask | np.isin(idx, order[pos + 1:])
    transform, d = potrace(mask)
    layers.append(f'<g id="layer-{pos}" fill="{color}">'
                  f'<path transform="{transform}" d="{d}"/></g>')

Two details cost me a run each. The mask has to be inverted (~mask), because in Pillow's 1-bit mode True is white and potrace traces black. And --flat merges each color into one path, so the group is easy to address and the file stays small.

Result: 8 groups, 104,445 bytes, 0.05 s for all eight potrace calls.

Each <g> rendered on its own (cutout version). The two red layers also hold the reflection. Photo: Bessi (Pixabay), CC0, via Wikimedia Commons.

Stacked or cutout

The if not cutout line is a choice you'll meet in every tracer. Cutout traces only the pixels of each color, so the shapes tile the canvas without overlapping. Stacked grows each layer underneath the layers above it, so the shapes overlap. I measured both against the 8-color bitmap, counting pixels that differ by more than 16 levels in any channel once the SVG is rendered on white:

• stacked: 2.36% of pixels off, 104,445 bytes
• cutout: 5.24% off, 179,518 bytes

Cutout is worse because neighboring shapes don't share an edge exactly, and the anti-aliased seams between them show the background through. The two modes also behave differently when you hide a layer, which matters later.

Route 2: VTracer in Python, then regroup by color

VTracer handles color itself, so the obvious plan is to feed it the 8-color bitmap and group its paths by fill. With 0.6.15 that breaks in two places.

First, the fills are not the palette. On the pre-quantized image, VTracer still produced 136 distinct fills across 231 paths, because each cluster's color is an average (#1E283A next to palette entry #1F293B). You have to snap each fill to the nearest palette color:

paths = re.findall(r'<path d="([^"]+)" fill="#([0-9A-F]{6})" transform="([^"]+)"/>', raw)

def nearest(hexcolor):
    rgb = tuple(int(hexcolor[k:k+2], 16) for k in (0, 2, 4))
    return min(range(K), key=lambda i: sum((a - b) ** 2 for a, b in zip(rgb, pal[i])))

layers = {}
for d, fill, transform in paths:
    layers.setdefault(nearest(fill), []).append(f'<path d="{d}" transform="{transform}"/>')

Second, grouping changes paint order. A stacked SVG depends on later paths covering earlier ones. Move every path of one color into one group and some small shapes end up underneath a big one they used to sit on top of. I rendered the snapped file in its original order and again after grouping:

• hierarchical='stacked': grouping changed 6.64% of pixels
• hierarchical='cutout': 0.86%

So with VTracer, trace in cutout mode if you plan to regroup. My settings were mode='spline', filter_speckle=4, color_precision=8, layer_difference=16. The grouped cutout file came out at 509,596 bytes, 137 paths, 4.03% off.

VTracer 1.0 alpha: fixed palettes

The GitHub README documents a 1.0 engine (1.0.0-alpha.4, released 2026-08-29) with --palette, --max-colors and a seam-free --hierarchical cutout. On PyPI it is a pre-release, so you have to ask for it: pip install vtracer==1.0.0a4.

cfg = vtracer.Config(hierarchical='cutout', mode='spline', filter_speckle=4)
cfg.palette = ['#0D121D', '#1F293B', '#34445B', '#4E637D',
               '#6F87A0', '#9DB5C9', '#76273E', '#C45B6E']
cfg.convert_file('balloon-q8.png', 'v1.svg')

Every fill came back as an exact palette color, so grouping by fill needs no snapping, and regrouping the cutout output changed only 0.06% of pixels. The catch is the input. On the original photo the sky gradient came out as one flat color, and the result was 79.20% off. On the pre-quantized bitmap it was 3.84% off (195 paths, 225,630 bytes after grouping). Quantize first here too. Letting the 1.0 engine choose instead (cfg.max_colors = 8) also kept two reds, #75223A and #AF5066, in 200 paths and 119,007 bytes, but then the palette is VTracer's, not one you fixed in advance.

Route 3: imagetracerjs in Node

imagetracerjs by András Jankovics is a plain JavaScript tracer, so it runs in Node or the browser with no native code. It's the one tool here that already thinks in color layers: its trace data is layers[colorIndex][pathIndex], and desc: true writes desc="l 0 p 0" on every path. Grouping is a loop:

const traced = ImageTracer.imagedataToTracedata(imgd, { pal, colorquantcycles: 1, pathomit: 8,
                                                        ltres: 1, qtres: 1, strokewidth: 0 });
const groups = traced.layers.map((layer, i) => {
  const paths = layer.map((_, p) => ImageTracer.svgpathstring(traced, i, p, options)
    .replace(/ (fill|stroke|stroke-width|opacity)="[^"]*"/g, ''));
  return `<g id="layer-${i}" fill="${hex(traced.palette[i])}">${paths.join('')}</g>`;
});

Passing the 8 palette colors as pal with one quantize cycle keeps the reds. The output was 2,434 paths in 325,916 bytes, 9.05% off: it's cutout-style, and the seams show.

Results side by side

All runs used the same 8-color palette and the same 960×654 input. "Off" means the share of pixels differing by more than 16 levels from the quantized bitmap, rendered with rsvg-convert on white.

For a layered SVG of a photo-like image, the potrace loop gave the smallest file and the closest match. VTracer is built to trace full-color images in one pass. The layer structure is the part you add, and that is where the extra steps come from.

How do you recolor or hide a layer in an SVG?

Once each color is a <g> and the paths inside carry no fill of their own, editing a layer is one attribute. fill is an inherited property in SVG (W3C SVG 2, Painting), so the children take the group's color. And display: none on a container removes it and all its descendants from rendering (SVG 2, Rendering).

In a page, that's CSS:

#layer-6, #layer-7 { fill: #E8A33D; }   /* recolor the reds */
#layer-5 { display: none; }             /* hide a layer */

In a build script, ElementTree does it without touching path data:

import xml.etree.ElementTree as ET
ET.register_namespace('', 'http://www.w3.org/2000/svg')

tree = ET.parse('balloon-layers.svg')
by_id = {el.get('id'): el for el in tree.iter() if el.get('id')}
by_id['layer-6'].set('fill', '#E8A33D')
by_id['layer-7'].set('display', 'none')
tree.write('edited.svg')

Recoloring and hiding <g> layers with ElementTree. Photo: Bessi (Pixabay), CC0, via Wikimedia Commons.

Hiding acts differently in the two modes. In the stacked file, hiding the red layers shows whatever is underneath, here the pale blue of layer 5, so the balloon looks repainted. In the cutout file it leaves holes. Pick the mode for the edit you expect to make.

Why aren't color layers the same as element layers?

Look at the red layers again. Of the 2,473 red pixels, 629 sit in connected regions centered below the horizon at y = 440: that's the reflection. Recolor layers 6 and 7 and the reflection turns gold along with the balloon. A color layer holds every pixel of one color, wherever it sits, and the balloon's blue panels sit in the same layers as the sky.

You can add a crude region rule. trace_layers.py --split-y 440 splits every color group into layer-N-above and layer-N-below, and recoloring only the -above groups changes the balloon but not the water. Watch the edge: without a one-row overlap between the halves, 499 pixels along the split line came out more than 16 levels off. With the overlap, 47 did. A horizontal line works here only because the scene has a horizon. Inkscape's Trace Bitmap works the same way: Multiple scans creates a separate object for each color scan (Inkscape Beginners' Guide).

Splitting by element is a different job: the balloon on one layer, the sky on another, any text on a third, each with all of its own colors. That needs segmentation, not quantization. If that's what you need, use an image to layers converter that separates objects instead of colors, then trace or edit each layer on its own.

One option is IntoLayers, which I work on. IntoLayers is an AI image-to-layers converter that splits a flattened PNG or JPEG into a rebuilt background plus a separate transparent layer for each element — text, subjects and graphics — and exports them as a layered PSD, transparent PNGs or a layered SVG. Things to know before you use it in a pipeline:

• Input is one PNG or JPEG per run, up to 10 MB.
• Besides the layered PSD and transparent PNGs, it can export a layered SVG traced in the browser.
• Text comes back as an image layer, not live editable type.
• Whatever sat behind another element is a guess, not a recovery. Whether it gets drawn depends on the image.
• Your first conversion (1K, 2 layers) runs without an account and can be downloaded.

FAQ

Potrace vs VTracer: which one for layered SVGs? Potrace, if you control quantization and want small files. You run it once per color and the <g> structure is yours from the start. VTracer handles color on its own and keeps more detail, but its paths arrive ungrouped, so plan on a regroup step and cutout mode.

Which VTracer version does pip install vtracer give you? 0.6.15 as of 2026-10-25, with the convert_image_to_svg_py() API. The 1.0 engine with Config and palette is pip install vtracer==1.0.0a4, an alpha.

Why is my SVG bigger than the PNG? Photos are full of small shapes. The 8-color PNG here is 33,820 bytes. The best layered SVG is 104,445. SVG wins on flat artwork, logos and icons, not on gradients.

What do VTracer's main settings do? Going by the option list in the README: filter_speckle discards patches smaller than that many pixels, color_precision is the number of significant bits kept per RGB channel, and layer_difference (--gradient-step on the 1.0 CLI) is the color difference between gradient layers. The 0.6.15 defaults are 4, 6 and 16. mode picks the curve fit (spline, polygon or none), and hierarchical picks stacked or cutout, which decides whether you can regroup paths without changing the picture.

Is there a VTracer web app or npm package? Yes. visioncortex hosts a web demo that runs in the browser, and the 1.0 README lists a Node package, @visioncortex/vtracer, built to WebAssembly with no native dependency. The Node route above uses imagetracerjs instead, because its trace data is already split by color layer.

Can I hide a layer without leaving a hole? Yes, in stacked mode: each layer extends under the ones above it, so hiding one shows the next color down. In cutout mode the hidden area becomes transparent.

Can I get the text in an image as editable SVG text? Not from any of these tools. Tracers output shapes, so text becomes outlines. Retyping it as a <text> element is a separate step.

Disclosure: I work on IntoLayers.

A CONSORT flow diagram is the figure in a randomized trial report that tracks every participant from eligibility screening to the final analysis. CONSORT stands for Consolidated Standards of Reporting Trials.

This guide walks through one real, published trial from start to finish. Yüceer and colleagues randomized 86 informal caregivers of people living with dementia to a mobile app plus usual care, or to usual care alone, for 8 weeks (BMC Geriatrics, 2026, CC BY 4.0). Every number below comes from their published diagram or their methods section.

Step 1: Download the CONSORT 2025 template, not an old paper's figure

Use the official CONSORT 2025 flow diagram as your starting layout. The CONSORT 2025 statement says it supersedes CONSORT 2010, "which should no longer be used". It appeared simultaneously in five journals, including The BMJ, JAMA and The Lancet, and the SPIRIT-CONSORT Group site offers the diagram as an editable Word file.

Copying the figure from a paper you admire often means copying 2010 wording. In the example, the authors label their figure "CONSORT 2025 flow diagram" and keep the four stage labels, though they adapt some box wording, as Steps 5 and 6 show.

Check: your Follow-up box should say "Lost to follow-up for primary outcome", and your Analysis box "Analysed for primary outcome". If it says only "Lost to follow-up" and "Analysed", you are on the 2010 layout.

The CONSORT 2025 flow diagram template. Source: Hopewell et al., PLOS Medicine 2025, Fig 1, CC BY 4.0.

What changed from the 2010 template

Putting the two official diagrams and checklists side by side (PLOS Medicine versions of both statements) shows these differences:

The diagram changes are small but point one way: every count after randomization is now tied to the primary outcome. The checklist changed more, with seven items added, three revised and one deleted.

The superseded CONSORT 2010 template, for comparison. Source: Schulz, Altman and Moher, PLoS Medicine 2010, Figure 1, CC BY.

Step 2: Pull every count from your trial records before you draw

List the numbers first, then draw the CONSORT flow diagram. Each group needs seven counts: allocated, received, did not receive, discontinued, lost to follow-up for the primary outcome, analyzed, and excluded from analysis, with reasons where the box asks. Enrollment adds three shared counts: assessed, excluded (by reason) and randomized.

Checklist item 22a asks, for each group, for the numbers "randomly assigned, received intended intervention, and were analysed for the primary outcome". Item 22b asks for "losses and exclusions after randomisation, together with reasons". The diagram is where most reports answer both.

Check: every number on your list should point to a source, such as a screening log, a randomization export or a data lock. A number you worked out by subtraction is a guess until it matches a record. Figure 3 shows the example's published diagram.

The running example: participant flow in the dementia-caregiver app trial. Source: Yüceer et al., BMC Geriatrics 2026, Fig 1, CC BY 4.0.

Step 3: Fill the Enrollment stage

Enrollment has three boxes: Assessed for eligibility, Excluded (with sub-counts for "Not meeting inclusion criteria", "Declined to participate" and "Other reasons"), and Randomised. Anyone removed before randomization goes here and nowhere else.

This stage shows how selective the sample was. In the example, 112 caregivers were assessed and 26 excluded: 12 did not meet the inclusion criteria and 14 declined. That leaves 86 randomized.

Check: 112 − 26 = 86, and 12 + 14 = 26. Leave out a reason category you do not use (as this paper does with "Other reasons"), or write n = 0. Do not leave a box blank without explanation.

Step 4: Fill the Allocation stage for each group

Add one column per group under the Randomised box. In each column, write how many were allocated, how many received the allocated intervention, and how many did not, with reasons.

A participant who never started the intervention still belongs to the group they were randomized to; moving them breaks the comparison randomization created. In the example, the authors used stratified block randomization in a 1:1 ratio. Both groups got 43, and all 43 in each group received their allocated condition (n = 0 did not).

Check: the allocated counts sum to the randomized total (43 + 43 = 86), and within each column, received plus not received equals allocated.

Step 5: Fill the Follow-up stage, keeping two losses apart

The 2025 template has two separate lines here. "Discontinued intervention" counts people who stopped the intervention. The second line, "Lost to follow-up for primary outcome", is for anyone with no primary outcome measurement at all. Give reasons for both.

These are different events. Someone who stopped the app but completed the 8-week assessment has a primary outcome and can be analyzed. Merge the lines and readers cannot tell how much outcome data is missing.

In the example, the published figure uses a single box per group. In the app group, 6 "did not complete the 8-week intervention/follow-up": 2 hospitalization, 1 death, and 3 who did not meet the prespecified minimum weekly app-use criterion. The methods say those 3 were discontinued from the intervention under the protocol. In the usual-care group, 5 did not complete follow-up: 1 hospitalization, 1 death, 3 lost contact. The paper does not split the other reasons between the two 2025 lines, so we will not guess. In your own figure, record each person on the right line from the start.

Check: reasons add up to the box total (2 + 1 + 3 = 6; 1 + 1 + 3 = 5). If the same person appears on both lines, add a footnote with that count, or the column will look one person short.

Step 6: Fill the Analysis stage and say who was analyzed

Write how many were analyzed for the primary outcome in each group, and how many were excluded from analysis, with reasons. Then make sure your methods section defines that population. Item 21b of the 2025 checklist asks for a "definition of who is included in each analysis".

"Intention-to-treat" means analyzing everyone in the group they were randomized to. If your Analysed box is smaller than your Allocated box and missing data were not imputed, avoid that label.

In the example, the authors state that efficacy analyses used a "per-protocol complete-case population": people who completed the post-intervention assessment and, in the app group, met the minimum weekly use criterion. The figure shows 37 analyzed (6 not included) and 38 analyzed (5 not included). So the figure and the methods agree.

Check: analyzed plus excluded from analysis equals allocated in each column: 37 + 6 = 43 and 38 + 5 = 43.

Step 7: Run a balance check on every column

Before you export your CONSORT flow diagram, redo every sum from the top down. The groups do not need equal totals (37 vs 38 is fine). Each column only has to reconcile with itself.

Every sum in the example diagram, column by column. Illustration made with HTML for this guide; counts from Fig 3.

If your counts already live in a spreadsheet or a script, a few lines will do the arithmetic every time a number changes:

def check_column(c):
    assert c["received"] + c["not_received"] == c["allocated"]
    assert c["analyzed"] + c["excluded_from_analysis"] == c["allocated"]
    assert sum(c["loss_reasons"]) == c["did_not_complete"]

app = dict(allocated=43, received=43, not_received=0, did_not_complete=6,
           loss_reasons=[2, 1, 3], analyzed=37, excluded_from_analysis=6)
usual = dict(allocated=43, received=43, not_received=0, did_not_complete=5,
             loss_reasons=[1, 1, 3], analyzed=38, excluded_from_analysis=5)

assert 112 - 26 == 86 == app["allocated"] + usual["allocated"]
for col in (app, usual):
    check_column(col)
print("every column balances")

Check: then compare outside the figure. The n in each column of your baseline table and of your primary outcome table should equal the Allocated and Analysed boxes; explain any gap in a footnote.

Step 8: Pick a way to draw your CONSORT flow diagram

Once the numbers balance, drawing is the easy part. Three common routes:

• Edit the official Word template. Type your counts into the official .docx. Free, exact standard wording; a third group means moving boxes by hand.
• Generate it from code. The consort package on CRAN (R) or matplotlib (Python). Suits trials whose counts keep changing during data cleaning: rerun instead of redraw.
• Describe it in text. Vizcept, an academic figure tool, reads a participant-flow paragraph and typesets the CONSORT 2025 template with code: 2 to 5 groups, several follow-up visits, and 2010 wording if your journal still asks for it. Each number on the figure comes from your text, and a count you did not give stays blank instead of being guessed. You can try the first figure free, as a watermarked 2K PNG. Plans start at $14.90/month, and credit packs at $19.90 never auto-renew. The catch: a text model decides which box each number goes in, so check the boxes against your log. Crossover, cluster and non-randomized designs, and trials with more than five groups, are drawn by an image model instead, so check those even more carefully.

The example trial's participant flow typed into a text-to-figure tool, before generating. Screenshot, October 2026.

Common CONSORT flow diagram mistakes to fix before you submit

• A column that does not add up, which makes every other number look doubtful.
• Losses without reasons. A bare n = 5 leaves item 22b unanswered.
• Discontinued participants counted as lost (Step 5).
• "Intention-to-treat" next to an Analysed box smaller than the Allocated box, with no imputation explained.
• Group sizes that differ between the abstract, the results tables and the figure.
• A non-standard design forced into the two-group layout. CONSORT 2025 "provides guidance for reporting all randomised trials but focuses on" the two-group parallel design. With three or more groups, add one column per group under Randomised; the Allocated boxes still sum to the randomized total. Cluster, crossover and multi-arm trials also have their own CONSORT extensions.

FAQ

What is a CONSORT flow diagram?

A CONSORT flow diagram is the figure that shows how many participants in a randomized trial were assessed, excluded, randomized, allocated, followed up and analyzed in each group. It answers item 22 of the 30-item CONSORT 2025 checklist, which asks for these counts per group and for losses and exclusions after randomization with reasons.

How do I make a CONSORT flow diagram in Word or PowerPoint?

Download the CONSORT 2025 flow diagram as a Word file from the SPIRIT-CONSORT Group website and replace each blank (n = ) with your count and reasons. For PowerPoint, copy the boxes onto a slide or rebuild them with rectangles and elbow connectors, keeping the 2025 wording. Run the Step 7 balance check first, then export to PDF or a high-resolution image if your journal asks for one.

Is a CONSORT diagram only for RCTs?

Yes, CONSORT is written for randomized trials. Observational studies are reported with a different guideline, STROBE (Strengthening the Reporting of Observational Studies in Epidemiology). For trial designs other than two parallel groups, use the matching CONSORT extension, such as the ones for cluster or crossover trials.

Disclosure: written by the team behind Vizcept.