DjiniousLabModelling & simulation

Design the whole systemon its digital replica.

Modelling & simulationModel

DjiniousLab is one engineering notebook for model-based design. Model every aspect of your system, simulate and test it as a living digital replica, then generate the embedded software — and the physical parts — that ship.

Book a demo See it in use

DjiniousLab block-diagram canvas holding a complete flight-control model, with a 1,094-block library on the left and wired mixer, attitude-estimation and controller blocks on the canvas — A complete flight-control model on the canvas: mixer, body dynamics, IMU fusion and attitude and altitude controllers, drawn from the 1,094-block library on the left.

blocks in the library: 1,094blocks in the library
demo projects: 200+demo projects
assistant tools: 30+assistant tools
import / export: FMI 3.0import / export

What it is

One engineering notebook. The whole product.

A digital replica is a high-fidelity, executable model of your system — physics, control logic, geometry, and all. In DjiniousLab it lives in one notebook, so the model you design, the replica you test, and the artefacts you ship never drift apart. Model, simulate, and generate are a single closed loop, not three disconnected tools.

Block-diagram canvas

Compose multi-domain models on a fast, GPU-accelerated canvas. Acausal modelling means you draw the physics — the solver figures out the math.

Acausal

Reactive notebook + REPL

Edit any upstream cell and every dependent cell re-evaluates automatically; a persistent REPL lets you interrogate live state without re-running the notebook.

Julia · Python

Parametric CAD

the3djin brings a BuildPart / ParameterSet API to the notebook: revolve, extrude, loft, fillet, chamfer, and boolean ops in plain Python, with STEP/STL export.

the3djin

Optimisation & RL

Parameter sweeps, CMA-ES / Bayesian optimisation, and PPO/SAC reinforcement learning run from the Studies panel, alongside the canvas.

Studies

Code generation

Compile any model to deterministic #![no_std] Rust firmware for STM32, Cortex-M, ESP32/RISC-V, WASM or x86-64 — built in, not a paid add-on.

no_std Rust

Reproducible runs

Every run is branded with its GIR hash — reproducible, auditable, bit-exact on replay.

GIR hash

Inside the product

See it working.

Every capture below is the running product.

01 · Canvas

A block-diagram canvas that thinks like an engineer.

Compose multi-domain models on a fast, GPU-accelerated canvas. Acausal Simscape-class modelling means you draw the physics — the solver figures out the math. Algebraic-loop detection and Pantelides index reduction happen at compile time, not at 3 AM.

Solvers: Tsit5 (explicit), Rodas5P (stiff), IDA (DAE) — chosen per-subsystem automatically
Live streaming scopes via Apache Arrow at >1 M samples/s with zero client-side buffering
GIR → ModelingToolkit.jl pipeline: symbolic simplification before any number is crunched
Subsystem hierarchy, variant management, and per-node parameter override in one place

A DjiniousLab canvas: an SIR epidemic model wired to three live scope plots

02 · Notebook & REPL

A reactive notebook that keeps downstream cells honest.

Edit any upstream cell and every dependent cell re-evaluates automatically — Pluto-style reactivity without the lock-in. A persistent WebSocket REPL lets you interrogate live state without re-running the whole notebook.

Julia and Python kernels; each cell’s stdout/stderr streams back as it executes
Magic-prefix renderers — Plotly, Three.js, maps, SVG, parameter widgets, progress bars
REPL shares the kernel process — inspect, patch variables, re-run from any cell
Notebook cells can drive canvas runs, read scopes, and emit STEP/STL assets

A DjiniousLab notebook cell rendering an interactive Plotly figure inline — ten colour-coded Gaussian clusters — as the cell finishes running

03 · Visualisation

Eight renderer flavours — rendered as the solver runs.

Outputs stream into the notebook cell in real time: no waiting for a run to finish before you see the first plot tick — from a Plotly surface to a satellite swarm orbiting a Cesium globe.

Plotly 2D/3D — scatter, heatmap, surface, bar, candlestick
Three.js scene graph, CesiumJS 3D globe and Leaflet maps
Sanitised inline SVG and inline renders of a canvas with a live Run button
Parameter widgets and live progress bars for sweeps

A Plotly Monte-Carlo touchdown-dispersion scatter with CEP / R95 rings, from the Reusable Rocket program, rendered inline from a notebook cell

04 · Parametric CAD

Parametric CAD in a notebook cell, pure Python.

Call show(part) and an interactive Three.js scene appears inline; call sweep_part(...) to generate STEP/STL variant families with a live progress bar. Generative design, where you hand the solver a load case and let it shape the part, is the direction we are building toward.

Full CAD kernel: revolve, extrude, loft, offset, fillet, chamfer, boolean
ParameterSet — named params with bounds, units, expressions, and dirty-flag tracking
Export to STEP (open standard), STL, or attach the asset to a canvas block directly
Roadmap: topology / generative optimisation driven by simulated load cases

A parametric mug rendered in 3D from the3djin in a notebook cell

05 · Code generation

One model. Browser, cloud, or silicon.

Compile any canvas model to deterministic, no_std Rust firmware via ModelingToolkit + StaticCompiler — the same symbolic pipeline that runs the solver drives the emitter. No hand-written wrappers, no bit-rot between sim and deployment.

Targets: STM32, ARM Cortex-M, ESP32/RISC-V, WASM (browser / edge), x86-64
FMI 3.0 export — drop the compiled unit into any FMI-compatible tool
Bit-exact cross-target replay: CI verifies the firmware matches the simulation trace
djl canvas build <model> --target <arch> — one command, zero GUI clicks

A DjiniousLab canvas wiring the quadcopter altitude-hold loop — step command, altitude-hold controller, vspeed plant, integrator, and live scopes — The quadcopter autopilot stack: close the loop on the real vehicle by deploying the generated firmware.

06 · Optimisation & RL

Optimise, sweep, and train a policy — from the same canvas.

The Studies panel runs alongside the canvas, not in a separate tool. Every study emits live progress to the notebook, and trained policies export directly as blocks you can drop back into the model.

Parameter optimisation: Latin Hypercube, CMA-ES, Nelder-Mead, Bayesian GP
Reinforcement learning: PPO, DDPG, SAC — train against the simulation environment
Trained RL policy exports as an FMU or as a native DjiniousLab block
All studies attach their GIR hash + seed so every run is reproducible

A Plotly 3-D render of the UR5 six-axis manipulator — joints, end-effector and base — from the UR5 Arm program, rendered inline from a notebook cell, drag-to-orbit

Library

Ready-to-run simulations. Open one and press play.

DjiniousLab ships a deep library of pre-built canvases and notebooks across engineering and science domains — production-grade models, not toy examples. Every demo is a digital replica you can open and run on the same engine that powers production.

The Quadcopter altitude hold demo in DjiniousLab

Control Systems & Robotics

14 demos

Closed-loop control and robotics — autopilots, motor drives, and manipulators modelled and tuned on the canvas.

Quadcopter altitude hold
Inverted pendulum
DC motor electromechanics
ABS slip control

The Reactor SCRAM transient demo in DjiniousLab

Chemical & Process

16 demos

Reactors, separations, and water treatment — process dynamics and control from kinetics to compliance.

Reactor SCRAM transient
Xenon poisoning
Activated sludge plant
Aeration DO control

The Theis aquifer pumping test demo in DjiniousLab

Geophysics & Climate

15 demos

Earth systems — aquifers, climate feedbacks, ice sheets, and atmospheric chemistry.

Theis aquifer pumping test
Contaminant plume migration
Greenland mass balance
Ice-albedo feedback

The Paris-law fatigue demo in DjiniousLab

Materials & Mechanics

13 demos

Materials and structural mechanics — phase transformations, fatigue, diffusion, and resonance.

Paris-law fatigue
Pearlite transformation
SDOF building resonance
Arrhenius diffusion

The QPSK constellation demo in DjiniousLab

Signal Processing & Telecom

8 demos

Signal processing and communications — modulation, carrier recovery, and adaptive filtering.

QPSK constellation
PLL carrier locking
LMS adaptive equalizer
Allan-variance estimate

The averaged buck converter demo in DjiniousLab

Power Electronics & Energy

9 demos

Power electronics and energy — converters, inverters, storage, and grid support.

Averaged buck converter
Grid-tie PQ inverter
PEM hydrogen electrolyzer
Frequency droop governor

The SIR epidemic curve demo in DjiniousLab

Biomedical & Epidemiology

18 demos

Physiology and epidemiology — cardiovascular dynamics, pharmacokinetics, neurons, and outbreak curves.

SIR epidemic curve
SEIR with incubation
Glucose-insulin dynamics
Arterial Windkessel

The Kepler orbit and Hohmann transfer demo in DjiniousLab

Aerospace & Marine

7 demos

Aerospace, astrodynamics, and marine — orbital mechanics, vessel dynamics, and ocean mixing.

Kepler orbit + Hohmann transfer
Marine vessel Nomoto yaw
Two-layer ocean salinity mixing

The Mach-Zehnder fringes demo in DjiniousLab

Optics & Photonics

6 demos

Optics and photonics — interference, polarization, and photon statistics.

Mach-Zehnder fringes
Malus’s law
Laser rate equations

Economics & Queueing

10 demos

Operations and finance — queueing, inventory, forecasting, and option pricing.

M/M/1 queue
Black-Scholes delta
Holt demand forecast
Bullwhip effect

Parametric 3D / CAD (the3djin)

4 demos

Parametric 3-D / CAD with the3djin — programmatic geometry, parameter sweeps, and STEP export.

Parametric mug — revolve + handle
Sweep variants
STEP export from ParameterSet
Torus-handle sweep

DjiniousLab

Lorenz attractor — streamed, then in 3-D. The trajectory streams into a live scope as the solver integrates, and the same run renders an interactive 3-D Plotly attractor inline — captured live from the app, no edits.

AI & agents

An AI assistant with access to your whole API.

DjiniousLab ships an in-app AI agent, two CLIs, and an MCP server — so you, your CI, and external agents like Claude Code, OpenAI Codex, and Pi can drive the whole model→simulate→generate loop programmatically, behind the same approval gates the UI uses.

Not a chatbot — an executor

A sidecar agent backed by your choice of LLM provider (keys encrypted at rest) with 30+ tools: it runs simulations, linearises models, fits symbolic laws, trains neural surrogates, and kicks off code generation.

Analyse and augment

DC-gain linearisation, symbolic regression, frequency-response and stability margins; MLP surrogate blocks, neural-ODE fits and auto-tuned PID and state-feedback controllers.

You stay in control

Every write operation and every REPL execution is gated: the assistant proposes the action and waits for an explicit confirmation before it runs. Read-only inspection never requires approval — only mutations do.

Frontend-parity CLI

The djl binary mirrors the full SPA surface: projects, canvases (incl. node and edge editing), notebooks (incl. cell editing), and WebSocket-streamed runs, cell executions, and REPL sessions.

Bring your own agent

Any MCP-aware agent — Claude Code, OpenAI Codex, Cursor, Pi, OpenCode, or your own orchestrator — authenticates with a single revocable djmcp_ bearer token and calls the same toolset the in-app assistant uses.

Operator CLI

A second CLI, djinious, handles the operator layer for deploy and CI: replay, codegen, sweep, optimise, rl-train, sign, verify and MATLAB transpilation.

The DjiniousLab in-app AI assistant answering ‘which notebooks render 3D plots’ — it calls the list_notebooks tool and returns a structured table, behind the same approval gate the UI uses

Capabilities

Model, simulate, generate — one engineering notebook.

Every capability of DjiniousLab serves one loop: model your system as a digital replica, simulate and test it, then generate what ships. Integrated pillars, no toolbox unlocking, no per-seat add-ons.

Model4 capabilities

Block library

Signal, electrical, mechanical, rotational, hydraulic, thermal, pneumatic and DSP blocks, plus domain libraries from robotics and aerospace to grid and power plant.

Acausal compilation

Algebraic-loop detection and Pantelides index reduction at compile time; GIR lowered to ModelingToolkit.jl with symbolic simplification.

Hierarchy & variants

Subsystem hierarchy, variant management, and per-node parameter override in one place.

the3djin parametric CAD

Revolve, extrude, loft, offset, fillet, chamfer and boolean ops in plain Python; ParameterSet with bounds, units and expressions.

Simulate4 capabilities

Solvers

Tsit5 (explicit), Rodas5P (stiff), IDA (DAE) — chosen per-subsystem automatically.

Live scopes

Streaming scopes via Apache Arrow at >1 M samples/s with zero client-side buffering.

Reactive notebook & REPL

Julia and Python kernels, Pluto-style reactivity, and a REPL sharing the kernel process.

Renderers

Plotly, Three.js, Cesium globe, Leaflet maps, sanitised SVG, inline canvas, parameter widgets and progress bars — lazy-loaded and streamed as the run proceeds.

Optimise3 capabilities

Parameter optimisation

Latin Hypercube, CMA-ES, Nelder-Mead, Bayesian GP.

Sweeps

Cartesian sweeps over all combinations with live progress ticks per iteration.

Reinforcement learning

PPO, DDPG, SAC trained against the simulation environment; policies export as an FMU or a native block.

Generate3 capabilities

Embedded firmware

#![no_std] Rust — auditable, no_alloc, ready for IEC 61508 review — for STM32, Cortex-M, ESP32/RISC-V, WASM and x86-64.

Bit-exact replay

CI verifies the firmware matches the simulation trace, deterministic regardless of OS or hardware.

Physical parts

the3djin emits STEP / STL geometry straight from a notebook cell today; generative design from simulated load cases is on the roadmap.

Interoperate & collaborate4 capabilities

FMI 3.0 import / export

Wrap any compliant .fmu as a first-class canvas block; compile any DjiniousLab model for co-simulation in third-party tools.

Simulink-style semantics

Rate transitions, bus creator/selector, From/Goto — and MATLAB model import to ease migration from an existing block-diagram codebase.

Real-time collaboration

Yjs CRDT: simultaneous canvas edits with presence cursors, zero merge conflicts.

Git-native projects

Every save creates a commit; branch, diff, and revert from the UI. The GIR hash on every run links any result back to the exact model state that created it.

Trust

Production-grade from day one.

Run the digital replica of your product on your own infrastructure. Single sign-on, isolation, auditability, and observability are part of the platform, not an afterthought — deploy on-premises, in your cloud, or air-gapped with no changes to the architecture.

SSO via OIDC

Bearer-JWT authentication with JWKS discovery. RS256 and ES256 only — alg:none is rejected at the gateway. Works out of the box with Okta, Auth0, Keycloak, and Zitadel.

OIDC

Multi-tenant by design

Per-tenant isolation with fine-grained quotas on projects, models, notebooks, runs, and concurrent sessions; per-session metering feeds your billing pipeline.

Session isolation

Each compute session runs in a sandboxed worker: read-only rootfs, no network by default, seccomp filter applied. Firecracker microVM and gVisor runtimes are supported deployment targets.

Audit logging

Append-only audit trail with content-hash and version on every mutation, streamed to object storage with object-lock immutability.

Observability

Distributed OpenTelemetry traces across the gateway, workers, and frontend SPA, with SLO targets for cell round-trip, simulation start, and scope latency.

OTLP

SCIM provisioning

SCIM user and group provisioning path for RBAC per project — no manual account creation, no stale access.

SCIM

Data residency & recovery

Metadata and blobs stay in the region you choose. Hourly snapshots, plus GIR-hash run provenance enables bit-exact replay of any past simulation from scratch.

No lock-in

FMI 3.0 units, plain git repositories and human-readable Rust firmware that compiles without the platform. Air-gapped deployments run the full stack from a single compose file with no external dependencies.

Supply-chain hygiene

STRIDE threat model, TLS enforced end-to-end, SBOM per artifact, signed run attestations, pinned toolchains, Trivy + cargo-audit scanning and Semgrep SAST.

In the digital thread

What it takes in. What it hands on.

DjiniousLab does its part of the engineering loop and passes its evidence along — and it works just as well on its own.

Receives

DjiniousEngineeringThe modelling work of the project: the system to capture as a digital replica, with the requirements and parameters it must be tested against.

DjiniousLabModelling & simulation

Delivers

DjiniousEngineeringSimulation evidence — every run branded with the GIR hash of the model that produced it, replayable bit-exact.

DjiniousWorkshopValidated models as FMI 3.0 co-simulation units, ready to be integrated into the complete system.

On its own

On its own, DjiniousLab is a complete model-based design environment: canvas, notebook, simulation, optimisation and code generation in one tool, with FMI 3.0 import and export to work alongside the tools you already use.

Use cases

DjiniousLab in use.

34 worked cases.

All 34 use cases

The full Djinborn T4 quadcopter on the DjiniousLab canvas — battery, four thrusters, hub body, arms, force injection, gyroscopic coupling, sensors, and the cascaded control stack wired as one runnable composition

Aerial roboticsDjinborn T4 quadcopterA 450-class survey drone as one multibody composition — airframe, propulsion, sensors, and a cascaded autopilot flying a closed-loop 6-DoF mission.

DjiniousLab

The UR5 6-axis robotic arm rendered in 3D at a representative mid-reach pose, showing all six revolute joints along the DH kinematic chain

Industrial roboticsUR5 6-axis manipulatorA spatial 6-DoF UR5 arm as one multibody model — closed-form inverse kinematics driving a Cartesian end-effector path through per-joint PD control with gravity feedforward.

DjiniousLab

An animated mission map of three UAVs flying a LiDAR survey of a 500-metre square near the Al-Batinah coast of Oman, with their flight paths and a mobile base marked over an OpenStreetMap basemap

UAV surveyAl-Batinah UAV LiDAR surveyPlan and optimise a LiDAR drone-fleet survey of a 500 × 500 m site in Oman — tune the mission to your fleet, drone and sensor specs, then drive an optimal mission against a simulated UAV fleet on an animated map.

DjiniousLab

Battery systemsEV battery packAn electric-vehicle battery pack as one multi-domain model — equivalent-circuit cells, a coupled thermal network, a CC-CV charge controller and an active balancer, composed cell → module → pack and run end to end.

DjiniousLab

A PMSM traction-motor efficiency map — torque against speed coloured by efficiency, with a high-efficiency island peaking near 97% inside the torque-speed envelope

Electric vehiclesFull EV vehicleThe battery pack you sized becomes the car you drive — a complete electric vehicle over the WLTP cycle: drive cycle, traction motor, regen, the battery over the cycle, thermal, and the numbers that sell a car — range, consumption, and 0–100.

DjiniousLab

A stacked-area dispatch chart over a day — PV, wind, battery and grid combining to exactly meet the load demand

MicrogridsMicrogridSolar PV + wind + battery + grid-tie serving a load as one system under an energy-management controller — composed on a DC bus and run over a day: dispatch, self-sufficiency, peak-shaving, sizing, and islanded stability.

DjiniousLab

Book a demo

See it on your problem.

See DjiniousLab on your models. We’ll walk your team through the workflows that matter to you — canvas, notebook, code-gen, or all three.

Book a demo Talk to us

Modelling a multi-domain system on the block-diagram canvas
Driving and analysing the replica from the reactive notebook
Parameter sweeps and optimisation from the Studies panel
Simulation run, surrogate training, and code generation — driven from the assistant and the CLI
Deployment model, security posture, and integration points for your stack

Along the thread

Works well with

All nine applications

DjiniousEngineeringOrchestration

The AI systems engineer: it takes the assignment and carries the whole project through a traceable System Ledger.

DjiniousWorkshopSystem integration

Components wired into a complete system and closed through GPU physics in NVIDIA Isaac Sim.

DjiniousSafeCertifiable code

Lean 4 specifications and kernel-checked proofs turned into panic-free embedded Rust, up to SIL 4.

DjiniousWorkflowAgent automation

Graph automation any stage can call on: build a process, run it, watch it and audit it.