Scale, Deployment, AI Skills, New Domains and More

Dyad 3.0 is a major release. Built on Julia 1.12, this version introduces a fundamental reorganization of our standard component libraries, expanding what Dyad can model and providing a more flexible environment for enterprise-scale engineering.

The standard libraries have been reorganized into hierarchical namespaces, making large libraries easier to navigate and maintain as projects scale. Alongside that, the Dyad agent gains a modular skills system that lets engineers extend its behavior with their own workflows.

In This Update (TL;DR)

• Structural Reorganization — Standard libraries now follow a hierarchical, domain-appropriate namespace for improved organization.

• Trimmed FMU Generation — Export compact, standalone binaries (FMI v2/v3) using new JuliaC-based infrastructure.

• Domain Expansion — Launch of MultibodyComponents with an initial focus on  planar mechanics and HVACComponents for refrigeration cycles.

• Skills System for the Dyad Agent — A new framework that allows engineers to codify their own modeling protocols for the AI agent to follow.

• Windows MSI Installer — A streamlined, one-shot install experience, especially valuable for restricted corporate networks.

Standard Libraries: Architecting for Scale

The most pervasive change in 3.0 is the reorganization of the core component libraries. We have restructured the libraries into domain-appropriate hierarchies, ensuring that fully-qualified paths are descriptive and consistent across large teams.

Hierarchical Namespaces

Components are now nested within domain-appropriate categories, providing a clearer structure for growing libraries and teams:

# Dyad 2.x (Flat)
r = ElectricalComponents.Resistor(R = 1.0)
c = ElectricalComponents.Capacitor(C = 1e-6)
 
# Dyad 3.0 (Hierarchical)
r = ElectricalComponents.Analog.Basic.Resistor(R = 1.0)
c = ElectricalComponents.Analog.Basic.Capacitor(C = 1e-6)

# Dyad 2.x (Flat)
r = ElectricalComponents.Resistor(R = 1.0)
c = ElectricalComponents.Capacitor(C = 1e-6)
 
# Dyad 3.0 (Hierarchical)
r = ElectricalComponents.Analog.Basic.Resistor(R = 1.0)
c = ElectricalComponents.Analog.Basic.Capacitor(C = 1e-6)

# Dyad 2.x (Flat)
r = ElectricalComponents.Resistor(R = 1.0)
c = ElectricalComponents.Capacitor(C = 1e-6)
 
# Dyad 3.0 (Hierarchical)
r = ElectricalComponents.Analog.Basic.Resistor(R = 1.0)
c = ElectricalComponents.Analog.Basic.Capacitor(C = 1e-6)

This pattern runs through the entire suite, including BlockComponents.Continuous.* and RotationalComponents.Components.*. Along with the structure, we've standardized certain naming conventions: for example, the base thermal connector Dyad.Node is now Dyad.HeatPort, and its flow variable has been renamed from Q to Q_flow. These changes align Dyad's component libraries with the Modelica naming convention, making the standard library instantly familiar to engineers from other tools.

Deployment: Trimmed FMU Generation

Dyad 3.0 supports building trimmed FMUs — compact, deployable binaries that contain only the runtime your specific model requires.

Utilizing the new JuliaC-based infrastructure in Julia 1.12, Dyad can now produce optimized binaries that hold the specific model logic and its immediate dependencies.

• Portability — Export to FMI v2 or v3, supporting both Model Exchange and Co-Simulation.

• Efficiency — Trimmed binaries are optimized for deployment on both Linux and Windows.

• Metadata — Every exported FMU carries metadata identifying it as a Dyad-authored model.

For step-by-step instructions and worked examples, see the FMU generation documentation.

New Physical Domains: Multibody and HVAC

We are expanding Dyad's reach into two critical engineering domains with dedicated, first-party libraries.

MultibodyComponents (Planar Mechanics)

This library brings 2D planar dynamics into the Studio, allowing for the simulation of mechanisms like linkages, suspensions, and robotic arms.

• Integrated Animation — The RenderAnalysis type produces an animation of the mechanism directly from a transient simulation. Extend it like any other Dyad analysis, configure the camera and framerate, and run.

• Workflow Integration — Includes a URDF importer to translate robot descriptions directly into Dyad components.

Watch the video:

HVACComponents (Refrigeration Cycles)

For engineers working on vapor-compression and refrigeration cycles, HVACComponents provides a suite of high-fidelity thermal components.

• Accuracy at Speed — Built with spline-based models for industry-standard refrigerants — including R32, R1234YF, R290, R152a, R134a, R410A, and R717 — optimized for the high-speed property lookups required in solver inner loops.

• Commercial Access — This library is a commercial add-on; please contact sales@juliahub.com for access.

Watch the video:

Advancing the Dyad Agent: Skills and more

The Dyad AI Agent is extensible. Instead of a fixed system prompt, the agent loads skills on demand based on what you’re trying to do. There’s a temptation to “stuff” your agent’s context with all the things it could possibly need to know in any circumstance. But agent performance degrades as its context becomes too large and full of information that’s irrelevant to what you’re working on right now. Skills are the industry standard solution to this: each skill has a description of what the skill is useful for and when it should be loaded. When you start working on something with your agent that a skill is relevant to, the agent automatically loads the skill as additional context. Skills can also provide tools for the agent to use to accomplish that task. If you’re unsure how to create a skill, the agent can help you!

A skill is a simple Markdown file (SKILL.md) that defines a behavioral protocol. By placing these files in your project's .dyad/skills/directory, the agent will discover and follow your specific standards.

For example:                                            

<workspace-root>/

.skills/

component-validation/

SKILL.md

resources/

thermal-guidelines/

SKILL.md

resources/

Each SKILL.md is plain Markdown with a YAML header:

  ---

  name: component-validation
  description: Bottom-up validation workflow for a Dyad component before
    integrating it into a larger assembly. Builds a one-component test harness,
    drives it with a known input, and compares against an analytic answer.
    Load when adding a new component to a project's `dyad/` directory or when
    a component is suspected of being the source of a simulation failure.
    Do not load for parameter sweeps on already-validated components.
  ---
  # Component Validation
  A component that hasn't been exercised in isolation will hide sign errors,
  unit mismatches, and degenerate operating points until the full-system
  simulation fails at hour 47.
  ## Phase 1 — Pick the analytic answer
  1. Identify one input trajectory for which the component has a closed-form
     response (step input, sinusoid at a known frequency, ramp to a known
     steady state).
  2. Write the expected output trajectory on paper before building the harness.
  ## Phase 2 — Build the harness
  3. Create a minimal `.dyad` analysis: the component under test, the input
     source, a sensor on the output, nothing else.
  4. Set the simulation horizon to ≥ 5× the component's slowest timescale.
  ## Phase 3 — Compare
  5. Run `preflight_tool`; confirm state count matches the component's
     energy-storage elements.
  6. Simulate. Plot expected-vs-actual. The two curves must agree to within  solver tolerance; if they don't, fix the component, not the tolerance.

  name: component-validation
  description: Bottom-up validation workflow for a Dyad component before
    integrating it into a larger assembly. Builds a one-component test harness,
    drives it with a known input, and compares against an analytic answer.
    Load when adding a new component to a project's `dyad/` directory or when
    a component is suspected of being the source of a simulation failure.
    Do not load for parameter sweeps on already-validated components.
  ---
  # Component Validation
  A component that hasn't been exercised in isolation will hide sign errors,
  unit mismatches, and degenerate operating points until the full-system
  simulation fails at hour 47.
  ## Phase 1 — Pick the analytic answer
  1. Identify one input trajectory for which the component has a closed-form
     response (step input, sinusoid at a known frequency, ramp to a known
     steady state).
  2. Write the expected output trajectory on paper before building the harness.
  ## Phase 2 — Build the harness
  3. Create a minimal `.dyad` analysis: the component under test, the input
     source, a sensor on the output, nothing else.
  4. Set the simulation horizon to ≥ 5× the component's slowest timescale.
  ## Phase 3 — Compare
  5. Run `preflight_tool`; confirm state count matches the component's
     energy-storage elements.
  6. Simulate. Plot expected-vs-actual. The two curves must agree to within  solver tolerance; if they don't, fix the component, not the tolerance.

  name: component-validation
  description: Bottom-up validation workflow for a Dyad component before
    integrating it into a larger assembly. Builds a one-component test harness,
    drives it with a known input, and compares against an analytic answer.
    Load when adding a new component to a project's `dyad/` directory or when
    a component is suspected of being the source of a simulation failure.
    Do not load for parameter sweeps on already-validated components.
  ---
  # Component Validation
  A component that hasn't been exercised in isolation will hide sign errors,
  unit mismatches, and degenerate operating points until the full-system
  simulation fails at hour 47.
  ## Phase 1 — Pick the analytic answer
  1. Identify one input trajectory for which the component has a closed-form
     response (step input, sinusoid at a known frequency, ramp to a known
     steady state).
  2. Write the expected output trajectory on paper before building the harness.
  ## Phase 2 — Build the harness
  3. Create a minimal `.dyad` analysis: the component under test, the input
     source, a sensor on the output, nothing else.
  4. Set the simulation horizon to ≥ 5× the component's slowest timescale.
  ## Phase 3 — Compare
  5. Run `preflight_tool`; confirm state count matches the component's
     energy-storage elements.
  6. Simulate. Plot expected-vs-actual. The two curves must agree to within  solver tolerance; if they don't, fix the component, not the tolerance.

Other agentic AI improvements:

• Project Configuration — Use a dyad-agent.md file at your project root to set persistent instructions and preferences (similar to a CLAUDE.md or AGENTS.md file).

• Built-in Capabilities — Dyad 3.0 ships with a built-in Surrogate Modelling Skill that helps the agent generate fast surrogate models from  existing components and training data. This isn’t loaded into your agent’s context until you actually want to do surrogate modeling.

• Background Tasks — The julia_background_tool allows the agent to manage long-running Julia tasks in the background, freeing you to continue modeling while the agent handles heavy lifting.

Language and Kernel Refinements

Underpinning these features is Julia 1.12.6, which brings faster precompilation and reduced cold-start latency. We've also introduced several language features to make model authoring more intuitive:

initial on Modifications. Override initial conditions directly at the modification site:

m = ComponentWithInitialExpression(a = initial 0)

SteadyStateAnalysis has been moved to the Dyad base library, as a  peer to TransientAnalysis, with a new NonlinearSolveAlg enum for solver selection.

Connector Parameters. Interfaces can now carry parameters, allowing for more descriptive and configurable connection types.

Upgrading to 3.0

Since 3.0 is a breaking release, existing 2.x projects will require a one-time migration. For per-library rename tables and detailed migration notes, see the library changelog. The fastest path is to use the Dyad AI Agent — see the 3.0 changelog for the migration prompt. Close any editor tabs before running it.

For enterprise users on restricted networks, the new Windows MSI installer simplifies deployment by bundling Juliaup, the Dyad distribution, and the three required VS Code extensions into a single, offline-ready package.

Looking Ahead

Dyad 3.0 establishes a new baseline for how AI and simulation work together. We are moving toward a future where the agent actively participates in the entire design-and-validate lifecycle. Stay tuned as we continue to expand our physical domains and deployment infrastructure.

Launch Dyad Studio now to explore the new environment.

Happy modeling!