meta    = FileAttachment("data/meta.json").json()
regions = FileAttachment("data/regions.csv").csv({ typed: true })
bandRows = FileAttachment("data/bands.csv").csv({ typed: true })

// One index, built once: area -> its rows. Every headline number and the trend
// chart read from here, so no view ever scans the whole file.
byGeo = d3.group(bandRows, d => String(d.geo_code))

// regions.csv already arrives ordered: Nepal, then the 7 provinces, then the
// 77 districts, each group alphabetical. Keep that order — it is the
// administrative hierarchy, and a flat A–Z list would hide it.
regionOptions = regions

// Provinces are labelled as such so "Koshi" the province is never mistaken for
// a district in a flat dropdown.
regionLabel = new Map(regions.map(d => [
  String(d.geo_code),
  d.geo_level === "province" ? `${d.name} Province` : d.name
]))

regionLevel = new Map(regions.map(d => [String(d.geo_code), d.geo_level]))
bandLabel   = new Map(meta.bands.map(d => [d.key, d.label]))

html`<p class="sub">${meta.scenario_label}. ${meta.years[0]}–${meta.years[1]},
single year of age, 77 districts, 7 provinces and the national total.
Reads the PopSyM app contract only — no microdata, no engine internals.</p>`

viewof regionCode = Inputs.select(
  regionOptions.map(d => String(d.geo_code)),
  { label: "Area", format: c => regionLabel.get(c), value: meta.national_code }
)

viewof bandKey = Inputs.select(
  meta.bands.map(d => d.key),
  { label: "Age group", format: k => bandLabel.get(k), value: "all" }
)

viewof sexKey = Inputs.select(
  ["both", "f", "m"],
  {
    label: "Sex",
    format: k => ({ both: "Both sexes", f: "Female", m: "Male" })[k],
    value: "both"
  }
)

viewof year = Inputs.range(
  [meta.years[0], meta.years[1]],
  { label: "Year", step: 1, value: 2031 }
)

// A cohort is everyone born in the same year. Because a cohort ages one year
// for every year that passes, following one means walking a diagonal through
// the data — which is exactly what the two views below do.
viewof cohortYear = Inputs.range(
  [meta.years[0] - meta.ages[1], meta.years[1]],
  { label: "Follow cohort born", step: 1, value: 2021 }
)

band   = meta.bands.find(d => d.key === bandKey)
sexName = ({ both: "Both sexes", f: "Female", m: "Male" })[sexKey]

// The one filter every view shares.
inSex = d => sexKey === "both" || d.sex === sexKey

sum = xs => d3.sum(xs, d => d.population)

areaRows = byGeo.get(regionCode) ?? []

fmt  = d3.format(",.0f")
fmt1 = d3.format(",.1f")
pct  = d3.format("+.1%")

// Muted teal and ochre. Deliberately not red-vs-green: the difference survives
// red-green colour blindness and greyscale printing, and neither reads as a
// Nepali party colour. Every chart also labels its series directly, so colour
// is never the only cue.
colF = "#0b5f70"
colM = "#8a6320"
colMuted = "#c7d0d8"

// Age the followed cohort has reached in the year on display. Outside 0..100 it
// is not in the projection — either not yet born, or beyond the open age group.
// Plot defaults to 640px, which leaves charts stranded in the middle of a wide
// panel. Size them from the page instead.
//
// Deliberately NOT Quarto's reactive `width`: it is not defined in this
// runtime, and an undefined reference in OJS leaves the cell pending forever
// rather than erroring — which silently stalled every cell on the page.
// document.body.clientWidth always resolves.
pageWidth = Math.max(360, document.body.clientWidth || 1100)
wFull = Math.max(560, Math.min(pageWidth - 60, 1320))
wHalf = Math.max(400, Math.min(pageWidth / 2 - 70, 660))

cohortAgeNow = year - cohortYear
cohortVisible = cohortAgeNow >= meta.ages[0] && cohortAgeNow <= meta.ages[1]

selected  = areaRows.filter(d => d.band === bandKey && inSex(d))
popNow    = sum(selected.filter(d => d.year === year))
popBase   = sum(selected.filter(d => d.year === meta.years[0]))
areaTotal = sum(areaRows.filter(d => d.band === "all" && d.year === year && inSex(d)))

// The dependency ratio always uses both sexes and the standard age split --
// it is a property of the area, not of whatever is currently filtered.
depYear  = areaRows.filter(d => d.year === year)
depYoung = sum(depYear.filter(d => d.band === "child"))
depWork  = sum(depYear.filter(d => d.band === "work"))
depOld   = sum(depYear.filter(d => d.band === "old65"))

// The grid is built inside the template rather than on the surrounding div,
// because OJS inserts wrapper elements that would otherwise become the grid
// items instead of these four cards.
html`
<div class="statgrid">
<div class="stat">
  <span class="k">Population, ${year}</span>
  <span class="v">${fmt(popNow)}</span>
  <span class="n">${bandLabel.get(bandKey).toLowerCase()}${sexKey === "both" ? "" : ", " + sexName.toLowerCase()}</span>
</div>
<div class="stat">
  <span class="k">Share of area</span>
  <span class="v">${fmt1(100 * popNow / areaTotal)}<small>%</small></span>
  <span class="n">of ${fmt(areaTotal)} people</span>
</div>
<div class="stat">
  <span class="k">Change from ${meta.years[0]}</span>
  <span class="v ${popNow < popBase ? "down" : "up"}">${pct(popNow / popBase - 1)}</span>
  <span class="n">${fmt(popBase)} → ${fmt(popNow)}</span>
</div>
<div class="stat">
  <span class="k">Dependency ratio, ${year}</span>
  <span class="v">${fmt1(100 * (depYoung + depOld) / depWork)}</span>
  <span class="n">per 100 of working age</span>
</div>
</div>
`

ageRows = d3.csv(`data/pyramid/${regionCode}.csv`, d3.autoType)

pyramid = ageRows
  .filter(d => d.year === year && inSex(d))
  .map(d => ({
    sex: d.sex,
    age: d.age,
    population: d.population,
    // males left of the axis, females right
    signed: d.sex === "m" ? -d.population : d.population,
    // rows outside the chosen age band are drawn faint, so the filter shows up
    // in the shape and not only in the total above
    lit: d.age >= band.lo && d.age <= band.hi,
    // the followed cohort, at the age it has reached in this year
    isCohort: d.age === cohortAgeNow
  }))

Plot.plot({
  width: wHalf,
  height: 430,
  marginLeft: 44,
  marginRight: 14,
  x: { label: "Population →", tickFormat: t => fmt(Math.abs(t)), grid: true },
  y: { label: "Age", reverse: true, ticks: [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100] },
  marks: [
    Plot.barX(pyramid, {
      y: "age",
      x: "signed",
      fill: d => d.sex === "f" ? colF : colM,
      fillOpacity: d => d.lit ? 1 : 0.2,
      insetTop: 0.15,
      insetBottom: 0.15,
      title: d => `${d.sex === "f" ? "Female" : "Male"}, age ${d.age}\n${fmt(d.population)}`
    }),
    // The cohort's own bar, outlined so it can be picked out as it climbs the
    // pyramid year by year.
    Plot.barX(pyramid.filter(d => d.isCohort), {
      y: "age",
      x: "signed",
      fill: "none",
      stroke: "currentColor",
      strokeWidth: 1.4,
      insetTop: 0.15,
      insetBottom: 0.15
    }),
    Plot.text(
      cohortVisible ? [{ a: cohortAgeNow }] : [],
      { y: "a", x: 0, text: d => `born ${cohortYear}`, dy: -9,
        fontSize: 10, fontWeight: 600, fill: "currentColor" }
    ),
    Plot.ruleX([0], { stroke: "#98a4b0" }),
    Plot.text(
      pyramid.some(d => d.sex === "m") ? [{ t: "◀ Male" }] : [],
      { text: "t", frameAnchor: "top-left", dx: 6, dy: 4, fill: colM, fontWeight: 600 }
    ),
    Plot.text(
      pyramid.some(d => d.sex === "f") ? [{ t: "Female ▶" }] : [],
      { text: "t", frameAnchor: "top-right", dx: -6, dy: 4, fill: colF, fontWeight: 600 }
    )
  ]
})

html`<p class="cap">${regionLabel.get(regionCode)}, ${year}. Bars outside
<strong>${bandLabel.get(bandKey).toLowerCase()}</strong> are faded — that is the
age filter, visible in the shape rather than only in the total above.</p>`

trend = selected.slice().sort((a, b) => a.year - b.year)

Plot.plot({
  width: wHalf,
  height: 430,
  marginLeft: 64,
  marginRight: 76,
  x: { label: null, tickFormat: "d", grid: true },
  y: { label: "People", tickFormat: fmt, grid: true, zero: true },
  marks: [
    Plot.ruleY([0], { stroke: "#98a4b0" }),
    Plot.ruleX([year], { stroke: "#98a4b0", strokeDasharray: "2,3" }),
    Plot.line(trend, {
      x: "year",
      y: "population",
      z: "sex",
      stroke: d => d.sex === "f" ? colF : colM,
      strokeDasharray: d => d.sex === "m" ? "5,3" : null,
      strokeWidth: 2.2
    }),
    Plot.dot(trend.filter(d => d.year === year), {
      x: "year",
      y: "population",
      fill: d => d.sex === "f" ? colF : colM,
      r: 4.5
    }),
    Plot.text(trend.filter(d => d.year === meta.years[1]), {
      x: "year",
      y: "population",
      text: d => d.sex === "f" ? "Female" : "Male",
      fill: d => d.sex === "f" ? colF : colM,
      textAnchor: "start",
      dx: 8,
      fontWeight: 600
    })
  ]
})

html`<p class="cap">Solid line female, dashed male, each labelled directly — the
series stay readable without relying on colour. The dotted vertical rule marks
the year selected above.</p>`

cohortRows = ageRows
  .filter(d => d.year - d.age === cohortYear && inSex(d))
  .sort((a, b) => a.year - b.year)

cohortStart = cohortRows.filter(d => d.year === d3.min(cohortRows, x => x.year))
cohortEnd   = cohortRows.filter(d => d.year === d3.max(cohortRows, x => x.year))
cohortSize  = yr => d3.sum(cohortRows.filter(d => d.year === yr), d => d.population)

Plot.plot({
  width: wFull,
  height: 340,
  marginLeft: 66,
  marginRight: 78,
  x: { label: null, tickFormat: "d", grid: true },
  y: { label: "People in the cohort", tickFormat: fmt, grid: true, zero: true },
  marks: [
    Plot.ruleY([0], { stroke: "#98a4b0" }),
    Plot.ruleX([year], { stroke: "#98a4b0", strokeDasharray: "2,3" }),
    Plot.line(cohortRows, {
      x: "year",
      y: "population",
      z: "sex",
      stroke: d => d.sex === "f" ? colF : colM,
      strokeDasharray: d => d.sex === "m" ? "5,3" : null,
      strokeWidth: 2.2
    }),
    Plot.dot(cohortRows.filter(d => d.year === year), {
      x: "year", y: "population",
      fill: d => d.sex === "f" ? colF : colM, r: 4.5
    }),
    Plot.text(cohortEnd, {
      x: "year", y: "population",
      text: d => `${d.sex === "f" ? "Female" : "Male"}, age ${d.age}`,
      fill: d => d.sex === "f" ? colF : colM,
      textAnchor: "start", dx: 8, fontWeight: 600
    }),
    Plot.text(cohortStart, {
      x: "year", y: "population",
      text: d => `age ${d.age}`,
      fill: "currentColor", textAnchor: "end", dx: -8, fontSize: 11
    })
  ]
})

html`<p class="cap">The cohort born in <strong>${cohortYear}</strong> in
${regionLabel.get(regionCode)}${cohortRows.length === 0
  ? " is not in the projection window — choose a birth year between " +
    (meta.years[0] - meta.ages[1]) + " and " + meta.years[1] + "."
  : `, from age ${d3.min(cohortRows, d => d.age)} to age ${d3.max(cohortRows, d => d.age)}.` +
    (cohortVisible ? ` In ${year} they are ${cohortAgeNow}.` : "")}
Nobody joins a cohort after birth, so the line can only fall — through deaths
and through people leaving. Where the dashed male line drops away from the solid
female one in the twenties and thirties, that gap is labour migration, and it is
the same gap the pyramid shows as a notch. The outlined bar on the pyramid is
this cohort; move the year and watch it climb.</p>`

ranked = Array.from(
  d3.rollup(
    bandRows.filter(d =>
      d.band === bandKey &&
      d.year === year &&
      inSex(d) &&
      d.geo_level === "district"
    ),
    v => d3.sum(v, d => d.population),
    d => String(d.geo_code)
  ),
  ([code, population]) => ({
    code,
    name: regionLabel.get(code),
    population,
    selected: code === regionCode
  })
).sort((a, b) => b.population - a.population)

Plot.plot({
  width: wFull,
  height: 960,
  marginLeft: 116,
  marginRight: 66,
  x: { label: "People →", tickFormat: fmt, grid: true },
  y: { label: null, domain: ranked.map(d => d.name) },
  marks: [
    Plot.barX(ranked, {
      y: "name",
      x: "population",
      fill: d => d.selected ? colF : colMuted,
      title: d => `${d.name}\n${fmt(d.population)}`
    }),
    Plot.text(ranked.filter(d => d.selected), {
      y: "name",
      x: "population",
      text: d => fmt(d.population),
      textAnchor: "start",
      dx: 6,
      fill: colF,
      fontWeight: 600
    }),
    Plot.ruleX([0])
  ]
})

html`<p class="cap">All 77 districts, ${bandLabel.get(bandKey).toLowerCase()}, ${year}${sexKey === "both" ? "" : ", " + sexName.toLowerCase()}.
${regionLevel.get(regionCode) === "district"
  ? `The highlighted bar is ${regionLabel.get(regionCode)}.`
  : `No bar is highlighted — ${regionLabel.get(regionCode)} is an aggregate, not a district.`}
Change any control above and every chart on this page recomputes in the
browser.</p>`

What it shows

Projected population for Nepal from 2021 to 2051, by single year of age, sex and area — 77 districts, 7 provinces and the national total. The projection starts from the 2021 Census and carries recent trends in fertility, mortality and migration forward.

These are projections, not forecasts. They describe what follows if the assumptions in the scenario hold. They are most useful for the shape of change — which districts age, which lose working-age people, how many children will need school places — rather than as a precise count for any single year.

What “population” means here

The figures are the resident population: people present in Nepal.

This matters in Nepal more than in most countries. The 2021 Census counted 29.16 million people present and a further 2.19 million living abroad. This model’s base is adjusted for undercount and age misreporting, giving 29.37 million resident in 2021. Nepalis abroad are modelled separately and are not included in the numbers shown here.

That is why the pyramids show a visible notch in men aged roughly 20 to 45, and why it is deepest in the far west. Those men are not missing from Nepal’s population — they are working abroad, and this view counts who is in the country.

How the projection works

A multistate cohort-component model. Each single-year age group is carried forward one year at a time: survived using area-specific mortality, added to by births from women of reproductive age, and adjusted for movement between districts and across the national border. Every district is projected in its own right; provinces and the national total come from the model’s own aggregate runs, not from adding districts up afterwards — and the three agree to within one part in a million.

Source of the projection

The projection follows the input data, estimation methods and assumptions documented in Nepal’s official population projection report:

National Statistics Office (2025). National Population and Housing Census 2021: Population Projections for Nepal, 2021–2051. First edition. Kathmandu: National Statistics Office. ISBN 978-9937-9844-2-3.

That report is the authoritative reference. Anyone using these figures for planning or analysis should read it — it documents the assumptions in full, which a dashboard cannot.

The multistate approach used here — every district projected as a state in its own right, rather than shares of a national total — is described in:

KC, S., Speringer, M., Thapa, A., & Khanal, M. N. (2016). Projecting Nepal’s Demographic Future: How to deal with spatial and demographic heterogeneity. IIASA World Population Program.

Data inputs

Summarised from the sources documented in the NSO report above:

input	source
Base population, single year of age by ward	National Population and Housing Census 2021, National Statistics Office
Fertility — ASFR and TFR by district	Census 2021, estimated using the Arriaga method
Sex ratio at birth	Census 2021, by district
Marriage patterns	Nepal Demographic and Health Survey 2022
Mortality — life tables by district and province	Census 2021 death records, smoothed
Life expectancy reference	UN World Population Prospects
Absentee population (abroad)	Census 2021, by district and ward
Internal migration	Census 2021, migration in the five years before the census
Administrative geography	Census 2021 province / district / municipality / ward register

The scenario shown

Baseline — medium mortality, fertility and domestic migration. Fertility and mortality follow their recent trajectories; internal migration continues at observed rates. Low and high variants exist in the model and are not yet shown here.

Credits

The population model is the work of Samir KC.

The earlier Nepal population dashboard, which this one succeeds, was the responsibility of Divya Shakya, who did much of the work on it, with contributions from Jibesh Acharya and Ashim Paudel. Much of how these results are presented — the choice of indicators, the scenario comparisons, the way places are compared — comes from that dashboard.

Developed at PSR HUB as part of PopSyM, a population-based systems model for Nepal, within Khoj Nepal — the wider programme of demographic research and discovery on Nepal.

How to cite

KC, S. (2026). Nepal Population Explorer: projected population by age, sex and area, 2021–2051. PSR HUB / PopSyM. https://nepal-population-explorer.pages.dev/

Limitations

• The base year is the 2021 Census. Anything that has changed since is not in it.
• Small areas and small age groups are less reliable than large ones. A district of 65,000 carries more uncertainty than one of 800,000.
• Absentee (abroad) population is modelled but not shown in these figures.
• One scenario is shown. The uncertainty around it is real and not displayed.
• Figures are model output and may differ slightly from published census tables.

html`<p><strong>Source.</strong> PopSyM app contract
<code>${meta.scenario}</code>, ${fmt(meta.n_rows)} rows, built ${meta.built_at}.
Prepared by <code>apps/nepal_population_explorer/prep_data.R</code> from
<code>${meta.source}</code>.</p>
<p><strong>How this page works.</strong> It is a static file. There is no server
and no R process running anywhere. The age-group table is loaded once; the
single-age file for one area is fetched only when you select it. That is why the
page can be hosted for free and cannot be knocked over by traffic.</p>`