Democracy Under Pressure

Sebastian Molina · March 2026

Measuring Democracy

Democracy is more than just a word; it’s a complicated set of gears. We often think it’s just about voting, but it actually depends on everything from how free the media is to how independent the courts are.

The V-Dem project tracks these different “gears” across 170+ countries to see where they are slipping and where they are holding steady. In the table below you can see the five main areas they measure, and in the chart you can see how they have changed globally since 1990.

Index	V-Dem variable	What it measures
Electoral Democracy	`v2x_polyarchy`	Free, fair, competitive elections; universal suffrage
Liberal Democracy	`v2x_libdem`	Individual rights, rule of law, checks on executive
Participatory Democracy	`v2x_partipdem`	Active civil society participation beyond the ballot
Deliberative Democracy	`v2x_delibdem`	Quality of public reasoning in political decisions
Egalitarian Democracy	`v2x_egaldem`	Equal distribution of political power across groups

Code

d3 = require("d3@7")

// ── Theme bridge ─────────────────────────────────────────────────────────────
// Your global.css already handles:
//   svg text          → font-family, fill: #888882
//   svg .tick text    → font-size: 11px, fill: #888882
//   svg .domain       → display: none
//   .tooltip-box      → all tooltip styles
//   .plot, .plot-fill → aspect ratios and layout
//
// This helper bridges the remaining values that CSS can't inject into D3
// function calls (axis constructors, scale calls, etc.).
// All methods are functions so they re-read live computed values,
// making them automatically light/dark-mode aware.

theme = {
  const css = () => getComputedStyle(document.documentElement);
  return {
    // ── Values ──────────────────────────────────────────────────────────────
    fontSans:    () => css().getPropertyValue("--font-sans").trim(),
    textMuted:   () => css().getPropertyValue("--table-text").trim(),
    borderLight: () => css().getPropertyValue("--border-light").trim(),
    bgBody:      () => css().getPropertyValue("--bg-body").trim(),
    tickSize:    () => parseInt(css().getPropertyValue("--chart-tick-size"))  || 11,
    labelSize:   () => parseInt(css().getPropertyValue("--chart-label-size")) || 12,
    dotRadius:   () => parseFloat(css().getPropertyValue("--chart-dot-radius")) || 4,

    // ── Helpers ─────────────────────────────────────────────────────────────

    // Apply to any D3 axis selection — removes domain line (CSS handles it
    // globally but this is a safety net), sets muted fill and font.
    // Usage: g.append("g").call(d3.axisLeft(y)).call(g => theme.styleAxis(g))
    styleAxis(g) {
      g.select(".domain").remove();
      g.selectAll("text")
        .attr("fill", this.textMuted())
        .style("font-size", this.tickSize() + "px")
        .style("font-family", this.fontSans());
      return g;
    },

    // Draw subtle horizontal grid lines behind a chart.
    // Usage: theme.gridLines(g, yScale, innerWidth)
    gridLines(g, yScale, width, ticks = 5) {
      g.selectAll(".grid-line")
        .data(yScale.ticks(ticks))
        .join("line")
          .attr("class", "grid-line")
          .attr("x1", 0).attr("x2", width)
          .attr("y1", d => yScale(d)).attr("y2", d => yScale(d))
          .attr("stroke", this.borderLight())
          .attr("stroke-opacity", 0.6);
      return g;
    },

    // Append a positioned axis label with consistent styling.
    // Usage: theme.axisLabel(svg, "Label text", x, y)
    // For rotated Y-axis: theme.axisLabel(svg, "Label", -h/2, -42, -90)
    axisLabel(svg, text, x, y, rotate = 0) {
      const el = svg.append("text")
        .attr("x", x).attr("y", y)
        .attr("text-anchor", "middle")
        .attr("class", "axis-label")  // picks up svg .axis-label from global.css
        .text(text);
      if (rotate) el.attr("transform", `rotate(${rotate})`);
      return el;
    },
  };
}

// ── Data-specific palette (semantic to this notebook, not site tokens) ────────
COLORS = ({
  v2x_polyarchy:  "#4A7CC9",
  v2x_libdem:     "#C96B3E",
  v2x_partipdem:  "#3BA882",
  v2x_delibdem:   "#A97BC0",
  v2x_egaldem:    "#C9A030",
})

// ── Tooltip ───────────────────────────────────────────────────────────────────
// .d3-tooltip is fully styled by global.css — no duplication needed here.
tooltip = {
  // Use join pattern to ensure only one div exists even if cell re-runs
  return d3.select("body")
    .selectAll(".d3-tooltip").data([null]).join("div")
    .attr("class", "d3-tooltip");
}

function showTip(html, event) {
  if (!event) return;
  d3.select(".d3-tooltip")
    .html(html)
    .style("display", "block")
    .style("opacity", 1)
    .style("left", (event.clientX + 14) + "px")
    .style("top",  (event.clientY - 28) + "px");
}
function hideTip() { 
  d3.select(".d3-tooltip")
    .style("display", "none")
    .style("opacity", 0); 
}

Code

trendsLegend = {
  const container = d3.create("div").attr("class", "legend");
  Object.entries(indices_meta).forEach(([key, label]) => {
    const item = container.append("div").attr("class", "legend-item");
    item.append("div")
      .attr("class", "legend-swatch")
      .style("background-color", COLORS[key]);
    item.append("span").text(label.replace(" Democracy", ""));
  });
  return container.node();
}

Code

linePlot = {
  const W = 760, H = 420;
  const m = { top: 24, right: 30, bottom: 44, left: 50 };
  const w = W - m.left - m.right;
  const h = H - m.top  - m.bottom;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, W, H])
    .style("width", "100%").style("height", "auto")

  const g = svg.append("g").attr("transform", `translate(${m.left},${m.top})`);

  const x = d3.scaleLinear().domain(d3.extent(trends_data, d => d.year)).range([0, w]);
  const y = d3.scaleLinear().domain([0, 1]).range([h, 0]);

  g.append("g").selectAll("line").data(y.ticks(5)).join("line")
    .attr("x1", 0).attr("x2", w)
    .attr("y1", d => y(d)).attr("y2", d => y(d))
    .attr("stroke", "#e8e8e8");

  g.append("g").attr("transform", `translate(0,${h})`)
    .call(d3.axisBottom(x).tickFormat(d3.format("d")).ticks(8))
    .call(g => g.select(".domain").remove())
    .call(g => g.selectAll("text").attr("fill", "#888882").style("font-size", "11px"));

  g.append("g")
    .call(d3.axisLeft(y).ticks(5).tickFormat(d3.format(".1f")))
    .call(g => g.select(".domain").remove())
    .call(g => g.selectAll("text").attr("fill", "#888882").style("font-size", "11px"));

  g.append("text").attr("transform", "rotate(-90)")
    .attr("y", -38).attr("x", -h/2).attr("text-anchor", "middle")
    .style("font-size", "11px").style("fill", "#888882")
    .text("Mean index value (0–1)");

  const series = Object.keys(indices_meta).map(idx => {
    const col = COLORS[idx];
    const group = g.append("g").attr("class", `series-${idx}`);

    group.append("path").datum(trends_data)
      .attr("fill", col).attr("opacity", 0.12)
      .attr("d", d3.area()
        .x(d => x(d.year)).y0(d => y(d[idx+"_lo"])).y1(d => y(d[idx+"_hi"]))
        .curve(d3.curveMonotoneX));

    group.append("path").datum(trends_data)
      .attr("fill", "none").attr("stroke", col).attr("stroke-width", 2.2)
      .attr("d", d3.line()
        .x(d => x(d.year)).y(d => y(d[idx]))
        .curve(d3.curveMonotoneX));



    const dot = group.append("circle").attr("r", 4).attr("fill", col).attr("stroke", "#fff").attr("stroke-width", 1.5).attr("opacity", 0);
    
    return { idx, dot };
  });

  const bisect   = d3.bisector(d => d.year).left;
  const hairline = g.append("line").attr("stroke", "#ccc").attr("stroke-width", 1).attr("y1", 0).attr("y2", h).attr("opacity", 0);

  svg.append("rect").attr("fill", "none").attr("pointer-events", "all")
    .attr("x", m.left).attr("y", m.top).attr("width", w).attr("height", h)
    .on("mousemove", function(event) {
      const mx   = d3.pointer(event, g.node())[0];
      const year = Math.round(x.invert(mx));
      const d    = trends_data[Math.min(bisect(trends_data, year), trends_data.length - 1)];
      if (!d) return;

      hairline.attr("x1", x(d.year)).attr("x2", x(d.year)).attr("opacity", 1);
      series.forEach(s => {
        s.dot.attr("cx", x(d.year)).attr("cy", y(d[s.idx])).attr("opacity", 1);
      });

      const tipHtml = `<div style="font-weight:600;margin-bottom:6px;border-bottom:1px solid #444;padding-bottom:2px">${d.year}</div>` +
        Object.keys(indices_meta).map(k =>
          `<div style="display:flex;justify-content:space-between;gap:16px;line-height:1.4">
             <span style="color:${COLORS[k]};font-weight:500">${indices_meta[k].replace(" Democracy","")}</span>
             <span style="font-family:inherit">${d[k].toFixed(3)}</span>
           </div>`).join("");
      
      showTip(tipHtml, event);
    })
    .on("mouseleave", () => { 
      hairline.attr("opacity", 0); 
      series.forEach(s => s.dot.attr("opacity", 0));
      hideTip(); 
    });

  return svg.node();
}

Shaded areas show where the data is a bit less certain. Overall, the world reached a high point for democracy in the early 2010s, but it’s been dropping steadily since.

Regional Divergence

The global average hides a lot of variation. While most of the world is seeing a drop in democratic scores, Asia-Pacific and Eastern Europe have been the bright spots, showing significant growth in their democratic scores lately. Places like Latin America and the Middle East, however, are seeing their progress slide backwards.

Code

regionalColors = ({
  "W. Europe & N. America":    "#4A7CC9",
  "E. Europe & C. Asia":       "#76BADE",
  "Latin America & Caribbean": "#3BA882",
  "Asia-Pacific":              "#C9A030",
  "MENA":                      "#C96B3E",
  "Sub-Saharan Africa":        "#A97BC0",
})

regionalGrid = {
  const container = d3.create("div")
    .style("display", "grid")
    .style("grid-template-columns", "repeat(auto-fill, minmax(290px, 1fr))")
    .style("gap", "16px");

  const allPlots = [];
  const entries  = Object.entries(regional_data);
  const bisect   = d3.bisector(d => d.year).left;

  const sync = (year, event) => {
    if (year === null) {
      allPlots.forEach(p => p.hide());
      hideTip();
      return;
    }
    allPlots.forEach(p => p._update(year));
    
    const tipHtml = `<div style="font-weight:600;margin-bottom:6px;border-bottom:1px solid #444;padding-bottom:2px">${year}</div>` +
      entries.map(([reg, data]) => {
        const d = data.find(d => d.year === year);
        const val = d ? d.v2x_libdem.toFixed(3) : "—";
        const col = regionalColors[reg] ?? "#888";
        return `<div style="display:flex;justify-content:space-between;gap:16px;line-height:1.4">
                  <span style="color:${col};font-weight:500">${reg}</span>
                  <span>${val}</span>
                </div>`;
      }).join("");
    showTip(tipHtml, event);
  };

  entries.forEach(([region, data]) => {
    const W = 290, H = 190;
    const m = {top: 32, right: 14, bottom: 28, left: 36};
    const col = regionalColors[region] ?? "#888";

    const svg = d3.create("svg")
      .attr("viewBox", [0, 0, W, H])
      .style("width","100%").style("height","auto")

    const x = d3.scaleLinear().domain([1990, 2025]).range([m.left, W - m.right]);
    const y = d3.scaleLinear().domain([0, 1]).range([H - m.bottom, m.top]);

    svg.append("text").attr("x", m.left).attr("y", 18)
      .style("font-size","11px").style("font-weight","500").style("fill", col)
      .text(region);

    svg.append("path").datum(data)
      .attr("fill", col).attr("opacity", 0.08)
      .attr("d", d3.area()
        .x(d => x(d.year)).y0(H - m.bottom).y1(d => y(d.v2x_libdem))
        .curve(d3.curveMonotoneX));

    svg.append("path").datum(data)
      .attr("fill","none").attr("stroke", col).attr("stroke-width", 1.8)
      .attr("d", d3.line().x(d => x(d.year)).y(d => y(d.v2x_libdem)).curve(d3.curveMonotoneX));

    svg.append("g").attr("transform", `translate(0,${H - m.bottom})`)
      .call(d3.axisBottom(x).ticks(4).tickFormat(d3.format("d")))
      .call(g => g.select(".domain").remove())
      .call(g => g.selectAll("text").style("font-size","9px").attr("fill","#888882"));

    svg.append("g").attr("transform", `translate(${m.left},0)`)
      .call(d3.axisLeft(y).ticks(3).tickFormat(d3.format(".1f")))
      .call(g => g.select(".domain").remove())
      .call(g => g.selectAll("text").style("font-size","9px").attr("fill","#aaa"));

    const hairline = svg.append("line").attr("stroke", "#ccc").attr("stroke-width", 1)
      .attr("y1", m.top).attr("y2", H - m.bottom).attr("opacity", 0);
    const dot = svg.append("circle").attr("r", 3.5).attr("fill", col).attr("stroke", "#fff").attr("stroke-width", 1).attr("opacity", 0);

    const node = svg.node();
    node._update = (year) => {
      const d = data.find(d => d.year === year);
      if (!d) { node.hide(); return; }
      hairline.attr("x1", x(year)).attr("x2", x(year)).attr("opacity", 1);
      dot.attr("cx", x(year)).attr("cy", y(d.v2x_libdem)).attr("opacity", 1);
    };
    node.hide = () => { hairline.attr("opacity", 0); dot.attr("opacity", 0); };
    allPlots.push(node);

    svg.append("rect").attr("fill","none").attr("pointer-events","all")
      .attr("x", m.left).attr("y", m.top)
      .attr("width", W - m.left - m.right).attr("height", H - m.top - m.bottom)
      .on("mousemove", function(event) {
        const year = Math.round(x.invert(d3.pointer(event)[0]));
        sync(year, event);
      })
      .on("mouseleave", () => sync(null));

    container.append(() => node);
  });

  return container.node();
}

Where Democracy Stands Today

The slide away from democracy doesn’t look the same everywhere. You can use the map below to see how different countries changed over time—from the gains in the 1990s to the recent declines in many places.

Code

topojson = require("topojson-client@3")
viewof map_metric = {
  const input = Inputs.select(
    new Map([["Liberal Democracy", "v2x_libdem"], ["Electoral Democracy", "v2x_polyarchy"]]),
    {value: "v2x_libdem", label: "Metric"}
  );
  const sel = input.querySelector("select");
  if (sel) sel.classList.add("picker");
  return input;
}

Code

worldMap = {
  const W = 820, H = 460;
  const colorScale = d3.scaleSequential(d3.interpolateRdYlBu).domain([0, 1]);
  const projection = d3.geoNaturalEarth1().scale(W / 6.3).translate([W / 2, H / 2]);
  const path = d3.geoPath().projection(projection);
  const features = topojson.feature(world_topo, world_topo.objects.countries).features;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, W, H])
    .style("width", "100%").style("height", "auto");

  // Draw paths once — only fill is updated reactively
  const paths = svg.append("g").selectAll("path")
    .data(features).join("path")
    .attr("d", path)
    .attr("stroke", "#fff").attr("stroke-width", 0.4)
    .attr("fill", d => {
      const score = map_data[num2iso3[String(d.id)]]?.scores[map_metric]?.[String(map_year)];
      return score != null ? colorScale(score) : "#e0e0e0";
    })
    .on("mousemove", (event, d) => {
      const iso   = num2iso3[String(d.id)];
      const score = map_data[iso]?.scores[map_metric]?.[String(map_year)];
      showTip(
        `<strong>${map_data[iso]?.name ?? "Unknown"}</strong><br>` +
        `${map_metric === "v2x_libdem" ? "Liberal" : "Electoral"} Democracy<br>` +
        (score != null ? score.toFixed(3) : "No data"),
        event);
    })
    .on("mouseleave", hideTip);

  // Large year watermark
  const yearLabel = svg.append("text")
    .attr("x", 20).attr("y", H - 14)
    .style("font-size", "26px").style("font-weight", "600")
    .style("fill", "#bbb").style("opacity", 0.5)
    .text(map_year);

  // Color legend
  const defs = svg.append("defs");
  const grad = defs.append("linearGradient").attr("id", "map-grad");
  d3.range(0, 1.01, 0.1).forEach(t =>
    grad.append("stop").attr("offset", t).attr("stop-color", colorScale(t)));
  const lg = svg.append("g").attr("transform", `translate(${W - 180},${H - 32})`);
  lg.append("rect").attr("width", 160).attr("height", 10).attr("rx", 3).attr("fill", "url(#map-grad)");
  lg.append("text").attr("y", 22).style("font-size", "10px").style("fill", "#666").text("0 — least");
  lg.append("text").attr("x", 160).attr("y", 22).attr("text-anchor", "end")
    .style("font-size", "10px").style("fill", "#666").text("1 — most");

  // Expose update fn so reactive cells can call it
  svg.node()._update = (year, metric) => {
    const yk = String(year);
    paths.transition().duration(400).ease(d3.easeCubicOut)
      .attr("fill", d => {
        const score = map_data[num2iso3[String(d.id)]]?.scores[metric]?.[yk];
        return score != null ? colorScale(score) : "#e0e0e0";
      });
    yearLabel.text(year);
  };

  return svg.node();
}

// Reactive cell — re-runs whenever map_year or map_metric changes
mapReactive = { if (worldMap?._update) worldMap._update(map_year, map_metric); }

Code

mapVisibility = {
  const container = document.querySelector("#map-wrap");
  if (!container) return null;
  return Generators.observe(notify => {
    const observer = new IntersectionObserver(entries => {
      if (entries[0].isIntersecting) {
        notify(true);
        observer.disconnect();
      }
    }, { threshold: 0.5 });
    observer.observe(container);
    return () => observer.disconnect();
  });
}

// Play animation logic (Side effect only)
{
  playMap;       // Manual trigger
  mapVisibility; // Auto trigger
  let cancelled = false;
  invalidation.then(() => { cancelled = true; });
  
  if (playMap > 0 || mapVisibility) {
    (async () => {
      for (let y = 1990; y <= 2024; ++y) {
         if (cancelled) break;
         viewof map_year.value = y;
         viewof map_year.dispatchEvent(new CustomEvent("input"));
         await Promises.tick(600);
      }
    })();
  }
}

Country Profile

Select a country to view its current profile across all five democracy dimensions.

Code

viewof radar_country = {
  const input = Inputs.select(
    radar_data.map(d => d.name).sort(),
    {label: "Country", value: "Mexico"}
  );
  const sel = input.querySelector("select");
  if (sel) sel.classList.add("picker");
  return input;
}

Code

radarPlot = {
  const W = 360, H = 360;
  const R  = Math.min(W, H) / 2 - 50;
  const country    = radar_data.find(d => d.name === radar_country);
  const categories = Object.keys(indices_meta);
  const values     = categories.map(k => country.scores[k] ?? 0);
  const angle      = i => (i / categories.length) * 2 * Math.PI - Math.PI / 2;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, W, H])
    .style("width", "320px")
    .style("height", "auto")
    .style("margin", "0 auto")
    .style("display", "block")

  const g = svg.append("g").attr("transform", `translate(${W/2},${H/2})`);

  [0.2, 0.4, 0.6, 0.8, 1.0].forEach(r => {
    g.append("circle").attr("r", R * r).attr("fill","none").attr("stroke","#e8e8e8");
    g.append("text").attr("y", -R * r - 3).attr("text-anchor","middle")
      .style("font-size","8px").style("fill","#bbb").text(r.toFixed(1));
  });

  categories.forEach((_, i) =>
    g.append("line")
      .attr("x1",0).attr("y1",0)
      .attr("x2", Math.cos(angle(i)) * R).attr("y2", Math.sin(angle(i)) * R)
      .attr("stroke","#e8e8e8"));

  const pts = values.map((v, i) => [Math.cos(angle(i)) * R * v, Math.sin(angle(i)) * R * v]);

  // Dash comparison (Global Average)
  const avgValues = categories.map(k => radar_avg[k] ?? 0);
  const avgPts = avgValues.map((v, i) => [Math.cos(angle(i)) * R * v, Math.sin(angle(i)) * R * v]);
  g.append("polygon")
    .attr("points", avgPts.map(p => p.join(",")).join(" "))
    .attr("fill", "none").attr("stroke", "#bbb").attr("stroke-width", 1.5)
    .attr("stroke-dasharray", "4,4").attr("opacity", 0.6);

  g.append("polygon")
    .attr("points", pts.map(p => p.join(",")).join(" "))
    .attr("fill","#4A7CC9").attr("fill-opacity",0.18)
    .attr("stroke","#4A7CC9").attr("stroke-width",2.2);

  pts.forEach((p, i) =>
    g.append("circle").attr("cx", p[0]).attr("cy", p[1]).attr("r", 4)
      .attr("fill","#4A7CC9").attr("stroke","#fff").attr("stroke-width",1.5)
      .on("mousemove", event =>
        showTip(`<strong>${indices_meta[categories[i]]}</strong><br>${values[i].toFixed(3)}`, event))
      .on("mouseleave", hideTip));

  categories.forEach((cat, i) => {
    const a = angle(i);
    const lx = Math.cos(a) * (R + 18), ly = Math.sin(a) * (R + 18);
    g.append("text").attr("x", lx).attr("y", ly)
      .attr("text-anchor", Math.abs(lx) < 10 ? "middle" : lx > 0 ? "start" : "end")
      .attr("dominant-baseline","middle")
      .style("font-size","11px").style("font-weight","500").style("fill","#444")
      .text(indices_meta[cat].replace(" Democracy",""));
  });

  // Small legend for comparison
  const leg = svg.append("g").attr("transform", `translate(${W - 90}, ${H - 10})`);
  leg.append("line").attr("x1", 0).attr("x2", 14).attr("y1", 0).attr("y2", 0)
     .attr("stroke", "#bbb").attr("stroke-width", 1.5).attr("stroke-dasharray", "3,2");
  leg.append("text").attr("x", 18).attr("y", 0).attr("dominant-baseline", "middle")
     .style("font-size", "9px").style("fill", "#999").style("font-weight", "500")
     .text("Global Avg");

  return svg.node();
}

What Predicts Democratic Change?

Blue bars retained by parallel analysis. Orange dashed line = 95th percentile of 200 simulated random datasets.

To identify latent constructs that predict democratic change, we run Exploratory Factor Analysis on twelve V-Dem sub-indicators, then use the lagged factor scores (t − 1) as predictors of electoral democracy (v2x_polyarchy) at time t in a two-way fixed effects panel model with country-clustered standard errors.

Code

loadingsHeatmap = {
  const factors = [...new Set(loadings_data.map(d => d.factor))];
  const vars    = [...new Set(loadings_data.map(d => d.var))];
  const cellH = 20, cellW = 70;
  const m = {top: 28, right: 20, bottom: 10, left: 160};
  const W = m.left + cellW * factors.length + m.right;
  const H = m.top  + cellH * vars.length   + m.bottom;

  const absMax     = d3.max(loadings_data, d => Math.abs(d.value));
  const colorScale = d3.scaleDiverging(d3.interpolateRdBu).domain([-absMax, 0, absMax]);

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, W, H])
    .style("width","100%").style("height","auto")
    .style("max-width", "500px")
    .style("margin", "0 auto")
    .style("display", "block");

  svg.selectAll(".fh").data(factors).join("text")
    .attr("x", (d,i) => m.left + i*cellW + cellW/2).attr("y", m.top - 8)
    .attr("text-anchor","middle")
    .style("font-size","12px").style("font-weight","500").style("fill","#444")
    .text(d => d);

  svg.selectAll(".rl").data(vars).join("text")
    .attr("x", m.left - 8).attr("y", (d,i) => m.top + i*cellH + cellH/2)
    .attr("text-anchor","end").attr("dominant-baseline","middle")
    .style("font-size","11px").style("fill","#555")
    .text(d => d);

  svg.selectAll(".cell").data(loadings_data).join("rect")
    .attr("x", d => m.left + factors.indexOf(d.factor)*cellW + 1)
    .attr("y", d => m.top  + vars.indexOf(d.var)*cellH + 1)
    .attr("width", cellW - 2).attr("height", cellH - 2).attr("rx", 0.5)
    .attr("fill", d => colorScale(d.value))
    .on("mousemove", (event, d) =>
      showTip(`<strong>${d.var}</strong><br>${d.factor}: ${d.value.toFixed(3)}`, event))
    .on("mouseleave", hideTip);

  svg.selectAll(".cv").data(loadings_data).join("text")
    .attr("x", d => m.left + factors.indexOf(d.factor)*cellW + cellW/2)
    .attr("y", d => m.top  + vars.indexOf(d.var)*cellH + cellH/2)
    .attr("text-anchor","middle").attr("dominant-baseline","middle")
    .style("font-size","10px")
    .style("fill", d => Math.abs(d.value) > 0.5 ? "#fff" : "#333")
    .text(d => d.value.toFixed(2));

  return svg.node();
}

Factor loadings from oblique (oblimin) EFA. Strong loadings (|λ| > 0.5) in white text. Blue = positive, red = negative.

Code

mechPlot = {
  const W = 680, H = 80 + mech_data.length * 68;
  const m = {top: 24, right: 60, bottom: 70, left: 180};
  const w = W - m.left - m.right;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, W, H])
    .style("width","100%").style("height","auto")
    .style("max-width", "680px")
    .style("margin", "0 auto")
    .style("display", "block");

  const allVals = mech_data.flatMap(d => [d.lo, d.hi]);
  const xPad    = (d3.max(allVals) - d3.min(allVals)) * 0.1;
  const x = d3.scaleLinear()
    .domain([Math.min(0, d3.min(allVals) - xPad), Math.max(0, d3.max(allVals) + xPad)])
    .range([m.left, W - m.right]);
  const y = d3.scaleBand()
    .domain(mech_data.map(d => d.name))
    .range([m.top, H - m.bottom]).padding(0.55);

  svg.append("g").attr("transform", `translate(0,${H - m.bottom})`)
    .call(d3.axisBottom(x).ticks(5).tickFormat(d3.format("+.4f")))
    .call(g => g.select(".domain").remove())
    .call(g => g.selectAll("text").attr("fill","#888882").style("font-size","11px"));

  svg.append("g").attr("transform", `translate(${m.left},0)`)
    .call(d3.axisLeft(y))
    .call(g => g.select(".domain").remove())
    .call(g => g.selectAll("text").attr("fill","#333").style("font-size","13px"));

  svg.append("text").attr("x", m.left + w/2).attr("y", H - 38)
    .attr("text-anchor","middle")
    .style("font-size","11px").style("font-weight","500").style("fill","#888")
    .text("Coefficient (Effect Size)");

  svg.append("line")
    .attr("x1", x(0)).attr("x2", x(0)).attr("y1", m.top).attr("y2", H - m.bottom)
    .attr("stroke","#ccc").attr("stroke-dasharray","4,3");

  const rows = svg.selectAll(".row").data(mech_data).join("g");
  const cy   = d => y(d.name) + y.bandwidth()/2;

  rows.append("line")
    .attr("x1", d => x(d.lo)).attr("x2", d => x(d.hi))
    .attr("y1", cy).attr("y2", cy)
    .attr("stroke", d => d.sig ? "#C96B3E" : "#bbb").attr("stroke-width", 2);

  ["lo","hi"].forEach(end =>
    rows.append("line")
      .attr("x1", d => x(d[end])).attr("x2", d => x(d[end]))
      .attr("y1", d => cy(d) - 4).attr("y2", d => cy(d) + 4)
      .attr("stroke", d => d.sig ? "#C96B3E" : "#bbb").attr("stroke-width", 2));

  rows.append("circle")
    .attr("cx", d => x(d.coef)).attr("cy", cy).attr("r", 6)
    .attr("fill", d => d.sig ? "#C96B3E" : "#bbb")
    .attr("stroke","#fff").attr("stroke-width",1.5)
    .on("mousemove", (event, d) =>
      showTip(
        `<strong>${d.name}</strong><br>β = ${d.coef.toFixed(4)}<br>` +
        `95% CI [${d.lo.toFixed(4)}, ${d.hi.toFixed(4)}]<br>` +
        `p = ${d.p_value < 0.001 ? "<0.001" : d.p_value.toFixed(3)}<br>` +
        `SE = ${d.se.toFixed(4)}`, event))
    .on("mouseleave", hideTip);

  rows.append("text")
    .attr("x", d => x(d.hi) + 8).attr("y", cy).attr("dominant-baseline","middle")
    .style("font-size","10px").style("fill", d => d.sig ? "#C96B3E" : "#aaa")
    .text(d => d.p_value < 0.001 ? "p<.001 *" : `p=${d.p_value.toFixed(3)}${d.sig?" *":""}`);

  const meta = mech_meta;
  svg.append("text").attr("x", m.left).attr("y", H - 12)
    .style("font-size","10px").style("fill","#aaa")
    .text(`Two-way FE panel OLS · ${meta.se_type} SE · N=${meta.n_obs} obs, ${meta.n_entities} countries · R²(within)=${meta.r2_within}`);

  return svg.node();
}

Coefficients represent the effect of a one-SD change in the lagged factor score (year t − 1) on electoral democracy (year t). Orange = significant at p < 0.05. Hover for full statistics.

The data suggests that democratic progress—or backsliding—doesn’t just happen because of one thing. It’s usually about how different parts of society, like the courts and the media, work together.

What’s behind the numbers?

The Factor Analysis (the heatmap above) helps us group 12 different indicators into bigger themes. For example, things like media freedom and free speech usually move together as one group, while court independence and fair elections form another.

We then used a Regression model to see which of these themes actually predicts what happens next:

The role of media: It turns out that Media Freedom and Free Speech are some of the best ways to predict if a country’s democracy is about to get worse. This suggests that when the media starts losing its freedom, the rest of democracy usually follows about a year later.
The role of courts: Independent Courts and Fair Elections act like a safety net. If these stay strong, they can help stop a country from sliding too far, even if other freedoms are under pressure.

Basically, the data shows that democracy is often lost in the media and public debate before it’s lost at the voting booth or in the courts.

Why is it dropping?

To see exactly what’s driving this decline, we can look at which specific freedoms have changed the most since the 2012 peak. The chart below shows the average global drop for each indicator.

The chart shows that the biggest reductions are happening in Media Freedom, Freedom of Expression, and Freedom of Association. These aren’t just dropping; they are falling faster than things like election integrity or court independence.

This tells us something about how modern political systems change: the initial shifts often happen in the information environment rather than the ballot box. By making it harder for people to talk freely or for the media to report, it becomes easier to change other parts of the democratic system.

Conclusion: Protecting the Early Warning Signs

The data since 1990 shows a clear divide. While democracy is declining in most of the world, parts of the Asia-Pacific and Eastern Europe are actually becoming more democratic.

Our analysis shows that pressure on democracy usually hits the media and free speech first. These are the early warning signs. If we can keep the media free and let people speak their minds, the rest of the democratic system has a much better chance of surviving. In the end, protecting democracy isn’t just about the next election—it’s about protecting the environment that makes a fair election possible.

Methodology

This analysis investigates the latent drivers of democratic change between 1990 and 2025 using a two-stage statistical approach combining Exploratory Factor Analysis (EFA) and Panel Fixed Effects Regression.

1. Dimensionality Reduction (EFA)

To identify the underlying mechanisms from 12 high-dimensional indicators (covering judicial constraints, media freedom, and civil society space), I employ EFA:

Sampling Adequacy: Factorability is confirmed via the Kaiser-Meyer-Olkin (KMO) test for sampling adequacy and Bartlett’s test of sphericity.
Factor Retention: The optimal number of factors is determined through Parallel Analysis, retaining factors where empirical eigenvalues exceed the 95th percentile of those from 200 simulated random datasets.
Rotation & Extraction: Latent dimensions are extracted using Maximum Likelihood (or Minimum Residual as a fallback) and an oblique (Oblimin) rotation. This allows different facets of democracy—such as civil liberties and institutional constraints—to correlate, providing a more ecologically valid representation of political systems. Each factor is automatically labeled based on its primary loading indicator.

2. Longitudinal Modeling (Panel OLS)

To quantify how these latent dimensions predict changes in democratic quality (measured by V-Dem’s Electoral Democracy Index), I estimate a panel regression model:

Temporal Lag: Independent variables are lagged by one year (t − 1) to predict outcomes at time t. This helps address simultaneity bias and establishes a clearer temporal sequence for the relationship.
Fixed Effects: The model incorporates entity (country) and year (time) fixed effects. This controls for time-invariant country-specific characteristics (e.g., historical geography) and global temporal shocks that affect all nations simultaneously.
Robust Inference: Standard errors are clustered by country to account for serial correlation within countries over time, ensuring conservative and reliable hypothesis testing.

References

Coppedge, Michael, John Gerring, Carl Henrik Knutsen, Staffan I. Lindberg, Jan Teorell, David Altman, Fabio Angiolillo, Michael Bernhard, Agnes Cornell, M. Steven Fish, Linnea Fox, Lisa Gastaldi, Haakon Gjerløw, Adam Glynn, Ana Good God, Allen Hicken, Katrin Kinzelbach, Kyle L. Marquardt, et al. 2026. V-Dem Codebook V16. Varieties of Democracy (V-Dem) Project.

Coppedge, Michael, John Gerring, Carl Henrik Knutsen, Staffan I. Lindberg, Jan Teorell, Ana Good God, et al. 2026. V-Dem Country Coding Units V16. Varieties of Democracy (V-Dem) Project; https://www.v-dem.net/data/reference-documents/.

Coppedge, Michael, John Gerring, Carl Henrik Knutsen, Staffan I. Lindberg, Jan Teorell, David Altman, Fabio Angiolillo, Michael Bernhard, Agnes Cornell, M. Steven Fish, Linnea Fox, Lisa Gastaldi, Haakon Gjerløw, Adam Glynn, Ana Good God, Allen Hicken, Katrin Kinzelbach, Joshua Krusell, et al. 2026. V-Dem Country-Year Dataset V16. Varieties of Democracy (V-Dem) Project. https://doi.org/https://doi.org/10.23696/vdemds26.

Coppedge, Michael, John Gerring, Carl Henrik Knutsen, Staffan I. Lindberg, Jan Teorell, Kyle L. Marquardt, et al. 2026. V-Dem Methodology V16. Varieties of Democracy (V-Dem) Project; https://www.v-dem.net/data/reference-documents/.

Coppedge, Michael, John Gerring, Carl Henrik Knutsen, Staffan I. Lindberg, Jan Teorell, Susanna Burmeister, et al. 2026. V-Dem Organization and Management V16. Varieties of Democracy (V-Dem) Project; https://www.v-dem.net/data/reference-documents/.

Pemstein, Daniel, Kyle L. Marquardt, Eitan Tzelgov, et al. 2026. “The v-Dem Measurement Model: Latent Variable Analysis for Cross-National and Cross-Temporal Expert-Coded Data.” Varieties of Democracy Institute Working Paper 21 (11th Ed).