Demos ao vivo

Demonstrações interativas no navegador — visualize a estrutura de benchmarks e os resultados de solvers, e execute um solver ao vivo com Python WebAssembly. Sem instalação, sem servidor.

Estes demos rodam inteiramente no seu navegador. A aba Visualize plota evidência de prévia segura-para-o-público — uma tabela de classificação de solvers, gráficos animados de convergência e de exploração–explotação, gráficos de análise de escalabilidade, estabilidade de sementes e robustez, e a caracterização estrutural de qualquer instância de benchmark. A aba Run live executa Python real em uma sandbox WebAssembly (Pyodide): edite o solver e reexecute-o sem instalar nada. A aba Analyze executa um experimento completo com sementes e compara dois solvers com um tamanho de efeito e um intervalo de confiança bootstrap — a mesma disciplina de evidência que o toolkit completo aplica.

Tudo aqui é material de prévia ilustrativo e seguro-para-o-público. O toolkit completo roda os mesmos tipos de benchmarking, resolução, e análise em escala de pesquisa — comece com o início rápido ou navegue pelo catálogo de benchmarks.

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.