Live Demos

Interactive in-browser demonstrations — visualize benchmark structure and solver results, and run a solver live with WebAssembly Python. No install, no server.

These demos run entirely in your browser. The Visualize tab charts public-safe preview evidence — a solver leaderboard, animated convergence and exploration–exploitation charts, scalability, seed-stability, and robustness analysis charts, and the structural characterization of any benchmark instance. The Run live tab executes real Python in a WebAssembly sandbox (Pyodide): edit the solver and re-run it without installing anything. The Analyze tab runs a complete seeded experiment and compares two solvers with an effect size and a bootstrap confidence interval — the same evidence discipline the full toolkit applies.

Everything here is illustrative, public-safe preview material. The full toolkit runs the same kinds of benchmarking, solving, and analysis at research scale — start with the quick start or browse the benchmark catalog.

Solver leaderboard

Best makespan per solver on the smoke benchmark set (lower is better). Bundled demo evidence — not a comparative ranking.

Convergence trajectory

How each iterative solver’s best-so-far objective improves over iterations — the anytime curve.

Per-iteration best-so-far objective for a native iterative cohort on a smoke instance (lower is better) — hover, or focus the chart and use the arrow keys, to read each solver’s incumbent. Public-safe preview from a real seeded run; the full platform traces convergence at research scale.

Exploration–exploitation balance

Population diversity over iterations — high while the search explores, falling as it exploits and converges.

Mean population diversity by iteration for the native population solver on a smoke instance — high while the search explores, falling as it exploits and converges. Hover, or focus the chart and use the arrow keys, to read the diversity. Public-safe preview from a real seeded run.

Scalability (size response)

Makespan across a doubling task-count ladder — how each solver scales as the problem grows.

Makespan across a doubling task-count ladder (16–96 tasks) for a dispatching baseline and a native metaheuristic on one Edge–Fog–Cloud family — reading the size response is the scalability curve a results section reports. Hover, or focus the chart and use the arrow keys, to read each solver’s makespan; the native search holds a slim edge that widens with size. Public-safe preview from real seeded solves.

Seed stability

Coefficient of variation across the seed set — how consistently each solver reaches its result.

Each solver’s seed coefficient of variation (makespan standard deviation over the seed set, divided by the mean) — lower is more stable. A deterministic solver reads zero. Hover or focus a bar to read it. Public-safe aggregate from a seed-replicated smoke campaign.

Robustness (tail risk)

CVaR of the worst per-problem makespan-ratio tail — ranking solvers by deployment-relevant risk, not the mean.

Each solver’s conditional value-at-risk (CVaR) of the worst tail of its makespan ratios (each run’s makespan over the problem’s best across the field) over the seed set — lower is more robust, ranking by deployment-relevant tail risk rather than the mean. Hover or focus a bar to read it. Public-safe aggregate from the same seed-replicated smoke campaign.

Benchmark characterization

Pick an instance to see its structural fingerprint.

Benchmark instance

heterogeneity

1.00

objective conflict

1.00

load skew

0.83

uncertainty

0.67

compatibility sparsity

0.67

opportunity density

0.50

solver sensitivity

0.45

dynamism

0.10

overload

0.04

contention

0.04

communication pressure

0.00

dependency depth

0.00

setup intensity

0.00

Each benchmark is characterized by quantitative metrics in [0, 1]. These structural features are what make the catalog construct-based rather than tag-based.

This runs real Python in your browser via WebAssembly (Pyodide) — no server, no install. It is a light illustrative solver; the full toolkit runs the same kinds of computation at research scale.

solver.py

# A self-contained scheduling scenario that mirrors the toolkit's
# benchmark -> solve -> analyze workflow: generate a heterogeneous instance,
# run three dispatching heuristics, and compare their makespans.
# Edit anything and re-run — it executes in your browser.
import random

random.seed(20260527)  # deterministic, like the toolkit's recorded seeds
n_tasks, n_machines = 9, 3

# Heterogeneous benchmark instance: task i has a different duration per machine.
exec_time = {
    (i, m): random.randint(2, 9)
    for i in range(n_tasks)
    for m in range(n_machines)
}

def makespan(order, pick):
    loads = [0] * n_machines
    for i in order:
        m = pick(i, loads)
        loads[m] += exec_time[(i, m)]
    return max(loads)

lpt = sorted(range(n_tasks), key=lambda i: -min(exec_time[(i, m)] for m in range(n_machines)))
least_loaded = lambda i, loads: min(range(n_machines), key=lambda m: loads[m] + exec_time[(i, m)])

solvers = {
    "min-load-greedy": (range(n_tasks), least_loaded),
    "LPT + min-load":  (lpt,            least_loaded),
    "fastest-machine": (range(n_tasks), lambda i, loads: min(range(n_machines), key=lambda m: exec_time[(i, m)])),
}

results = {name: makespan(order, pick) for name, (order, pick) in solvers.items()}
best = min(results, key=results.get)

print(f"Instance: {n_tasks} tasks x {n_machines} heterogeneous machines\n")
print(f"{'solver':18} makespan")
print("-" * 30)
for name, mk in sorted(results.items(), key=lambda kv: kv[1]):
    print(f"{name:18} {mk:>5}{'   <- best' if name == best else ''}")
print(f"\nBest here: {best}. Capability, not a universal claim — the full")
print("toolkit runs fair, seeded, statistically-compared campaigns.")

Output

Press Run to execute the solver in your browser.

A complete experiment-then-analysis scenario: it runs two solvers across many seeded instances and compares them the way the toolkit reports evidence — with a Cliff’s-delta effect size and a bootstrap confidence interval, never a bare p-value. Runs live in your browser; edit the budget or the solvers and re-run.

experiment.py

# A complete benchmark -> solve -> ANALYZE scenario, reported the way the
# toolkit reports evidence: run two dispatching heuristics across many seeded
# instances, then compare them with an effect size AND a bootstrap confidence
# interval — never a bare p-value. Edit anything and re-run; it runs in your browser.
import random, statistics

SEEDS = 40                    # independent seeded instances (a real run budget)
N_TASKS, N_MACHINES = 12, 3

def instance(seed):
    rng = random.Random(seed)
    return {(i, m): rng.randint(2, 9)
            for i in range(N_TASKS) for m in range(N_MACHINES)}

def makespan(et, order, pick):
    loads = [0] * N_MACHINES
    for i in order:
        m = pick(i, loads, et)
        loads[m] += et[(i, m)]
    return max(loads)

def least_loaded(i, loads, et):
    return min(range(N_MACHINES), key=lambda m: loads[m] + et[(i, m)])

def lpt_order(et):            # longest-processing-time first
    return sorted(range(N_TASKS),
                  key=lambda i: -min(et[(i, m)] for m in range(N_MACHINES)))

A, B = "LPT + min-load", "arrival-order + min-load"
a, b = [], []
for s in range(SEEDS):
    et = instance(20260000 + s)
    a.append(makespan(et, lpt_order(et), least_loaded))
    b.append(makespan(et, range(N_TASKS), least_loaded))

# Cliff's delta: (#(A>B) - #(A<B)) / (n*m). Negative => A tends to be smaller (better).
gt = sum(x > y for x in a for y in b)
lt = sum(x < y for x in a for y in b)
delta = (gt - lt) / (len(a) * len(b))
mag = next(lbl for thr, lbl in
           [(0.147, "negligible"), (0.33, "small"), (0.474, "medium"), (2.0, "large")]
           if abs(delta) < thr)

# Bootstrap 95% CI on the mean paired difference A - B (percentile method).
diffs = [x - y for x, y in zip(a, b)]
boot_rng = random.Random(7)
boot = sorted(statistics.fmean(boot_rng.choices(diffs, k=len(diffs)))
              for _ in range(2000))
lo, hi = boot[int(0.025 * len(boot))], boot[int(0.975 * len(boot)) - 1]

print(f"{SEEDS} seeded instances - {N_TASKS} tasks x {N_MACHINES} machines\n")
print(f"mean makespan  {A:24} {statistics.fmean(a):6.2f}")
print(f"mean makespan  {B:24} {statistics.fmean(b):6.2f}\n")
print(f"Cliff's delta (A vs B):  {delta:+.3f}  ({mag} effect)")
print(f"95% bootstrap CI of mean(A - B):  [{lo:+.2f}, {hi:+.2f}]")
credible = ("excludes 0 - the advantage is statistically credible"
            if (lo < 0) == (hi < 0) else "spans 0 - no credible difference")
print(f"  the interval {credible}.\n")
print("Reported with an effect size AND a confidence interval, never a bare")
print("p-value. The full platform adds Holm-corrected Wilcoxon / Friedman tests")
print("across the whole catalog.")

Output

Press Run to execute the solver in your browser.