Coming from R-INLA

A side-by-side reference for users coming from R-INLA. Every R-INLA family, f(model = ...), prior, integration strategy, and post-fit accessor that the Julia ecosystem currently supports has a row here, with the Julia constructor a user would type and (where applicable) the @lgm formula-DSL analogue.

If you'd rather start from a worked example, the formula-DSL tutorial walks through Scotland BYM2 and Meuse SPDE end-to-end. This page is the lookup reference you keep open next to a translation in progress.

Likelihoods

R-INLA's family = "..." string maps to a Julia <Likelihood>() constructor. The @lgm column is what you'd write inside @lgm y ~ ... family = ....

The zero-inflated * stands for Poisson, Binomial, or NegativeBinomial. The three suffixes match R-INLA's three zero-inflation parameterisations.

censoring is an (int_left, int_right) pair per observation; pass nothing for fully observed data.

Latent components

R-INLA's f(idx, model = "...") becomes a struct constructor in Julia. Inside @lgm, the same struct is passed positionally to f().

For BYM2, the precision graph wraps R-INLA's W matrix: GMRFGraph(W) from GMRFs.jl builds the adjacency structure once and the component reuses it. The α keyword on BYM2 controls the PC prior on φ; the default matches R-INLA's recommended setting.

Hyperpriors

R-INLA expresses priors via hyper = list(prec = list(prior = "...", param = ...)). In Julia each prior is a struct passed to the component or likelihood that owns the hyperparameter.

Worked priors

BYM2 — PC prior on precision and φ

R-INLA:

f(area, model = "bym2", graph = W,
  hyper = list(prec = list(prior = "pc.prec", param = c(1, 0.01)),
               phi  = list(prior = "pc",      param = c(0.5, 2/3))))

Julia:

BYM2(GMRFGraph(W);
     hyperprior_prec = PCPrecision(1.0, 0.01),
     U = 0.5, α = 2/3)

The φ prior is parameterised via the PC-mixing-weight construction (Riebler et al. 2016): P(φ < U) = α. R-INLA exposes this through the phi hyper entry; Julia exposes the same through the U and α keyword arguments on BYM2(...).

RW2 — PC prior on smoothing precision

R-INLA:

f(t, model = "rw2",
  hyper = list(prec = list(prior = "pc.prec", param = c(1, 0.01))))

Julia:

RW2(T; hyperprior = PCPrecision(1.0, 0.01))

The PC prior is on the precision; the user-scale interpretation is "a marginal SD greater than 1 has 1% prior probability."

SPDE2 — PC-Matérn joint prior

R-INLA:

spde <- inla.spde2.pcmatern(mesh,
                            prior.range = c(0.5, 0.5),
                            prior.sigma = c(1.0, 0.01))
f(field, model = spde)

Julia:

SPDE2(mesh; pc = PCMatern(range_U = 0.5, range_α = 0.5,
                          sigma_U = 1.0, sigma_α = 0.01))

PCMatern is the joint PC prior on the Matérn range ρ and marginal SD σ (Fuglstad et al. 2019). The four arguments mean: P(ρ < range_U) = range_α and P(σ > sigma_U) = sigma_α.

Inference flags

inla(model, y; kwargs...) is the Julia analogue of R-INLA's inla(formula, family, data, control.inla = ...).

The Julia API splits R-INLA's monolithic control.compute into post-fit accessor functions: nothing is computed at fit time beyond the marginals, and you call exactly the diagnostics you need. This also means cross-validation diagnostics that need posterior samples take an explicit rng::AbstractRNG argument — Julia's RNG state is never global in this ecosystem.

Accessors

R-INLA returns a list with $summary.fixed, $summary.random, $summary.hyperpar, $mlik, $dic, $waic, $cpo. Julia returns an INLAResult and gives one accessor per concern.

fixed_effects, random_effects, and hyperparameters return a vector of named tuples with .name, .mean, .sd, .lower, .upper, where level controls the credible-interval coverage.

Sampling

R-INLA's inla.posterior.sample(n, res, ...) becomes posterior_sample(rng, res, model; n_samples = n). The Julia version returns a NamedTuple (x, θ) of Matrix{Float64}s — x is the latent field samples (rows = latent dim, cols = samples), θ is the hyperparameter samples.

using Random
rng = Xoshiro(20260506)
res = inla(model, y)
draws = posterior_sample(rng, res, model; n_samples = 1000)

# Posterior on a contrast of two random-effect levels:
contrast = draws.x[i, :] .- draws.x[j, :]
quantile(contrast, [0.025, 0.5, 0.975])

To sample at new observation points (R-INLA's predict.inla-style workflow), use posterior_predictive(rng, res, model, A_new) with a new observation mapping or matrix A_new. To draw y_new from the likelihood given posterior η, use posterior_predictive_y(rng, res, model).

Prediction

R-INLA exposes prediction through stacking NA rows into the design matrix and reading them back from res$summary.linear.predictor. Julia keeps the original fit clean and provides explicit prediction endpoints.

Raster prediction has its own vignette (Meuse SPDE) walking through the full INLA fit → posterior raster pipeline.

SPDE-specific glue

R-INLA wraps the SPDE setup in inla.spde2.matern / inla.spde2.pcmatern and the projector in inla.spde.make.A; Julia exposes each step explicitly so users can mix mesh, projector, and observation mapping freely.

The mesh + SPDE component pieces compose into a LatentGaussianModel the same way as any other component:

mesh = inla_mesh_2d(loc; max_edge = 0.1, cutoff = 0.05)
spde = SPDE2(mesh; pc = PCMatern(range_U = 0.5, range_α = 0.5,
                                  sigma_U = 1.0, sigma_α = 0.01))
A_field = MeshProjector(mesh, loc) |> as_matrix
A = hcat(ones(n_obs), x_cov, A_field)
model = LatentGaussianModel(GaussianLikelihood(),
                             (Intercept(), FixedEffects(1), spde), A)
res = inla(model, y)

NUTS triangulation

R-INLA does not provide a built-in HMC sampler; users typically re-fit in Stan or NIMBLE for a sanity check. Julia ships LGMTuring.jl, which evaluates LogDensityProblems on the same LatentGaussianModel and runs NUTS via AdvancedHMC over the same hyperparameter posterior:

using LGMTuring
chain = nuts_sample(model, y, 1000;
                    n_adapts = 200, init_from_inla = inla(model, y))
diff = compare_posteriors(inla(model, y), chain; model = model)

compare_posteriors returns a side-by-side row per hyperparameter with flagged = true when the posterior summaries disagree beyond configurable tolerances. This is the load-bearing tier-3 validation that ships nightly in CI.

Things R-INLA does that we don't (yet)

The Julia ecosystem is a strict subset of R-INLA's surface. The following land in v1.x or later:

• Spatial models on the sphere. R-INLA's inla.spde2.matern(mesh, B.tau, B.kappa, alpha = 2) on a spherical mesh ships through ADR-031; Julia tracks this in packages/INLASPDE.jl/plans/plan.md as a v0.3+ item.
• 3D SPDE. Brain-connectivity / subsurface workflows. Tracked in the same plan as spherical SPDE.
• Non-separable space-time SPDE. The separable case (KroneckerComponent) ships in Phase M; Lindgren et al.'s 2024 non-separable generalisation is M+1 territory.
• Fractional-α SPDE. Bolin-Kirchner 2020 rational approximation for non-integer α. Deferred to v0.2.1+ (ADR-030).
• inla.qsample raw GMRF sampling without conditioning on data. Use GMRFs.jl directly — sample from a GMRF via rand(rng, gmrf) after constructing the precision matrix.
• po (probability ordinate). A future Phase K addition.

If you hit a gap not in this list, file an issue at HaavardHvarnes/INLA.jl/issues — the v1.x backlog is shaped by user reports.