A suite of 11 open-source Shiny apps for impact evaluation, poverty analysis, program design, and data exploration. Built for researchers, practitioners, and students working in global development.
Organized into four categories spanning the full lifecycle of development economics work.
Compute sample size, statistical power, and minimum detectable effect size for randomized controlled trials. Supports cluster randomization and multiple treatment arms with ICC adjustment.
Simulate difference-in-differences designs with OLS output, event-study coefficient plots, and automatic parallel trends violation detection.
Explore sharp and fuzzy regression discontinuity designs with local polynomial estimation, McCrary manipulation testing, and bandwidth sensitivity analysis.
Visualize the synthetic control method with constrained optimization, in-space and in-time placebo tests, gap plots, and pre-treatment fit diagnostics.
Calculate the Gini coefficient, Theil index, and Palma ratio from generated or uploaded distributions. Compare distributions side by side with interactive Lorenz curves.
Explore the Multidimensional Poverty Index using the Alkire-Foster method. Radar charts, decomposition by dimension, and sensitivity analysis to the poverty cutoff (k).
Compute FGT(0), FGT(1), FGT(2) and Watts indices against World Bank international poverty lines. Simulate pro-poor growth and redistribution scenarios.
Build interactive ToC diagrams with sector templates for Education, Health, Livelihoods, and WASH. Auto-generates narrative descriptions and exportable summaries.
Calculate NPV, BCR, and IRR with tornado diagrams and Monte Carlo simulation. Includes a cost-effectiveness tab benchmarked against GiveWell thresholds.
Build logical frameworks with editable matrices, indicator tracking with progress bars, results chain visualization, and HTML/CSV export.
Explore 15 key development indicators across 50 countries and 6 regions using World Bank WDI data. Time series, cross-country scatter plots, regional comparisons, and downloadable data tables.
Clone the repo and run any app locally in under two minutes. No API keys or external datasets required.
6 apps built with Python Shiny. Each has its own requirements.txt.
# Clone the repository
git clone https://github.com/Varnasr/deveconomics-toolkit.git
cd deveconomics-toolkit
# Pick any Python app
cd python-shiny/rct-power-calculator
# Create a virtual environment (recommended)
python -m venv .venv
source .venv/bin/activate
# Install dependencies and run
pip install -r requirements.txt
shiny run app.pyOpens at http://127.0.0.1:8000
5 apps built with R Shiny. Standard CRAN packages.
# Install R dependencies (once)
install.packages(c(
"shiny", "ggplot2", "dplyr",
"tidyr", "DT"
))
# Run any R app
shiny::runApp("r-shiny/rdd-explorer")Or from the terminal:
cd r-shiny/rdd-explorer
Rscript -e "shiny::runApp('.')"Opens at http://127.0.0.1:3838 (or the port R assigns)
Expand any app below for full usage instructions, inputs, outputs, and methodological notes.
Computes the required sample size, statistical power, or minimum detectable effect (MDE) for two-arm and multi-arm randomized controlled trials — the workhorse design in development economics.
Uses the standard normal approximation for power analysis. For cluster RCTs, applies the design effect formula: DE = 1 + (m - 1) × ICC, where m is the cluster size. Multi-arm trials apply a Bonferroni correction to the significance level.
cd python-shiny/rct-power-calculator
pip install -r requirements.txt && shiny run app.pyGenerates synthetic panel data and estimates difference-in-differences models with full regression output. Designed to help students and practitioners build intuition for the assumptions behind DiD.
Implements the canonical two-way fixed effects estimator: Y = α + β₁Treat + β₂Post + δ(Treat × Post) + ε. The event-study specification replaces the single post indicator with period-specific dummies.
cd python-shiny/did-simulator
pip install -r requirements.txt && shiny run app.pyInteractive tool for exploring sharp and fuzzy RD designs. Visualize the discontinuity, test for manipulation, and assess sensitivity to bandwidth and polynomial order.
Sharp RDD estimates the LATE at the cutoff using local polynomial regression. Fuzzy RDD instruments actual treatment with the assignment indicator (2SLS). McCrary test checks for bunching at the cutoff.
Rscript -e "shiny::runApp('r-shiny/rdd-explorer')"Implements the synthetic control method for comparative case studies where a single unit receives treatment. Constructs a weighted combination of donor units that approximates the treated unit's pre-treatment trajectory.
Solves a constrained optimization problem to find non-negative donor weights that minimize pre-treatment RMSPE. Placebo tests assess whether the estimated gap is unusually large relative to placebo gaps. Based on Abadie, Diamond & Hainmueller (2010).
cd python-shiny/synthetic-control
pip install -r requirements.txt && shiny run app.pyCalculate and visualize inequality measures from income or expenditure distributions. Compare two distributions side by side to see how policy interventions or structural changes affect inequality.
Rscript -e "shiny::runApp('r-shiny/gini-lorenz')"Explore multidimensional poverty using the Alkire-Foster counting approach. Understand how the choice of dimensions, indicators, weights, and the poverty cutoff (k) affect who is identified as poor.
Implements Alkire & Foster (2011). Each household is assigned a deprivation score across weighted indicators. Those whose score exceeds k are identified as multidimensionally poor. The MPI decomposes into incidence (H) and intensity (A).
cd python-shiny/mpi-explorer
pip install -r requirements.txt && shiny run app.pyAnalyze poverty using the Foster-Greer-Thorbecke family of indices against international and custom poverty lines. Simulate how economic growth and redistribution affect poverty outcomes.
Implements Foster, Greer & Thorbecke (1984): FGT(α) = (1/n) ∑ [(z - yᵢ)/z]𝑞 for yᵢ < z. Higher α gives more weight to the poorest. The Watts index uses the log ratio: W = (1/n) ∑ ln(z/yᵢ).
Rscript -e "shiny::runApp('r-shiny/poverty-line-analysis')"Build interactive Theory of Change diagrams for development programs. Start from sector-specific templates or build from scratch. Generates visual diagrams and narrative summaries ready for donor proposals.
cd python-shiny/theory-of-change
pip install -r requirements.txt && shiny run app.pyA comprehensive CBA/CEA calculator for development projects. Computes standard investment metrics, runs sensitivity analysis, and benchmarks cost-effectiveness against GiveWell thresholds.
cd python-shiny/cost-benefit-analysis
pip install -r requirements.txt && shiny run app.pyBuild and manage logical frameworks for development projects with editable matrices, progress tracking, and sector-specific templates aligned with major donor requirements.
Rscript -e "shiny::runApp('r-shiny/logframe-builder')"Explore World Bank development data with interactive visualizations. Compare countries and regions across key indicators spanning economic growth, health, education, and infrastructure.
Rscript -e "shiny::runApp('r-shiny/wdi-dashboard')"Each app is self-contained and can be deployed independently to any of these platforms.
| Platform | Best For | How |
|---|---|---|
| shinyapps.io | R Shiny apps — free tier available | rsconnect::deployApp("r-shiny/rdd-explorer") |
| Hugging Face Spaces | Python Shiny apps — free CPU instances | Create a Space with Docker SDK, copy the app directory |
| Shinylive (WASM) | Python apps — runs entirely in the browser | shinylive export app.py site/ |
| Posit Connect | Enterprise deployment for R + Python | Follow Posit Connect documentation |
| Docker | Any app — portable containers | Dockerfile per app (see repo) |
| Your website | Embed deployed apps via iframe | <iframe src="https://app-url" width="100%" height="800"></iframe> |
Built on well-supported, production-ready frameworks.
Modern reactive web apps in Python, deployable as Shinylive for zero-server client-side execution via WebAssembly.
The original reactive framework for statistical computing, with deep integration into R's visualization and data analysis ecosystem.
All apps generate synthetic data for demonstration — no external API calls or datasets required.
The methods behind these tools come from the development economics canon.