language

Neutron Julia

Scientific computing with DifferentialEquations.jl, ModelingToolkit, CUDA kernels, and FMI interop — wired to Nucleus so your simulations persist like real data.

Where the equations live.

Available

DiffEqSolver Bindings

CUDAGPU Kernels

FMI 3.0Model Exchange

14Data Models

Science, with the plumbing already done.

Julia is the best language on the planet for numerical computing — C speed, LLVM codegen, multiple dispatch that makes solvers composable in a way static languages can't touch. What it doesn't have is a story for persistence, deployment, and integration with the rest of your stack. Neutron Julia is that story: a typed Nucleus client, first-class DifferentialEquations.jl bindings, ModelingToolkit helpers, and CUDA kernels that don't need a separate toolchain.

src/lorenz.jl
using Neutron
using DifferentialEquations

function lorenz!(du, u, p, t)
    σ, ρ, β = p
    du[1] = σ*(u[2]-u[1])
    du[2] = u[1]*(ρ-u[3]) - u[2]
    du[3] = u[1]*u[2] - β*u[3]
end

u0 = [1.0, 0.0, 0.0]
prob = ODEProblem(lorenz!, u0, (0.0, 100.0), (10.0, 28.0, 8/3))
sol  = solve(prob, Tsit5(), saveat=0.01)

db = Neutron.connect(ENV["DATABASE_URL"])
series = Neutron.timeseries(db, "lorenz_runs")
for (t, u) in zip(sol.t, sol.u)
    push!(series, (t=t, x=u[1], y=u[2], z=u[3]))
end
Solve Lorenz ODEs, store the trajectory in Nucleus time-series.

Nucleus native

Typed client for all 14 data models over pgwire. Persist trajectories as time-series, vectors as vectors, graphs as graphs — no ORM adapter in between.

DifferentialEquations.jl

First-class bindings to the best ODE/SDE/DAE/DDE/PDE solver ecosystem in any language. Adaptive timestepping, event handling, auto-differentiation.

ModelingToolkit

Symbolic-numeric modeling with automatic simplification, index reduction, and code generation. Write physics, get fast solvers for free.

CUDA kernels

CUDA.jl integration for GPU numerics. Write kernels in Julia, compile to PTX, no C++ required. Same code runs on CPU with Threads.jl.

FMI 2.0 / 3.0

Import FMUs from Modelica, Simulink, or any FMI-compliant tool. Co-simulation and model exchange. Digital twins connect to real data.

Package extensions

Flux, Graphs, DataFrames, Makie, and CUDA are optional extensions. Import what you need; Julia's package extensions system loads them lazily.

The scientific workflow, end to end.

The cycle is always the same: define the model, solve, persist, analyze, visualize. Neutron Julia keeps each step in one process with one database.

The pipeline

Define

ModelingToolkit symbolic models

Solve

DifferentialEquations.jl, CUDA-accelerated

Persist

Nucleus time-series + blob + SQL

Analyze

DataFrames + statistics + graphs

Visualize

Makie plots served via Neutron TypeScript

What it's for

Scientific simulations with persistent state. Climate models, financial models, population dynamics, digital twins backed by a real time-series database. ML-adjacent numerics that need CUDA but don't fit Python's asyncio. Research pipelines where Julia's speed meets Neutron's infrastructure.

Why Julia?

Because it compiles through LLVM to native code and hits C speed on numerical workloads. Because multiple dispatch makes solvers composable in a way monkey-patching and inheritance can't match. Because the same function runs on CPU, GPU, or distributed clusters with no rewrite. For the problems Julia solves, there's no substitute.

Part of a bigger system

Simulate in Neutron Julia. Serve interactive dashboards with Neutron TypeScript. Persist everything in Nucleus. Feed results into Neutron Mojo for ML inference. One source of truth across runtimes.