Models
The design is tested on models that other people wrote. Each model comes from another framework, kept as its authors wrote it, next to the same model written in Starsim.
The test
A model should never be easier to write without the lingua franca than with it. So each translation is held to two numbers from its original:
- No more lines of model code, not counting imports, comments, blank lines, and plotting.
- No more time for a rerun, measured on the same machine: running the same model again once it is set up, as in a parameter scan or a calibration. First-run times are shown as well, but don’t count toward the mark. A first run includes setup that happens once, so a small model can take tens of milliseconds even when its reruns are much faster.
Results should also agree, within a stated tolerance. Missing any of these doesn’t fail the translation: it is a gap, written up with the model for the design to address. Times are not always like for like: some originals can only be timed as a whole command, and each model’s notes say where that is the case. For modelers who use one of these frameworks, the comparison with other frameworks sums up how Starsim compares with each, and links to a page for each with a model written both ways.
Where each model stands
The model names link to the side-by-side comparison, which shows the original code next to the Starsim version.
| Model | Language | Lines | Time | Results |
|---|---|---|---|---|
| atomica hiv_dyn |
Excel spreadsheets (run from Python) | Original: 217 Starsim: 65 |
Original: first 140 ms, rerun 4.1 ms Starsim: first 32 ms, rerun 0.41 ms (Rust) |
Identical, to rounding error (a largest difference of 1 in 1014), in every compartment and every level of the cascade of both sexes, in all four runs: without programs, and with the default, doubled, and zero budgets |
| atomica sir |
Excel spreadsheets (run from Python) | Original: 62 Starsim: 16 |
Original: first 110 ms, rerun 2.2 ms Starsim: first 10 ms, rerun 0.21 ms (Rust) |
Every compartment identical, to rounding error |
| camdl sir |
camdl | Original: 30 Starsim: 13 |
Original: first 10 ms, rerun 4.7 ms Starsim: first 9.9 ms, rerun 0.25 ms (Rust) |
Agree. Compartments and weekly cases within 0.02% (compare.py asks for 0.1%); Agree. Mean of 200 runs within 0.6% for I and 0.9% for weekly cases, chain-binomial in both, with whole-day steps (compare.py asks for 3% and 4%) |
| camdl stratified |
camdl | Original: 47 Starsim: 16 |
Original: first 20 ms, rerun 12 ms Starsim: first 14 ms, rerun 0.68 ms (Rust) |
Agree. The infectious in every cell within 0.4%, with and without vaccination (compare.py asks for 0.5%, since camdl writes whole numbers, which matters in the smallest cells), and the totals of S, E, and R within 0.1%, apart from the day of the vaccination (finding below); Agree in size, not quite in timing. The peak in every cell is within 2%, but with a step of a day the south’s epidemic rises about a day sooner, so the mean of 200 runs differs by up to 7% of the peak on the way up (compare.py asks for 2% and 8%). The gap is about the two chain-binomial schemes at a coarse step: on 14 October it shrank from 7% to 2% with a quarter-day step |
| emulsion quickstart |
YAML (the EMULSION modeling language) | Original: 280 Starsim: 53 |
Original: first 1.2 s, rerun 1.1 s Starsim: first 330 ms, rerun 220 ms (Numba) |
Do not agree. The mean of 50 runs ends with 55 animals, against 65, and every count of adults is low from early on (finding 1). Up to step 13 the timing is right apart from the quarantine, which starts two steps sooner in EMULSION (finding 5). compare.py asks for 13 animals, so it records this miss and fails if it grows; Do not agree. The quarantine now matches (Q within 1.3), and births come on time, but the herd is still too small: 70 animals against 76 at step 53, and 55 against 65 at step 105 (finding 1) |
| emulsion sir |
YAML (the EMULSION modeling language) | Original: 81 (compartments), 86 (individuals) Starsim: 10 |
Original: first 710 ms, rerun 710 ms Starsim: first 8.5 ms, rerun 0.2 ms (Rust) |
Agree. Mean of 200 runs: a peak of 38 infectious on day 18, against 37 on day 18; 86 recovered at the end, against 85 (compare.py asks for 1.5 and 2 animals). This needs whole-day steps, substeps=1; Agree, within chance. Mean of 200 runs: a peak of 35 on day 18, against 37 on day 19; 79 recovered at the end, against 81, with 21% of runs dying out early, against about 19% (compare.py asks for 3 and 6 animals) |
| epidemics seasonal_scenarios |
R (models written in odin) | Original: 76 Starsim: 24 |
Original: first 50 ms, rerun 9 ms Starsim: first 21 ms, rerun 1.5 ms (Rust) |
Agree to 9.2e-4 of each state’s largest value, in total and in each age group, on every day. I peaks at 2,377,511 on day 275 (original 2,378,561 on day 275). The difference is the original’s: it gives odin the seasonal factor at whole days, and odin interpolates linearly between them. With the same interpolation and steps of a quarter of a day, Starsim agrees to 1e-4 in total. compare.py allows 1e-3; Agree to 8.6e-3 of each state’s largest value. The difference is how overlapping cuts combine: epidemics adds them and Starsim multiplies them (finding 1). With the cuts added by hand, Starsim agrees to 1.6e-3, and its peak is 1,374,560. compare.py allows 1e-2; Agree to 1.4e-3 of each state’s largest value. compare.py allows 2e-3 |
| epidemics seirv |
R (models written in odin) | Original: 36 Starsim: 12 |
Original: first 20 ms, rerun 9 ms Starsim: first 590 ms, rerun 1.1 ms (JAX) |
Agree to 1.4e-7 of each state’s largest value, in total and in each age group, on every day. I peaks at 1,231,054 on day 369 in both, and 23,438,153 people are infected in both. compare.py allows 1e-6 |
| epimodel hiv |
R | Original: 405 Starsim: 56 |
Original: first 44 s, rerun 43 s Starsim: first 2.3 s, rerun 2 s (Rust) |
Agree within the noise of the runs in three scenarios; with no intervention, the epidemic is larger, as before (tolerance: 2.5 percentage points for prevalence, 2 for the care cascade and PrEP; below) |
| epimodel sis-network |
R | Original: 13 Starsim: 9 |
Original: first 5.5 s, rerun 4.7 s Starsim: first 570 ms, rerun 300 ms (Rust) |
Agree, once the order within a step is allowed for (within 5% at equilibrium): 11.7 new infections a step at equilibrium, against 12.0 (means of 100 runs each). Over the last 200 steps 240 of 500 are infected, against 227.5: EpiModel lets people recover in the step in which they are infected and counts them after that, which makes its count 5% lower for the same epidemic (240 × 0.95 = 228). With the same allowance, 118 are infected after step 50, against 113, where the runs vary most |
| epipack siarx_tracing |
Python | Original: 61 Starsim: 16 |
Original: first 870 ms, rerun 480 ms Starsim: first 540 ms, rerun 500 ms (Rust) |
Agree to 2e-6 of the population on every day to day 100; Agree to 1.2e-2 of the population on every day, with steps of 0.1 days against epipack’s continuous time. The largest difference is in S as it falls fastest, about three times the standard error of the difference of the two means; Agree to 1.2e-2 of the population on every day, as on the network |
| epipack sirs |
Python | Original: 37 Starsim: 8 |
Original: first 54 ms, rerun 52 ms Starsim: first 8.5 ms, rerun 0.25 ms (Rust) |
Agree to 6.5e-6 of the population on every day, with a daily RK4 step against epipack’s adaptive solver; Agree to 5.6e-3 of the population on every day, within the error of a mean of 1,000 runs; Agree to 2.1e-2 of the population on every day, with steps of 0.025 days against epipack’s continuous time. The largest difference is in the first days, when the epidemic doubles in about 10 hours |
| epiworld covid_flu |
R | Original: 29 Starsim: 21 |
Original: first 69 ms, rerun 67 ms Starsim: first 18 ms, rerun 0.47 ms (Rust) |
Agree while few are infected, and within 5% after (mean of 1,000 runs each): on days 1 to 5 every mean agrees within three standard errors (725 infected on day 5, against 721). Later the epidemic is larger, as expected from the original’s chance of infection (see below): it peaks on day 11 in both, at 9,296 against 8,899 (+4.5%), the flu peaks on day 9 at 162 against 155, and 26,855 have recovered on day 50, against 26,509 (+1.3%) |
| epiworld seirconn |
R | Original: 12 Starsim: 8 |
Original: first 3.4 ms, rerun 2.5 ms Starsim: first 9 ms, rerun 0.21 ms (Rust) |
Agree (within three standard errors; mean of 1,000 runs each): 398 ± 17 recovered on day 50, against 394, and the infection dies out by day 50 in 22.6% of runs, against 20.8%. Every state agrees on days 10 to 50, and the 95% quantile of the recovered on day 50 is 1,601 against 1,403, 2.1 standard errors apart |
| epydemix covid19 |
Python | Original: 161 Starsim: 43 |
Original: first 34 ms, rerun 34 ms Starsim: first 23 ms, rerun 1.2 ms (Rust) |
Agree (tolerance 3% of the peak). The mean of 200 runs: weekly deaths within 0.7% of the peak (833 against 837, in the same week), and 0.5% and 0.4% in the two reopening scenarios; deaths by age within 3% of the peak in every group from age 40; E, I, R, and D within 0.5%; 10,507 deaths by 2 August against 10,525; Agree (tolerance: each posterior mean inside the original’s 5% to 95% range, and projected peaks within 10%). Posterior means: R0 2.28 (original 2.25), Delta 18.8 days (19.0), I0 4,777 (4,770), and seasonality_min 0.79 (0.80), with similar ranges. Peak weekly deaths projected from the posterior are 891 (897), 1,366 (1,363), and 2,231 (2,217) in the three scenarios. This is a change from before: a point estimate gave much smaller second waves |
| epydemix sir_kenya |
Python | Original: 7 Starsim: 15 |
Original: first 7 ms, rerun 6.5 ms Starsim: first 11 ms, rerun 0.34 ms (Rust) |
Agree (peaks within 1%, a day apart at most, final size within 0.1 of a percentage point): the mean of 100 runs peaks 0.4% higher than the original, a day sooner, and the final size is the same (99.63%). On any one day the difference is up to 6% of the peak, since the rise is a day ahead (see the findings) |
| epymorph pei_humidity |
Python | Original: 22 Starsim: 19 |
Original: first 210 ms, rerun 130 ms Starsim: first 70 ms, rerun 2 ms (Rust) |
Agree to within 3.4% at the peak in each state, 3 days in its timing, and 0.9% in the number infected. Florida, where it starts, peaks on day 59 in both; the other states peak 1 to 3 days earlier in Starsim, for the reason given for the SIRS in Arizona |
| epymorph sirs_centroids |
Python | Original: 29 Starsim: 10 |
Original: first 410 ms, rerun 320 ms Starsim: first 16 ms, rerun 4 ms (Rust) |
Agree to within 8% at the peak in each county, and 5 days in its timing; 1.0% in the number recovered. Starsim is 1 to 5 days early in every county; see the findings |
| flepimop seir_2pop |
YAML (a flepiMoP configuration) | Original: 42, plus 10 lines of CSV Starsim: 15 |
Original: first 8 s, rerun 7.7 s Starsim: first 13 ms, rerun 0.38 ms (Rust) |
Agree exactly (tolerance 1e-6 people): every compartment in both provinces, on every day, within 3e-12 people |
| flepimop vaccine_scenarios |
YAML (a flepiMoP configuration) | Original: 141, plus 10 lines of CSV Starsim: 33 |
Original: first 21 s, rerun 21 s Starsim: first 770 ms, rerun 330 ms (Numba) |
Agree exactly, by province (tolerance 1e-9). Run with the values of Ro and of the share of cases detected that the original drew, the mean, 5%, and 95% of all 28 series in each province (5 compartments, 5 incidences, and the 4 outcomes, including the number in hospital) agree within 1e-9 of their largest value in all three scenarios; Agree in distribution (tolerance 30%, since the original has only ten runs, drawn afresh each time it is run). With 100 runs of each scenario, the mean peak of I in the large province is 1,099, 466, and 17 (original, from 10 runs: 1,103, 482, and 15), and the mean deaths are 89.0, 60.0, and 2.2 (88.8, 60.6, and 1.9) |
| LASER england_wales |
Python (Jupyter notebook) | Original: 126 Starsim: 46 |
Original: first 3.7 s, rerun 2.6 s Starsim: first 100 s, rerun 100 s (Rust) |
Agree. Over the 10 years, 107,761 infections against 106,639 (+1.1%; means of 3 and 50 runs, where compare.py now makes the last two of the three to keep the benchmark short; the three Starsim runs are 106,611, 106,913, and 109,760, against the original’s 5% to 95% range of 103,139 to 108,758); in each of seven places from Norwich to Southwold within 3%, except the smallest, Southwold, at +12%; 537,442 people at the end against 529,833 (+1.4%, finding 1). The share of weeks with no infections in each place, in the second half, is 0.631 against 0.628, and correlates at 0.985 across places. compare.py allows 5% in total, 20% in a place, 2% in people at the end, and 0.03 in the share of weeks |
| LASER hub_spoke_seir |
Python | Original: 50 Starsim: 17 |
Original: first 2.2 s, rerun 1 s Starsim: first 720 ms, rerun 610 ms (Numba) |
Agree. As agents, the means of 6 Starsim runs and 20 LASER runs: 1,529,575 recovered at the end, against 1,532,298, and within 0.5% in each place shown; peaks within 5% in size and 9 days in time. As an ODE: 1,532,507 recovered, peaks within 5% in size and 8 days in time. compare.py allows 2%, 15%, and 10 days. |
| measles metapopulation seir_districts |
Python | Original: 89 Starsim: 22 |
Original: first 820 ms, rerun 810 ms Starsim: first 440 ms, rerun 390 ms (Rust) |
Agree. Over 2010 to 2025, 1,734,028 infections against 1,740,643 and 17,325 reported cases against 17,396 (means of 50 runs each); monthly means correlate at 0.999 and 0.998; infections from 2020 in each of the 16 regions within 6% (compare.py asks for totals within 2%, each year within 20%, a correlation over 0.98, regions within 20%, and S and R at the end within 3%) |
| memilio secir |
Python (bindings to C++) | Original: 44 Starsim: 14 |
Original: first 0.41 ms, rerun 0.02 ms Starsim: first 13 ms, rerun 0.47 ms (Rust) |
Agree. Within 67 people of 83,000 at every time, which is the error of the reference itself (it is interpolated between steps of about two days); deaths within 0.5, of which 0.4 is the reference’s error (it remains with a step of 0.01 days) and 0.12 is Starsim’s daily step. compare.py allows 73 people and 0.6 deaths |
| memilio secir_ageres |
Python (bindings to C++) | Original: 45 Starsim: 22 |
Original: first 0.77 ms, rerun 0.06 ms Starsim: first 19 ms, rerun 0.67 ms (Rust) |
Agree. Within 1.5 people of 10,000 at every time (1.3 in Susceptible, 1.5 in Recovered), the same with a step of a day or a tenth of a day, which is the error of the reference itself (it is interpolated between solver steps); deaths within 0.02. compare.py allows 1.6 people and 0.02 deaths |
| odin seir_array |
R (the odin modeling language) | Original: 53 Starsim: 18 |
Original: first 710 ms, rerun 1.4 ms Starsim: first 19 ms, rerun 3.2 ms (Rust) |
Agree. S, E, I, and R within 0.23%, 0.36%, 0.25%, and 0.15% of their largest values on every day (a quarter of that with a step of half a day), and I peaks at 6.19 million on day 125, as in the original. It needs the workaround of finding 1: without it the epidemic peaks 15 days late. compare.py allows 0.5%; Agree, except in the youngest group, where E, I, and R differ by up to 15%, 5%, and 8%. The original’s delay does not let the latent age (finding 2); Starsim’s does. compare.py allows 1% in the other groups |
| odin stochastic_sir_arrays |
R (the odin modeling language) | Original: 27 Starsim: 11 |
Original: first 650 ms, rerun 0.95 ms Starsim: first 13 ms, rerun 0.91 ms (Rust) |
Agree. The mean of 20,000 replicates is within 6.1 people of 1,001 at every time, against the original’s 20,000 replicates; 44.8% die out. compare.py allows 12 people, three standard errors of the difference |
| pandemic_simulator ebola_legrand |
Python | Original: 306 Starsim: 30 |
Original: first 310 ms, rerun 5.8 ms Starsim: first 20 ms, rerun 1.1 ms (Rust) |
Agree to 2.9e-6 of the population on every day, with a daily RK4 step against an adaptive solver; Agree to 1.9e-4 of the population, or 3.1e-7 with the original in float64 (JAX_ENABLE_X64=1), where it leaves 179,407. See the findings for the difference |
| pandemic_simulator sir_reactive |
Python | Original: 99 Starsim: 8 |
Original: first 230 ms, rerun 4.6 ms Starsim: first 10 ms, rerun 0.38 ms (Rust) |
Agree to 1.2e-5 of the population on every day (6 people in I), with a daily RK4 step against an adaptive solver; Agree to 1.7e-3 of the population. The difference is when the threshold is noticed: Starsim reads it at each stage of its daily step, and the original within its adaptive step; Consistent: inside the original’s 95% band on every day. The original’s draws have no seed, so two of its runs differ by this much |
| siminf sir_herds |
R | Original: 12 Starsim: 21 |
Original: first 170 ms, rerun 75 ms Starsim: first 270 ms, rerun 140 ms (Rust) |
Agree. The mean of 200 runs (compare.py now makes 100, to keep the benchmark short) is within three standard errors (at most 2.7) of the original’s mean of 200 at every day checked, for the totals, the number of herds infected, and the first herd, including the total susceptible on day 100, where little else varies (199,901 ± 3 against 199,906). The infection dies out early in 4% of runs (7% in the original), so it takes about 200 runs to compare the means: 20 runs can easily have none of these runs, and then differ a lot |
| siminf sise3 |
R (and C, for the built-in model) | Original: 27 Starsim: 39 |
Original: first 280 ms, rerun 89 ms Starsim: first 760 ms, rerun 510 ms (Rust) |
Agree, within a herd, between herds, and in the demography. With 100 runs (compare.py now makes 50, to keep the benchmark short, and allows the same three standard errors), every series is within two standard errors of the difference from SimInf’s mean on every day checked (three is the tolerance), and 81% to 97% of the runs are inside SimInf’s 5% to 95% range for every series on every day. On day 1,457 the mean of 100 runs has 181 ± 13 herds infected (SimInf: 166, range 24 to 352) and 4,175 ± 309 animals (3,770; 519 to 8,138). The spread between herds runs a little high on every day (175 herds in 200 runs), within the noise, so a small difference there cannot be ruled out |
| summer2 seir-age-clinical |
Python | Original: 134 (55 for the model alone) Starsim: 16 |
Original: first 2.8 s, rerun 0.29 ms Starsim: first 14 ms, rerun 0.53 ms (Rust) |
Every compartment within 0.0006 people of 1,000; every derived output within 0.006% of its peak. From the same start, the stratified model and the same model written as four states (as_states() in compare.py) agree to 2e-14 people; At time 20 the mean of 100 stochastic runs has 542 ± 9 recovered and of 100 agent-based runs 547 ± 10, against 580 in the ODE, since the epidemic is still under way and runs take off at different times. No run died out. By time 100 they end with 848 recovered, as does the ODE (847) |
| summer2 sir-age-location |
Python | Original: 35 Starsim: 12 |
Original: first 780 ms, rerun 0.22 ms Starsim: first 12 ms, rerun 0.43 ms (Rust) |
Every compartment within 0.08 people of 1,000; The stochastic and agent-based runs give the same number recovered as the ODE, to within 1% (mean of 100 runs) |
Times under each set of kernels
Starsim can run a model with its Rust, Numba, or JAX kernels. The table above gives the fastest rerun of each model, which is in bold here. Times are in seconds, and a blank means that model can’t use those kernels, for example because it runs as agents.
| Model | Rust: first | Rust: rerun | Numba: first | Numba: rerun | JAX: first | JAX: rerun | JAX on a GPU: first | JAX on a GPU: rerun |
|---|---|---|---|---|---|---|---|---|
| atomica/hiv_dyn | 0.032 | 0.00041 | 0.1 | 0.0023 | 0.58 | 0.0023 | 2.2 | 0.0039 |
| atomica/sir | 0.01 | 0.00021 | 0.075 | 0.00096 | 0.46 | 0.0004 | 0.91 | 0.002 |
| camdl/sir | 0.0099 | 0.00025 | 0.076 | 0.00093 | 0.54 | 0.00044 | 1.3 | 0.0078 |
| camdl/stratified | 0.014 | 0.00068 | 0.18 | 0.0037 | 1.8 | 0.0023 | 2.8 | 0.034 |
| emulsion/quickstart | 0.23 | 0.22 | 0.33 | 0.22 | ||||
| emulsion/sir | 0.0085 | 0.0002 | 0.07 | 0.00077 | ||||
| epidemics/seasonal_scenarios | 0.021 | 0.0015 | 0.31 | 0.052 | 1.2 | 0.052 | 3.5 | 0.11 |
| epidemics/seirv | 0.03 | 0.0013 | 0.31 | 0.0021 | 0.59 | 0.0011 | 2.5 | 0.062 |
| epimodel/hiv | 2.3 | 2 | 2.4 | 2 | ||||
| epimodel/sis-network | 0.57 | 0.3 | 0.63 | 0.37 | ||||
| epipack/siarx_tracing | 0.54 | 0.5 | 0.64 | 0.52 | ||||
| epipack/sirs | 0.0085 | 0.00025 | 0.18 | 0.0004 | 0.99 | 0.00046 | 2.4 | 0.0063 |
| epiworld/covid_flu | 0.018 | 0.00047 | 1.4e+02 | 0.00071 | ||||
| epiworld/seirconn | 0.009 | 0.00021 | 0.16 | 0.00041 | ||||
| epydemix/covid19 | 0.023 | 0.0012 | 0.11 | 0.0027 | 0.15 | 0.0028 | 0.14 | 0.0026 |
| epydemix/sir_kenya | 0.011 | 0.00034 | 0.19 | 0.0026 | ||||
| epymorph/pei_humidity | 0.07 | 0.002 | 0.22 | 0.003 | ||||
| epymorph/sirs_centroids | 0.016 | 0.004 | 0.16 | 0.0061 | ||||
| flepimop/seir_2pop | 0.013 | 0.00038 | 0.082 | 0.0012 | 0.68 | 0.0005 | 2.2 | 0.0095 |
| flepimop/vaccine_scenarios | 0.61 | 0.33 | 0.77 | 0.33 | 1.1 | 0.33 | 3.2 | 0.67 |
| laser/england_wales | 1e+02 | 1e+02 | 13 | 13 | ||||
| laser/hub_spoke_seir | 0.63 | 0.63 | 0.72 | 0.61 | ||||
| measles_metapop/seir_districts | 0.44 | 0.39 | 0.69 | 0.56 | ||||
| memilio/secir | 0.013 | 0.00047 | 0.083 | 0.0016 | 0.57 | 0.00062 | 1 | 0.012 |
| memilio/secir_ageres | 0.019 | 0.00067 | 0.087 | 0.0015 | 1 | 0.0021 | 2.3 | 0.011 |
| odin/seir_array | 0.019 | 0.0032 | 0.086 | 0.0056 | 1.9 | 0.023 | 4.6 | 0.097 |
| odin/stochastic_sir_arrays | 0.013 | 0.00091 | 0.33 | 0.019 | ||||
| pandemic_simulator/ebola_legrand | 0.02 | 0.0011 | 0.096 | 0.0023 | 0.78 | 0.0017 | ||
| pandemic_simulator/sir_reactive | 0.01 | 0.00038 | 0.075 | 0.00086 | 0.84 | 0.00053 | ||
| siminf/sir_herds | 0.27 | 0.14 | 0.53 | 0.31 | ||||
| siminf/sise3 | 0.76 | 0.51 | 1.6 | 1.2 | ||||
| summer2/seir-age-clinical | 0.014 | 0.00053 | 0.076 | 0.0013 | 0.99 | 0.0023 | 2.4 | 0.022 |
| summer2/sir-age-location | 0.012 | 0.00043 | 0.079 | 0.0012 | 0.55 | 0.00056 | 2.7 | 0.018 |
Measured on 2026-11-09 with Starsim 4.0.0rc3 (commit be38b9f6) on a 20-core Linux machine, using each set of kernels’ default threads. Those not in benchmark/kernels.yaml were last timed on 2026-11-03. Compiling the Numba kernels, needed once per install, took 315 s; the Rust kernels are built when Starsim is installed.
To regenerate these results, see the benchmark.
What is in each folder
Each model has the original source, where it came from and its license, reference results from running it, and its line count and run time. Next to these are the Starsim version, a script that checks it against the reference results, and notes on what was awkward or could not be expressed.
How the models were chosen
The models are chosen to span frameworks and paradigms, and each framework’s own showcase models are preferred over ones written for this project. They are brought in as a build set and held-out waves, described in about the models.
Of the 24 frameworks reviewed, 16 have models here. The measles metapopulation model is here too, though it isn’t a framework. Each of the others is left out because its models are already covered by one that is, or because a translation would test something other than how a model is written.
| Framework | Models here | Why |
|---|---|---|
| Atomica | hiv_dyn, sir |
Held-out wave 1: the strongest non-programmer specification path, in spreadsheets |
| camdl | sir, stratified |
Held-out wave 1: the closest existing thing to the target design |
| EMULSION | quickstart, sir |
Held-out wave 1: one model run as compartments, agents, or both |
| epidemics | seasonal_scenarios, seirv |
Added after the waves: a library of fixed models, composed into scenarios with elements |
| EpiModel | hiv, sis-network |
Held-out wave 1: the most widely used framework in R, and the network models |
| epipack | siarx_tracing, sirs |
Added after the waves: one model run as ODEs, by Gillespie’s method, and on a network, plus contact tracing |
| epiworld | covid_flu, seirconn |
Added after the waves: several viruses and protective tools carried by the same agents |
| Epydemix | covid19, sir_kenya |
Held-out wave 1: named in the project brief as an interconversion target |
| epymorph | pei_humidity, sirs_centroids |
Added after the waves: disease, movement, and geography as separate parts |
| flepiMoP | seir_2pop, vaccine_scenarios |
Held-out wave 1: models as configuration files, at production scale |
| LASER | england_wales, hub_spoke_seir |
Held-out wave 1: IDM’s other agent-based engine, and the speed comparison for large ABMs |
| MEmilio | secir, secir_ageres |
Held-out wave 1: the library that spans the most paradigms |
| odin | seir_array, stochastic_sir_arrays |
Held-out wave 1: the best-established equations-as-code approach |
| Pandemic Simulator | ebola_legrand, sir_reactive |
Added after the waves: a published platform of ready-made models |
| SimInf | sir_herds, sise3 |
Held-out wave 1: compartments, metapopulations, and networks in one small vocabulary |
| summer2 | seir-age-clinical, sir-age-location |
Held-out wave 1: the most developed answer to stratification |
| Starsim | None | Starsim is what is being tested. Its own models (Covasim, HPVsim, STIsim, and the rest) are reviewed against v4 separately, in tests/reviews/ |
| MetaCast | None | No longer maintained; its metapopulation ODEs are covered by summer2, flepiMoP, and MEmilio |
| EoN | None | Network SIR and SIS, which EpiModel’s network model already covers; what EoN adds is its analytic approximations, which aren’t a model to translate |
| individual | None | A low-level toolkit with no disease concepts: its users write the model from scratch, so there is no showcase model of its own to translate |
| EMOD | None | A model is several large JSON files for a C++ engine, so a translation would mostly test the mapping of its parameters, not how a model is written |
| EpiHiper | None | Its models run on synthetic national contact networks, which aren’t available to rerun here |
| Vivarium | None | Its models are whole microsimulations built from many components and data files, not models to translate on their own |
| Thanzi La Onse | None | A whole health-system model, too large to translate as one model here; rebuilding it on Starsim v4 is a separate piece of work (see admin/deferred.md) |
Each of the frameworks with brief notes is left out too, since those notes are about one idea from each, not its models.