What Would It Take to Stop This Outbreak?

An Interactive Branching-Process Model of the 2026 Bundibugyo Epidemic

This note is a companion to the Other Designs chapter of Global Health Research in Practice, where the book takes up modeling studies, and a sibling to Testing Ebola Drugs in an Epidemic, which follows the same outbreak from the angle of treatment trials. Here the question is different: with only a surveillance count in hand, how does a response team decide where to put its effort — and how does a model help inform that decision?

It is built for teaching not for response planning. For the CDC team’s actual projections and recommendations, see their MMWR report and CDC’s official outbreak guidance.

A separate technical companion documents the model in full, lists every parameter, provides the code, and shows how it reproduces the CDC’s published figures.

On May 15, 2026, the Democratic Republic of the Congo and Uganda declared outbreaks of Ebola disease caused by Bundibugyo virus, centered in Ituri province in the northeastern DRC. By June 2 there were 378 confirmed cases (363 in the DRC and 15 in Uganda) and 63 confirmed deaths.

A few hundred cases doesn’t, by itself, tell you what kind of outbreak this is. The same early count is consistent with an epidemic that fades within weeks and one that grows into a regional emergency. The future epidemic depends on things the count doesn’t show: how many people each case goes on to infect, how much that number varies from person to person, and how fast the response can find and isolate the sick.

In June 2026, a CDC team published exactly this kind of forward look (Mooring et al., MMWR 2026). They estimated a basic reproductive number near 2.5 and projected the outbreak under several levels of case isolation. The contrast was large: with only 20% of infections detected and isolated, 65% of their simulations reached 20,000 or more cases within three months; with 70% isolated, 94% of simulations stayed under 10,000. Their conclusion was that urgent and sustained public health action would be needed to keep this outbreak from rivaling the 2014–2016 West Africa epidemic, which caused more than 28,000 cases and over 11,000 deaths.

The model below is a close reimplementation of theirs. You can run it, change the assumptions underneath it, and watch the projection move. Press Run simulations after changing any control. Each bar is built from 500 simulations (the same number the CDC used) so a run takes a moment; pressing Run again without changing anything will shift the numbers by a point or two. That wobble is just the model’s stochastic noise.

// Precomputed CDC starting point (seed 1006, 500 sims, default parameters). The first paint uses
// these directly — no engine import and no simulation on load, which is what removes the initial
// wait for both the figure and the controls. Regenerate if the engine, defaults, or seed change.
cachedDefault = [{"iso":0.2,"cases":[0.19,0.162,0.648],"deaths":[0.154,0.17,0.676],"pGe20kCases":0.648,"pGe4kDeaths":0.676,"accepted":500},{"iso":0.5,"cases":[0.638,0.152,0.21],"deaths":[0.55,0.198,0.252],"pGe20kCases":0.21,"pGe4kDeaths":0.252,"accepted":500},{"iso":0.7,"cases":[0.918,0.054,0.028],"deaths":[0.882,0.082,0.036],"pGe20kCases":0.028,"pGe4kDeaths":0.036,"accepted":500},{"iso":0.95,"cases":[1,0,0],"deaths":[1,0,0],"pGe20kCases":0,"pGe4kDeaths":0,"accepted":500}]

isoLevels = [0.20, 0.50, 0.70, 0.95]

palette = ["#cbd5e1", "#7dd3fc", "#0284c7"]

result = {
  const c = controls;
  // Initial load and Reset (seed 1006) return the precomputed CDC bars instantly — no engine
  // import, no simulation. Otherwise import the engine lazily and compute, accumulating draws in
  // batches and yielding to the browser between them so the page stays responsive (no synchronous
  // freeze / "page unresponsive") and the spinner animates. The single rng stream is reused across
  // all bars in order, so results are identical to runScenario and to the precomputed cache.
  if (c.seed === 1006) { yield {loading: false, bars: cachedDefault}; return; }
  const engine = await import(new URL("bundibugyo-engine.js", document.baseURI).href);
  const priors = engine.makePriors({offspringMedian: c.offspringMedian, cfrMean: c.cfrMean});
  const rng = engine.mulberry32(c.seed);
  const breathe = () => new Promise(res => requestAnimationFrame(res));
  const bars = [];
  for (let li = 0; li < isoLevels.length; li++) {
    yield {loading: true, done: li, total: isoLevels.length};
    await breathe();
    const opts = {isoProb: isoLevels[li], target: c.target, band: 0.20,
                  interventionDay: c.interventionDay, horizon: c.horizon, cap: 30000, priors};
    const results = [];
    const maxAttempts = c.nSims * 800;
    let attempts = 0;
    while (results.length < c.nSims && attempts < maxAttempts) {
      attempts++;
      const run = engine.calibratedRun(rng, opts);
      if (run) results.push(run.res);
      // Break the synchronous burst into ~2000-draw chunks; each is well under the browser's
      // unresponsive watchdog, and the await lets the spinner paint between chunks.
      if (attempts % 2000 === 0) { yield {loading: true, done: li, total: isoLevels.length}; await breathe(); }
    }
    const b = engine.bucketize(results);
    bars.push({iso: isoLevels[li], cases: b.cases, deaths: b.deaths,
               pGe20kCases: b.pGe20kCases, pGe4kDeaths: b.pGe4kDeaths, accepted: results.length});
  }
  yield {loading: false, bars};
}

viewof metric = {
  const radio = Inputs.radio(["Cases", "Deaths"], {value: "Cases"});
  const el = html`<div class="sim-metric"><span class="sim-metric-label">Show outbreak size by</span>${radio}</div>`;
  el.value = radio.value;
  radio.addEventListener("input", () => { el.value = radio.value; el.dispatchEvent(new Event("input", {bubbles: true})); });
  return el;
}

labels = metric === "Cases"
  ? ["Under 10,000", "10,000–19,999", "20,000 or more"]
  : ["Under 2,000", "2,000–3,999", "4,000 or more"]

// Legend
html`<div style="display:flex; flex-wrap:wrap; gap:1.25rem; font-size:0.85rem; margin:0.75rem 0 0.5rem;">
  ${labels.map((lab, i) => html`<span style="display:inline-flex; align-items:center; gap:0.4rem;"><span style="width:14px; height:14px; border-radius:2px; background:${palette[i]};"></span>${lab}</span>`)}
</div>`

// Stacked bars rendered as plain HTML divs (inline background colors — no SVG, no Plot color scale).
chart = {
  const H = 340;
  if (result.loading) {
    return html`<figure class="sim-loading" style="min-height:${H + 36}px;">
      <div class="sim-spinner"></div>
      <div>Running simulations… (${result.done} of ${result.total} scenarios)</div>
    </figure>`;
  }
  const bars = result.bars.map(bar => ({
    iso: Math.round(bar.iso * 100) + "%",
    fr: metric === "Cases" ? bar.cases : bar.deaths
  }));
  const seg = (f, i) => html`<div title="${labels[i]}: ${(f * 100).toFixed(0)}%"
      style="height:${f * 100}%; background:${palette[i]};"></div>`;
  // Each column is just the bar box (height H); iso labels sit in a separate row
  // below, sharing the same flex layout so they stay centered under each bar.
  const col = (b) => html`<div style="flex:1 1 0; min-width:0; height:100%; display:flex; flex-direction:column-reverse; outline:1px solid #e2e8f0; border-radius:2px; overflow:hidden;">
    ${b.fr.map(seg)}
  </div>`;
  const isoLabel = (b) => html`<div style="flex:1 1 0; min-width:0; text-align:center; font-size:0.85rem; color:#334155;">${b.iso}</div>`;
  // Continuous gridlines spanning the full plot width, anchored to the axis ticks.
  const gridline = (pos) => html`<div style="position:absolute; left:0; right:0; top:${pos}; border-top:1px ${pos === "50%" ? "dashed" : "solid"} rgba(148,163,184,0.45); pointer-events:none;"></div>`;
  const tick = (t, shift) => html`<div style="transform:translateY(${shift});">${t}</div>`;
  const GAP = "clamp(0.6rem, 3vw, 1.75rem)";
  return html`<figure style="margin:0.5rem 0 1rem;">
    <div style="display:flex; align-items:flex-start; gap:0.85rem;">
      <div style="flex:0 0 auto; display:flex; flex-direction:column; justify-content:space-between; height:${H}px; font-size:0.75rem; color:#94a3b8; text-align:right;">
        ${tick("100%", "-0.55em")}${tick("50%", "0")}${tick("0%", "0.55em")}
      </div>
      <div style="flex:1; min-width:0;">
        <div style="position:relative; height:${H}px;">
          ${gridline("0")}${gridline("50%")}${gridline("100%")}
          <div style="position:absolute; inset:0; display:flex; align-items:stretch; gap:${GAP};">
            ${bars.map(col)}
          </div>
        </div>
        <div style="display:flex; gap:${GAP}; margin-top:0.45rem;">
          ${bars.map(isoLabel)}
        </div>
      </div>
    </div>
    <figcaption style="font-size:0.8rem; color:#64748b; margin-top:0.7rem;">Horizontal axis: percentage of cases detected and isolated. Bar height: share of simulations reaching each outbreak size.</figcaption>
  </figure>`;
}

result.loading
  ? md`*Running simulations…*`
  : md`**At a glance.** ${metric === "Cases"
  ? `With isolation at **20%**, ${(result.bars[0].pGe20kCases*100).toFixed(0)}% of simulations reach 20,000 or more cases; at **70%**, ${(result.bars[2].pGe20kCases*100).toFixed(0)}%.`
  : `With isolation at **20%**, ${(result.bars[0].pGe4kDeaths*100).toFixed(0)}% of simulations reach 4,000 or more deaths; at **70%**, ${(result.bars[2].pGe4kDeaths*100).toFixed(0)}%.`}`

// Custom compound input: the controls are button-gated — dragging a slider updates only
// its own display; the model recomputes only when Run (or Reset) commits a snapshot.
viewof controls = {
  // A slider that shows its value in a bubble centered above the thumb — no number box.
  const slider = (min, max, val, step, fmt) => {
    fmt = fmt || (v => `${v}`);
    const input = html`<input type="range" class="sim-range" min="${min}" max="${max}" step="${step}" value="${val}">`;
    const bubble = html`<output class="sim-bubble"></output>`;
    const wrap = html`<div class="sim-slider"><div class="sim-slider-row">${bubble}${input}</div></div>`;
    const THUMB = 16;
    const update = () => {
      const v = +input.value;
      const frac = (v - min) / (max - min);
      bubble.textContent = fmt(v);
      bubble.style.left = `calc(${frac * 100}% + ${(0.5 - frac) * THUMB}px)`;
    };
    input.addEventListener("input", update);
    update();
    Object.defineProperty(wrap, "value", {
      get: () => +input.value,
      set: (v) => { input.value = v; update(); }
    });
    return wrap;
  };

  // R₀ is the control; the engine wants the offspring-mean median, and realized
  // R₀ averages to ≈ 0.87 × that, so convert with R0_FACTOR behind the scenes.
  const R0_FACTOR = 0.87;
  const target = Inputs.radio([50, 100, 200], {value: 50});
  const r0 = slider(1.3, 3.5, 2.5, 0.1, v => v.toFixed(1));
  const cfrMean = slider(0.10, 0.60, 0.33, 0.01, v => v.toFixed(2));
  const interventionDay = slider(-14, 60, 0, 1);
  const horizon = slider(60, 180, 90, 5);
  const nSims = slider(50, 500, 500, 50);
  const inputs = [target, r0, cfrMean, interventionDay, horizon, nSims];

  let seed = 1006; // matches the precomputed cachedDefault so the initial state needs no compute
  const snapshot = () => ({
    target: target.value, offspringMedian: r0.value / R0_FACTOR, cfrMean: cfrMean.value,
    interventionDay: interventionDay.value, horizon: horizon.value, nSims: nSims.value, seed
  });

  // Stop slider/radio input events from bubbling to the panel, so the model stays button-gated.
  for (const el of inputs) el.addEventListener("input", (e) => e.stopPropagation());

  const row = (labelText, control, help) => html`<div class="sim-row">
    <div class="sim-label">${labelText}</div>
    <div class="sim-control">${control}${help ? html`<div class="sim-help">${help}</div>` : ""}</div>
  </div>`;

  const runBtn = html`<button type="button" class="sim-btn sim-btn-primary">Run simulations</button>`;
  const resetBtn = html`<button type="button" class="sim-btn sim-btn-secondary">Reset to CDC assumptions</button>`;

  const panel = html`<div class="sim-panel">
    <div class="sim-tier">
      <div class="sim-tier-label">Outbreak assumptions</div>
      ${row("Deaths by May 24", target, "How far along the outbreak is assumed to be")}
      ${row("Reproduction number (R₀)", r0, "Infections per case before isolation; CDC estimated ≈ 2.5")}
      ${row("Case fatality ratio", cfrMean, "Load-bearing: the model calibrates to deaths")}
    </div>
    <div class="sim-tier">
      <div class="sim-tier-label">Response</div>
      ${row("Isolation start day", interventionDay, "Days from May 24; below 0 = a faster response")}
      <div class="sim-help" style="margin-top:0.25rem;">The other main lever — the share of cases detected and isolated — is shown at several levels along the chart's horizontal axis, not set here.</div>
    </div>
    <details class="sim-tier sim-advanced">
      <summary class="sim-tier-label">Advanced</summary>
      <div style="margin-top:0.85rem;">
        ${row("Projection horizon", horizon, "Days projected forward")}
        ${row("Simulations per bar", nSims, "Scope and precision, not a claim about the world")}
      </div>
    </details>
    <div class="sim-buttons">${runBtn}${resetBtn}</div>
  </div>`;

  panel.value = snapshot();
  const commit = () => { panel.value = snapshot(); panel.dispatchEvent(new Event("input", {bubbles: true})); };
  const setVal = (el, v) => { el.value = v; el.dispatchEvent(new Event("input", {bubbles: true})); };

  runBtn.onclick = () => { seed += 1; commit(); };
  resetBtn.onclick = () => {
    setVal(target, 50); setVal(r0, 2.5); setVal(cfrMean, 0.33);
    setVal(interventionDay, 0); setVal(horizon, 90); setVal(nSims, 500);
    seed = 1006; commit();
  };

  return panel;
}

Using a model to inform the response

A response team has to decide where to put limited effort while the outbreak is still small and most of what drives it is unobserved. How hard to push case-finding? How fast to stand up isolation? This is where modeling comes in.

This model is a branching process: start with a single infection, let each case generate a random number of new infections before recovering or dying, and repeat. The outbreak is the tree that grows from that rule, and its size follows from a handful of quantities: how transmissible the virus is, how much that varies from person to person, and how quickly the response interrupts it. Each is an input you set, and watching the projection move as you change them is how you ask which interventions would bend the outbreak’s path, and how much the answer depends on what you assumed.

The inputs split into two kinds. The intervention is what a response actually controls: the share of cases detected and isolated and when isolation begins. The assumptions are things you can’t observe and have to commit to: the reproduction number (R₀) sets transmissibility — how many people each case infects before isolation, which the CDC estimated near 2.5; the deaths by May 24 you choose is really a statement about how far along the outbreak already is, since the model infers an earlier start to match a higher death count; and the case fatality ratio, because the model calibrates to deaths, fixes how large a hidden pool of infections sits behind the same body count.

Each bar stacks the share of simulated outbreaks that stay small, land in the middle, or reach the catastrophic range three months out. The model is calibrated the way the CDC calibrated theirs. It infers when the outbreak began so the death count matches the figure you choose, then projects forward from May 24, 2026. It reproduces their headline figures, with a small documented residual at 50% isolation that the technical companion lays out in full.

What it leaves out

The CDC team was explicit about the limits of their model, and the same limits apply here. The death counts that anchor the calibration are themselves uncertain. Estimates of the reproduction number for Ebola vary widely across outbreaks, so any single calibrated value is more precise than the historical record can justify. And the model holds the world fixed in ways the real response will not: it doesn’t represent behavior change as people learn an outbreak is underway, doesn’t account for immunity among those who have recovered, and excludes the possibility of relapse. Read the projections as a structured argument about what could happen under stated conditions, not as a prediction of what will.

Take-home messages

A model lets you reason about an intervention you can’t test. You can’t run an outbreak twice to see what earlier or harder isolation would have done, so any claim about it comes from a model, and is only as good as its assumptions. The CDC developed their model to argue that urgent and sustained action is needed to keep the current outbreak from rivaling the 2014–2016 West Africa epidemic and its more than 28,000 cases.
The model turns the outbreak’s drivers into dials you can see. How transmissible the virus is, how much that varies, and how fast the response isolates cases are all inputs you set and change. That is how the CDC reasoned about it: with the reproduction number estimated near 2.5, the dial that decided the outcome was the share of cases detected and isolated.
The outcome hinges on a tipping point in case detection. There is a level—near seventy percent at this outbreak’s transmissibility—where the effective reproduction number falls below one and transmission begins to shrink. The CDC’s projections show the difference it makes: with 1 in 5 cases isolated, 65% of simulations reached 20,000 or more cases; with 7 in 10 isolated, 94% stayed under 10,000.

How this model was built and checked. The engine is a close reimplementation of the CDC’s branching-process model, not their original code. The technical companion note documents every parameter, provides the full source, and shows how the model reproduces the three supplementary figures from the MMWR report.