# \[ANN\] Dyad: A New Language to Make Hardware Engineering as Fast as Software

**URL:** <https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996>\
**Category:** Package Announcements\
**Tags:** package, announcement, sciml, modelingtoolkit, dyad\
**Created:** [June 18, 2025, 3:08pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996 "2025-06-18T15:08:01Z")\
**Posts on this page:** 20\
**Page:** 1

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [June 18, 2025, 3:08pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/1 "2025-06-18T15:08:01Z")

</div>

JuliaHub is happy to announce Dyad, a new language to make hardware engineering as fast and easy as software engineering! Check out the release blog post!

> **[Dyad: A New Language to Make Hardware Engineering as Fast as Software - Blog...](https://juliahub.com/blog/dyad-making-hardware-as-easy-as-software)**
>
> Explore Dyad, a groundbreaking language that bridges hardware engineering and AI. Enhance productivity while ensuring safety and accuracy in your engineering projects.

## What is Dyad in a nutshell?

It is a declarative physical modeling language, allowing the easy construction of complex multiphysics models by piecing together components from the provided model libraries (or your own model libraries!). It has a 1-1 relationship between code and graphical representations, which means the same model can be inspected and interacted with in both GUI (coming soon) and code. For the coding interface, JuliaHub has released the Dyad Studio extensions for VS Code, which offers easy interactions with the compiler, static analysis to ensure correctness of physical models, and ease of authentication into the JuliaHub registries for models and launching large-scale jobs on clusters. That last part is essential for some of our big differentiators, as you can build a big model on your computer but, with a click of a button, launch of a big multi-GPU job on the cloud to train a surrogate of your model for quicker inspection!

## How does this relate to Julia?

You might think, oh no the JuliaHub people are working on a different language, not Julia? Well Dyad is actually quite related to Julia! The Dyad compiler lowers to Julia code, so if you know Julia SciML packages DifferentialEquations.jl and ModelingToolkit.jl you’ll feel right at home with its lowered representations. In addition, Dyad contains and interface for [“custom analyses”](https://help.juliahub.com/dyad/dev/manual/advanced/custom_analysis.html#advanced-custom-analysis), which means you can write dispatches in Julia which are then exposed as actions in the Dyad language and the coming GUI. Thus if you have some new fancy scientific machine learning workflow you’d like industrial companies to easily make use of, adding a little bit of Dyad bindings to your package suddenly exposes your new tools in these interfaces!

## Why is a new language needed here?

There are a few reasons why we needed to create a new language for this. First of all, in order to achieve this goal of having the same code be both the backing of a graphical environment and be an accessible representation for modeling, it needs to be a declarative language. You can’t say “run this Turing machine in order to figure out how many resistors there are” if you want a GUI to be snappy! On top of that, we wanted to ensure that we could build responsive tooling that could perform static analyses instantly to alert about problems with units and incorrect physical corrections. This means that, while there are some declarative DSLs in Julia that are similar (notably `@model` macro in ModelingToolkit.jl), moving this to be a Typescript-defined declarative language that lowers into Julia makes it so we can achieve these goals.

But all of the imperative behavior takes place in Julia. You adding new functions/operators, new analyses, data handling, etc. is all done by writing extensions in Julia. Also, the Dyad packages are Julia packages, but with a few extra requirements, and as such it also uses Pkg for all of its dependency management. Thus if you’re a Julia developer, then you’re already suited to be a Dyad developer!

## What’s Next?

We have a lot more that is coming soon. In particular:

- New tooling around agentic and generative AI for modeling
- Targeting embedded systems
- The GUI
- SciML model discovery analysis pipelines
- Model-predictive control
- Model libraries: multibody, HVAC/fluids, etc.

So much more is coming soon. Stay tuned!

## Where can I get more information?

Check out our documentation:

> **[Dyad](https://help.juliahub.com/dyad/dev/)**
>
> Modeling with Dyad: Hardware Engineering at the Speed of Software

and get [subscribed to our newsletter](https://share.hsforms.com/1zWvtHSvKSNCvFt7oVvQv3Acwyu9? __hstc=252702102.42c8eeb3775bc1a91bb47be73ec67043.1747049971514.1750191640299.1750258015695.19&__ hssc=252702102.1.1750258015695&__hsfp=1812501627) as we will be releasing a series (/barrage!) of blog posts as many things Dyad related are about to be released!

---

<div class="post-metadata">

**Author:** ![digital\_carver](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/digital_carver/32/33818_2.png) [@digital\_carver](https://discourse.julialang.org/u/digital_carver)\
**Post date:** [June 18, 2025, 3:50pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/2 "2025-06-18T15:50:12Z")

</div>

This seems pretty neat, kudos and good luck to everyone involved!

For anyone (else) who wanted to see a sample of the GUI and the corresponding code behind it, [one of the tutorials](https://help.juliahub.com/dyad/dev/tutorials/inversion-based-control.html) has a pretty nice example.

Also, for anyone (else) that’s curious about licensing and missed the last part of the blog post:

> We have chosen to publish Dyad Studio under a Source Available license. This allows us to make the code publicly available on [GitHub](https://github.com/DyadLang/) and people can use it for free for educational and non-commercial personal purposes, with [licenses available for commercial use](https://juliahub.com/company/contact-us-dyad). In addition, Dyad’s standard libraries are BSD3 open source licensed to enable open bug reporting and rapid improvements by community contributions.

- so, more “closed” than most things in Julia (at least that we publicly see and get to use), and more open than most things that are roughly in this space.

I’m really tempted to drop other things and try this out, to see what it feels like in practice 😀 But I’ll defer it and just subscribe to the updates for now.

---

<div class="post-metadata">

**Author:** ![ufechner7](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ufechner7/32/51363_2.png) [@ufechner7](https://discourse.julialang.org/u/ufechner7)\
**Post date:** [June 18, 2025, 4:42pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/3 "2025-06-18T16:42:52Z")

</div>

So what is the relationship between MTK and Dyad? Will MTK become depreciated and shall be replaced by Dyad? Or will both receive continued improvements?

---

<div class="post-metadata">

**Author:** ![viralbshah](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/viralbshah/32/54_2.png) [@viralbshah](https://discourse.julialang.org/u/viralbshah)\
**Post date:** [June 18, 2025, 4:59pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/4 "2025-06-18T16:59:52Z")

</div>

> [@digital\_carver](#):
>
> - so, more “closed” than most things in Julia (at least that we publicly see and get to use), and more open than most things that are roughly in this space.

That is accurate and a very good articulation of what we aimed for. There is lots of commercial software in Julia today, but it is not visible as you pointed out. We also feel that toolchains do need to have openness for wide adoption, but at the same time we do need a commercial model to sustain it over long periods.

---

<div class="post-metadata">

**Author:** ![viralbshah](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/viralbshah/32/54_2.png) [@viralbshah](https://discourse.julialang.org/u/viralbshah)\
**Post date:** [June 18, 2025, 5:01pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/5 "2025-06-18T17:01:53Z")

</div>

> [@ufechner7](#):
>
> So what is the relationship between MTK and Dyad? Will MTK become depreciated and shall be replaced by Dyad? Or will both receive continued improvements?

Dyad emits MTK, so it is a layer on top of MTK, and thus both will co-evolve. Of course, we also want to explore at some point what native compilation looks like and a lot of that will depend on what the users want.

---

<div class="post-metadata">

**Author:** ![ggggggggg](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/ggggggggg/32/265_2.png) [@ggggggggg](https://discourse.julialang.org/u/ggggggggg)\
**Post date:** [June 18, 2025, 5:09pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/6 "2025-06-18T17:09:55Z")

</div>

This post mention catching unit errors, but a brief skim of the docs didn’t tell me much about Dyad’s approach to units? Is unit support built in? Based on Unitful? Something that can be done by importing a package?

---

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [June 18, 2025, 5:25pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/7 "2025-06-18T17:25:25Z")

</div>

> [@ggggggggg](#):
>
> Is unit support built in?

Unit support is built in. It’s not based on Unitful. It’s not done through multiple dispatch because that’s not the right level to do unit checks correctly. If you make your number types all Unitful.jl values, then every single piece of arithmetic, every single time a function is called, is always checking the units. This either has a high run time or compile time burden, and it’s usually a high run time burden because most models will have many units and thus you’d have Any-eltype arrays (DynamicQuantities.jl can make this be type stable, at a computational cost). But that level is not necessarily what you need: you need to check whether your physical equations are unit correct, and if they are correct, then you can just generate lean code knowing that the equations are fine. This makes the code simpler while also making it easier to do things like target C for embedded devices.

So instead, this is the kind of stuff then done at the TypeScript level, for example making sure that the voltages are not connected to masses, and giving instant linting feedback in the VS Code extension.

Note that the unit implementation is not complete right now and there’s more coming with that, but at least that should be clear as to why this is elevated to a language / compiler level pre-Julia.

---

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [June 18, 2025, 5:26pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/8 "2025-06-18T17:26:48Z")

</div>

> [@ufechner7](#):
>
> So what is the relationship between MTK and Dyad? Will MTK become depreciated and shall be replaced by Dyad? Or will both receive continued improvements?

MTK is the compiler for Dyad. The major push of improvements to MTK has been all funded based on Dyad’s development. In other words, it’s the exact opposite: MTK is only able to exist because of Dyad.

---

<div class="post-metadata">

**Author:** ![j-fu](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/j-fu/32/11373_2.png) [@j-fu](https://discourse.julialang.org/u/j-fu)\
**Post date:** [June 18, 2025, 7:25pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/9 "2025-06-18T19:25:13Z")

</div>

Interesting to see the “source available license”. Could this be used for other projects as well or is its use limited to JuliaHub ? Also, what is the difference to GPL/AGPL ?

We had good experience with AGPLv3 based dual licensing (TetGen mesh generator) - the commercial licensing brought quite a bit of revenue.

---

<div class="post-metadata">

**Author:** ![danielwe](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/danielwe/32/35657_2.png) [@danielwe](https://discourse.julialang.org/u/danielwe)\
**Post date:** [June 18, 2025, 8:19pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/10 "2025-06-18T20:19:20Z")

</div>

> [@j-fu](#):
>
> Also, what is the difference to GPL/AGPL ?

\*GPL licences grant the user explicit rights to use, modify, and redistribute the code within the parameters set by the license, which are mostly that distribution of derivative works must make source code available under the same or a compatible license. Beyond that, you’re allowed to _use_ the software for anything you wish, commercial or otherwise.

~~Looks like the full Dyad license agreement is the [JuliaHub EULA](https://juliahub.com/company/eula) […]~~

Correction: as pointed out by @viralbshah below, the Dyad Source Available License is here: [GitHub - DyadLang/dyad-lang: The Dyad Language Kernel](https://github.com/DyadLang/dyad-lang?tab=License-1-ov-file). It’s a slight modification of [PolyForm Strict License 1.0.0 – Polyform Project](https://polyformproject.org/licenses/strict/1.0.0/). Some relevant lines:

> license […] to do everything you might do with the software that would otherwise infringe the licensor’s copyright in it for any non-commercial use

> does not include distributing the software or making changes or new works based on the software.

> Use by any state, local, or national government, including use for research and development purposes, is considered a commercial purpose and not permitted.

So, personal, non-commercial use and not-for-profit education/research is OK, however, compared to \*GPL licenses, there are a lot more restrictions on what you can do with the code, and the purpose of the license is different. The point of \*GPL is to ensure that the source code is always available to whoever is installing and running software built on/with the code. The point of the source available license is presumably to balance openness against JuliaHub’s commercial interests.

> [@j-fu](#):
>
> We had good experience with AGPLv3 based dual licensing

I’d be curious how this works if/when you start receiving contributions back from your users. I suppose they must also agree to you selling a commercial license to code that includes their contributions without them being compensated. That’s what CLA’s are for I guess. (Off-topic, so let’s not take this tangent and run with it.)

---

<div class="post-metadata">

**Author:** ![viralbshah](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/viralbshah/32/54_2.png) [@viralbshah](https://discourse.julialang.org/u/viralbshah)\
**Post date:** [June 18, 2025, 9:34pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/11 "2025-06-18T21:34:58Z")

</div>

> [@j-fu](#):
>
> Interesting to see the “source available license”. Could this be used for other projects as well or is its use limited to JuliaHub ? Also, what is the difference to GPL/AGPL ?

We adopted the PolyForm strict, but customized it a bit for our needs: [https://polyformproject.org/](https://polyformproject.org/). The website discusses the rationale and design.

---

<div class="post-metadata">

**Author:** ![viralbshah](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/viralbshah/32/54_2.png) [@viralbshah](https://discourse.julialang.org/u/viralbshah)\
**Post date:** [June 18, 2025, 10:18pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/12 "2025-06-18T22:18:53Z")

</div>

> [@danielwe](#):
>
> Looks like the full Dyad license agreement is the [JuliaHub EULA](https://juliahub.com/company/eula), which under the “FREE LICENSE” paragraph contains the following clauses:
> 
> So basically, unless you pay, you’re not allowed to generate revenue, and you’re not allowed to redistribute/license derivative software to others even if you’re not charging for it.

The JuliaHub EULA is our commercial license. The Source Available license is the license in the dyad-lang repo here: [GitHub - DyadLang/dyad-lang: A collection of TypeScript packages to implement various aspects of the Dyad language](https://github.com/DyadLang/dyad-lang).

Like I said above, it is an adapted version of PolyForm Strict, which is a choice we made.

The Dyad standard library is BSD-3 licensed, and it derives from the OpenModelica Standard Library. All the underlying ModelingToolKit and SciML Julia packages are MIT licensed.

> [@danielwe](#):
>
> I’d be curious how this works if/when you start receiving contributions back from your users.

Like you said, we would need a CLA in order to accept contributions. We have just put the release out there, and we’ll put infrastructure for CLA shortly. Please reach out to us on #dyad on the Julia slack for any questions or discussions.

---

<div class="post-metadata">

**Author:** ![danielwe](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/danielwe/32/35657_2.png) [@danielwe](https://discourse.julialang.org/u/danielwe)\
**Post date:** [June 18, 2025, 10:26pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/13 "2025-06-18T22:26:31Z")

</div>

> [@viralbshah](#):
>
> The JuliaHub EULA is our commercial license. The Source Available license is the license in the dyad-lang repo here: [GitHub - DyadLang/dyad-lang](https://github.com/DyadLang/dyad-lang).

Thanks for the correction, I’ll edit my post.

Just to explain: the `dyad-lang` repo wasn’t public when I was flipping through this, and the other non-BSD Dyad repos only have a generic “All rights reserved” notice (e.g., [GitHub - DyadLang/DyadData.jl: Interface for interacting with datasets in Dyad](https://github.com/DyadLang/DyadData.jl?tab=License-1-ov-file)). The only pointer I could find to an actual license was in the Dyad Studio VSCode extension, which links to the JuliaHub EULA ([License Agreement | Visual Studio Marketplace](https://marketplace.visualstudio.com/items/JuliaComputing.dyad-studio/license)), hence my inference in the post above.

---

<div class="post-metadata">

**Author:** ![viralbshah](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/viralbshah/32/54_2.png) [@viralbshah](https://discourse.julialang.org/u/viralbshah)\
**Post date:** [June 18, 2025, 10:28pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/14 "2025-06-18T22:28:49Z")

</div>

> [@danielwe](#):
>
> Thanks for the correction, I’ll edit my post.
> 
> Just to explain: the `dyad-lang` repo wasn’t public when I was flipping through this, and the other non-BSD Dyad repos only have a generic “All rights reserved” notice (e.g., [GitHub - DyadLang/DyadData.jl: Interface for interacting with datasets in Dyad](https://github.com/DyadLang/DyadData.jl?tab=License-1-ov-file)).

We realized that we had forgotten to flip the bit on that repo, until I saw your comment. 🙂

---

<div class="post-metadata">

**Author:** ![danielwe](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/danielwe/32/35657_2.png) [@danielwe](https://discourse.julialang.org/u/danielwe)\
**Post date:** [June 18, 2025, 10:56pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/15 "2025-06-18T22:56:36Z")

</div>

> Non-commercial use also includes use by any not-for-profit educational institution. Use by any state, local, or national government, including use for research and development purposes, is considered a commercial purpose and not permitted.

Can you clarify how university research funded by government grants fits into this?

---

<div class="post-metadata">

**Author:** ![viralbshah](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/viralbshah/32/54_2.png) [@viralbshah](https://discourse.julialang.org/u/viralbshah)\
**Post date:** [June 19, 2025, 12:01am UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/16 "2025-06-19T00:01:43Z")

</div>

> [@danielwe](#):
>
> Can you clarify how university research funded by government grants fits into this?

That would be usage at an educational institution / university, and hence free.

---

<div class="post-metadata">

**Author:** ![linwaytin](https://avatars.discourse-cdn.com/v4/letter/l/898d66/32.png) [@linwaytin](https://discourse.julialang.org/u/linwaytin)\
**Post date:** [June 19, 2025, 3:24am UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/17 "2025-06-19T03:24:01Z")

</div>

I appreciate the work done by JuliaHub, and hope they can get benefits from this product, which definitely also helps the Julia community.

One thing I would suggest is to make the pricing more transparent. I feel very confused, especially for a small team.

---

<div class="post-metadata">

**Author:** ![longemen3000](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/longemen3000/32/7298_2.png) [@longemen3000](https://discourse.julialang.org/u/longemen3000)\
**Post date:** [June 19, 2025, 3:43am UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/18 "2025-06-19T03:43:01Z")

</div>

> [@ChrisRackauckas](#):
>
> Thus if you have some new fancy scientific machine learning workflow you’d like industrial companies to easily make use of, adding a little bit of Dyad bindings to your package suddenly exposes your new tools in these interfaces!

I’'m interested in this part in particular, what can we do as developers to make Dyad libraries?

---

<div class="post-metadata">

**Author:** ![ChrisRackauckas](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/chrisrackauckas/32/77_2.png) [@ChrisRackauckas](https://discourse.julialang.org/u/ChrisRackauckas)\
**Post date:** [June 19, 2025, 12:55pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/19 "2025-06-19T12:55:16Z")

</div>

> [@longemen3000](#):
>
> I’'m interested in this part in particular, what can we do as developers to make Dyad libraries?

A Dyad library is a Julia library with a `dyad` folder that contains the Dyad code and `include` statements in the module that point to the `generated` code folder. A folder of this form is auto-generated via VS Code commands as shown here:

> **[Getting Started with Dyad Studio | Dyad](https://help.juliahub.com/dyad/dev/tutorials/getting-started.html#First-Step:-Creating-a-Component-Library)**
>
> Learn how to use Dyad Studio and the Dyad language.

I recommend looking at the DyadExampleComponents.jl repository as an example of how this looks:

> **[GitHub - DyadLang/DyadExampleComponents: Dyad Modeling and simulation examples](https://github.com/DyadLang/DyadExampleComponents)**
>
> Dyad Modeling and simulation examples

The `dyad` folder is the Dyad code. The `generated` folder is the Julia code the Dyad compiler generates. And then everything runs in the core Julia module. And there’s an `assets` folder that can be used for things like icons for the GUI representation.

So to create a new Dyad library, you just create new components in the repo exactly how the getting started shows! Every project is already a package! The Dyad compiler is then able to find the other projects in scope and allows for connecting their components (it has a `using` import syntax which is similar in form to Julia but at the Dyad component level).

The component is then able to use any functions defined in the Julia module, so for example you can use [Clapeyron.jl](https://github.com/ClapeyronThermo/Clapeyron.jl) to define `@symbolic_register`ed functions for ModelingToolkit, and then use those functions in the Dyad files, and that then exposes the processes in the Dyad formalism and GUI representation!

There’s also a way to define new analyses via schemas there, and that’s for if you want to expose a new functionality on models rather than a new model, such as a new plot or a new SciML training scheme. [Write a custom analysis | Dyad](https://help.juliahub.com/dyad/dev/manual/advanced/custom_analysis.html)

---

<div class="post-metadata">

**Author:** ![jebej](https://sea2.discourse-cdn.com/julialang/user_avatar/discourse.julialang.org/jebej/32/1784_2.png) [@jebej](https://discourse.julialang.org/u/jebej)\
**Post date:** [June 19, 2025, 3:35pm UTC](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996/20 "2025-06-19T15:35:39Z")

</div>

Hi @Chris & team, congrats on the announcement! I’d suggest putting that “Dyad in a nutshell” paragraph on the [webpage](https://help.juliahub.com/dyad/dev/), it’s more descriptive than the one liner currently there.

I looked through some of the definitions e.g. for inductors [here](https://github.com/DyadLang/ElectricalComponents/blob/main/dyad/inductor.dyad) and it looks quite similar to the definitions in the MTK standard library [here](https://github.com/SciML/ModelingToolkitStandardLibrary.jl/blob/9362b66d1126d1324c914c75b717c70c7d43e3a6/src/Electrical/Analog/ideal_components.jl#L151).

What will be the relationship between these two projects going forward? Will the standard library keep being developed?

[Next page](https://discourse.julialang.org/t/ann-dyad-a-new-language-to-make-hardware-engineering-as-fast-as-software/129996.md?page=2)