What is Julia?#

Julia is a new-ish programming language targeting scientific and high-performance computing applications. Like Python or MATLAB, it is a dynamic language—you don’t need to declare the types of variables like you would in C, C++, Fortran, etc.. Unlike Python, it is a compiled language, as every function is compiled to machine code the first time it is called. The aim of Julia is to provide users with a programming language that combines the convience of Python or MATLAB with the speed of C or Fortran. The official Julia documentation has a nice page comparing Julia to other popular languages if you’d like to know more.

One of the most attractive features of Julia for OpenMDAO users is its good support for automatic differentiation (AD). There are many (perhaps too many!) AD libraries available for the language, all with particular strengths and weaknesses. Happily, an excellent library called DifferentiationInterface.jl exists which allows us to use any of these numerious AD library via a uniform API, which makes switching from one to another a matter of changing just one or two lines of code.

What is OpenMDAO.jl?#

NOTE This page is a brief, Python-centric introduction to using Julia within OpenMDAO and OpenMDAO.jl in particular. Please check out the OpenMDAO.jl docs for all the details.

OpenMDAO.jl is a Python+Julia software package that allows users to create OpenMDAO Components out of Julia code, and optionally use a Julia AD package to differentiate the Component. There are currently two possible approaches to using AD with Julia:

  1. Manual Approach: Users can write the equivalent of a compute_partials or linearize method in Julia that calls the desired AD library manually. This is quite flexible and conceptually straightforward, but requires more work on the part of the user to manage the complexities of translating the inputs and outputs vectors OpenMDAO provides to something that the AD library can work with.

  2. Automatic Approach: Users can write a relatively simple “callback function” that implements the math behind the Component they wish to create, and allow OpenMDAO.jl to call the AD for them. This is much less work for the user, but does require learning a bit more about the Julia language. This approach is also currently limited to creating ExplicitComponents (though the callback function can contain implicitness via the ImplicitAD.jl package).

This documentation will focus on approach number 2, the Automatic Approach, which consists of essentially three steps:

  1. Create a user-defined callback function

  2. Create an OpenMDAO.jl AbstractADExplicitComp struct that will keep track the user-defined function, the desired AD library, and other optional features like units, tags, etc..

  3. Pass the AbstractADExplicitComp to omjlcomps (“OpenMDAO Julia Components”), a Python library that knows how to create OpenMDAO Components from an OpenMDAO.jl AbstractADExplicitComp.

After completing those three steps, you’ll be left with an OpenMDAO Component that you can include anywhere in an OpenMDAO model. We’ll go through each of the three steps below. For more details, have a look at the OpenMDAO.jl docs.

Guided Tutorial#

Step 1: The User-Defined Function#

The user-defined function must follow one of two forms: either it can be an “in-place” function that writes its outputs to an output vector, or it can be an “out-of-place” function that returns a single output vector. The function must be written in Julia, of course, and anything that happens inside the function is up to you, of course. Both the in-place and out-of-place form must also have a params argument that will contain inputs that are needed for the calculation, but won’t be differentiated (the equivalent of OpenMDAO options). So, an example of an in-place function would be

function f_in_place!(Y, X, params)
   # calculate stuff with X and params, storing result in Y
   return nothing
end

where X is the input vector and Y is the output vector. (The function doesn’t have to return nothing, but any returned value will be ignored, so I like to include return nothing to make it clear that the return value doesn’t matter.) An out-of-place function would look like

function f_out_of_place(X, params)
   # calculate stuff with X and params, returning Y
   return Y
end

where again X is the input vector and Y is the output vector.

Now, the X and Y arguments of those functions must not be plain Julia Vectors, but ComponentVectors from the ComponentArrays.jl package. What are those? They are objects provided by the ComponentArrays.jl package that act like Vectors, but allow the user to define names for each part (“component”) of the vector. For example, we can do this from the Julia REPL:

julia> using ComponentArrays: ComponentVector

julia> x1 = ComponentVector(foo=-1.0, bar=-2.0, baz=-3.0)
ComponentVector{Float64}(foo = -1.0, bar = -2.0, baz = -3.0)

julia> @show x1 x1[3] x1.foo x1[:foo]
x1 = (foo = -1.0, bar = -2.0, baz = -3.0)
x1[3] = -3.0
x1.foo = -1.0
x1[:foo] = -1.0
-1.0

julia>

Notice that we can get, say, the third value of x1 the usual way (x1[3]), but also by referring to the foo field value via x1.foo and by indexing the ComponentVector with the symbol :foo (x1[:foo]).

Each of the components in x1 are scalars, but they don’t have to be:

julia> x2 = ComponentVector(foo=-1.0, bar=1:4, baz=reshape(5:10, 2, 3))
ComponentVector{Float64}(foo = -1.0, bar = [1.0, 2.0, 3.0, 4.0], baz = [5.0 7.0 9.0; 6.0 8.0 10.0])

julia> @show x2 x2[:foo] x2[:bar] x2[:baz]
x2 = (foo = -1.0, bar = [1.0, 2.0, 3.0, 4.0], baz = [5.0 7.0 9.0; 6.0 8.0 10.0])
x2[:foo] = -1.0
x2[:bar] = [1.0, 2.0, 3.0, 4.0]
x2[:baz] = [5.0 7.0 9.0; 6.0 8.0 10.0]
2×3 Matrix{Float64}:
 5.0  7.0   9.0
 6.0  8.0  10.0

julia>

In x2, the foo component is a scalar, bar refers to a Vector (aka a 1D Array) and baz refers to a Matrix (aka a 2D Array). But x2 still “looks like” a Vector:

julia> @show x2[3]  # will give the third value of `x2`, which happens to be the second value of x2[:bar]
x2[3] = 2.0
2.0

julia> @show ndims(x2)  # Should be 1, since a Vector is 1-dimensional
ndims(x2) = 1
1

julia> @show length(x2)  # length(x2) gives the total number of entries in `x2`, aka 1 + 4 + 2*3 = 11
length(x2) = 11
11

julia> @show size(x2)  # size is a length-1 tuple since a Vector has just one dimension
size(x2) = (11,)
(11,)

julia>

Now, how will we use ComponentVectors here? We’ll use them to define the names and sizes of all the inputs and outputs to our component. For example, if we wanted to implement the Paraboloid Example, which minimizes the function

\[ f(x,y) = (x-3.0)^2 + x \cdot y + (y+4.0)^2 - 3.0 \]

using OpenMDAO.jl, we could create an input vector called X_ca that looks like this:

julia> X_ca = ComponentVector(x=1.0, y=1.0)
ComponentVector{Float64}(x = 1.0, y = 1.0)

julia>

That has two scalar components, x and y, that correspond to the two inputs to the paraboloid function. We could similarly use an output vector Y_ca that looks like this:

julia> Y_ca = ComponentVector(f_xy=0.0)
ComponentVector{Float64}(f_xy = 0.0)

julia>

with the single output f_xy.

We could type in a callback function that implements the paraboloid equation above into the REPL if we want:

julia> function f_paraboloid!(Y, X, params)
           # Get the inputs:
           x = @view(X[:x])
           y = @view(X[:y])
           # Could also do this:
           # x = X.x
           # y = X.y
           # or even this
           # (; x, y) = X

           # Get the output:
           f_xy = @view(Y[:f_xy])
           # Again, could also do this:
           # f_xy = Y.f_xy
           # or
           # (; f_xy) = Y

           # Do the calculation:
           @. f_xy = (x - 3.0)^2 + x*y + (y + 4.0)^2 - 3.0

           # No return value for in-place callback function.
           return nothing
       end
f_paraboloid! (generic function with 1 method)

julia>

And then test it out with the X_ca and Y_ca ComponentVectors we created earlier:

julia> f_paraboloid!(Y_ca, X_ca, nothing)

julia> X_ca
ComponentVector{Float64}(x = 1.0, y = 1.0)

julia> Y_ca
ComponentVector{Float64}(f_xy = 27.0)

julia>

Some remarks about the callback function:

  • The @view macro is used when extracting the inputs and outputs from the X_ca and Y_ca ComponentVectors. This creates a view into the original ComponentVector, instead of a new array with a copy of the original data, which avoids unnecessary allocations and (for the outputs) allows modifications to the view to be reflected in the Y_ca array. In this example everything is a scalar, so no allocations would have happened anyway. But it doesn’t hurt to use @view: it’s a good habit to get into, and it allows us to use the @. broadcasting macro with the scalar f_xy output.

  • The params argument is not used in this example, but it is still required, since the code in OpenMDAO.jl will expect it. We provided a nothing value for it, but we could have given it anything and not changed the result of the function, of course.

An out-of-place version of f_paraboloid! would look like this:

julia> function f_paraboloid(X, params)
           x = @view(X[:x])
           y = @view(X[:y])
           f_xy = @. (x - 3.0)^2 + x*y + (y + 4.0)^2 - 3.0
           return ComponentVector(f_xy=f_xy)
       end
f_paraboloid (generic function with 1 method)

julia> f_paraboloid(X_ca, nothing)
ComponentVector{Float64}(f_xy = 27.0)

julia>

But we only need one or the other.

Step 2: The OpenMDAO.jl AbstractADExplicitComp#

So far we’ve done a lot of typing in the Julia REPL, which is great for testing, but not great for writing code that you’ll use more than once. Where should we store this Julia code that we’re creating, and how will we call it from Python? This section will explain my favorite way to do that. Along the way we’ll learn how to choose a Julia AD library, and create an AbstractADExplicitComp that will eventually be used to instantiate an ExplicitComponent that can be added to a OpenMDAO model.

A Julia Package for our Paraboloid#

We’ll store our Julia code for the paraboloid component in a brand new Julia package called MyParaboloidPackage. Creating a new Julia package is very easy from the REPL: just type ] to enter the Pkg REPL (look for the pkg> in the prompt to ensure you’re in “Pkg mode”), then type generate MyParaboloidPackage to create the package:

(openmdao_jl_dev) pkg> generate MyParaboloidPackage
  Generating  project MyParaboloidPackage:
    MyParaboloidPackage/Project.toml
    MyParaboloidPackage/src/MyParaboloidPackage.jl

(openmdao_jl_dev) pkg>

(Keep this REPL open, as we’ll be using it again later.) As the output suggests, running that command creates a directory called MyParaboloidPackage in the current working directory, along with two files. The Project.toml file contains metadata about the Julia project (name, version number, a UUID to distinguish it from other Julia packages, dependencies, etc.). The src/MyParaboloidPackage.jl contains the source code of the package, and at the moment looks like this:

module MyParaboloidPackage

greet() = print("Hello World!")

end # module MyParaboloidPackage

We’ll put our paraboloid code in src/MyParaboloidPackage.jl by copy-pasting the definition of f_paraboloid! into the file. Now it should look like this (with the greet function removed):

module MyParaboloidPackage

function f_paraboloid!(Y, X, params)
    x = @view(X[:x])
    y = @view(X[:y])
    f_xy = @view(Y[:f_xy])
    @. f_xy = (x - 3.0)^2 + x*y + (y + 4.0)^2 - 3.0
    return nothing
end

end # module MyParaboloidPackage

Now, let’s see if we can create that AbstractADExplicitComp that we’ve been talking about. There are a few different flavors of AbstractADExplicitComp structs that we could use, but for this example, we’ll use DenseADExplicitComp, one that’s designed for explicit components with a dense Jacobian. If we check out the documentation for DenseADExplicitComp constructor, we’ll see that we need four things to get this done:

  • An ad_backend, to be explained shortly

  • A callback function f!

  • Y_ca, a ComponentVector of outputs

  • X_ca, a ComponentVector of inputs

In the previous section we learned how to create X_ca and Y_ca, and our callback function f! will be the f_paraboloid!. So the only missing ingrediant is the ad_backend.

The ad_backend is a Julia object that will tell the DenseADExplicitComp which AD library we want to use to differentiate our component. The object must be a subtype of AbstractADType, an abstract type provided by the ADTypes.jl package. That package is not part of the Julia Standard Library, so we’ll need to install it. How do we do that? The easiest way is from the Julia Pkg REPL, aka the thing we used to generate the MyParaboloidPackage earlier. First, type ] to ensure we’re in the Pkg REPL (again, look for pkg> in the prompt), then do this:

(openmdao_jl_dev) pkg> activate ./MyParaboloidPackage
  Activating project at `~/projects/openmdao_jl_dev/ved/OpenMDAO/openmdao/docs/openmdao_book/features/experimental/MyParaboloidPackage`

(MyParaboloidPackage) pkg>

That “activates” the environment associated with MyParaboloidPackage, which tells the Julia Pkg package manager that we want to mess around with the dependencies of it and not some other environment or package. (The Pkg REPL reminds us which environment is “active” by changing the prompt to (MyParaboloidPackage) pkg>.) We can check the status of MyParaboloidPackage via the status command:

(MyParaboloidPackage) pkg> status
Project MyParaboloidPackage v0.1.0
Status `~/projects/openmdao_jl_dev/ved/OpenMDAO/openmdao/docs/openmdao_book/features/experimental/MyParaboloidPackage/Project.toml` (empty project)

(MyParaboloidPackage) pkg>

Unsuprisingly there isn’t much going on with it yet.

The next step is to add the dependencies we need. We’ve already decided that we want ADTypes.jl, but we’ll also need:

  • ComponentArrays.jl: for the ComponentVectors we’ll provide to the DenseADExplicitComp constructor

  • OpenMDAOCore.jl: for the DenseADExplicitComp itself

  • ForwardDiff.jl: a forward-mode AD library that we’ll use for this example

So, let’s install those using the add command from the Pkg REPL:

(MyParaboloidPackage) pkg> add ADTypes ComponentArrays OpenMDAOCore ForwardDiff
   Resolving package versions...
   Installed DifferentiationInterface ─ v0.7.14
      Compat entries added for ADTypes, ComponentArrays, OpenMDAOCore, ForwardDiff
    Updating `~/projects/openmdao_jl_dev/ved/OpenMDAO/openmdao/docs/openmdao_book/features/experimental/MyParaboloidPackage/Project.toml`
  [47edcb42] + ADTypes v1.21.0
  [b0b7db55] + ComponentArrays v0.15.31
  [f6369f11] + ForwardDiff v1.3.1
  [24d19c10] + OpenMDAOCore v0.3.3
    Updating `~/projects/openmdao_jl_dev/ved/OpenMDAO/openmdao/docs/openmdao_book/features/experimental/MyParaboloidPackage/Manifest.toml`

# Lots of output removed for clarity
(MyParaboloidPackage) pkg>

Now if we try the status command again, we’ll see this:

(MyParaboloidPackage) pkg> status
Project MyParaboloidPackage v0.1.0
Status `~/projects/openmdao_jl_dev/ved/OpenMDAO/openmdao/docs/openmdao_book/features/experimental/MyParaboloidPackage/Project.toml`
  [47edcb42] ADTypes v1.21.0
  [b0b7db55] ComponentArrays v0.15.31
  [f6369f11] ForwardDiff v1.3.1
  [24d19c10] OpenMDAOCore v0.3.3

(MyParaboloidPackage) pkg>

That shows the dependencies of MyParaboloidPackage, and their version numbers. Excellent.

Now we should have everything we need to create the DenseADExplicitComp. I think it’s easiest to create a small “helper function” that we can call later that returns our DenseADExplicitComp that looks like this:

function get_paraboloid_comp()
    ad_backend = ADTypes.AutoForwardDiff()
    X_ca = ComponentVector(x=1.0, y=1.0)
    Y_ca = ComponentVector(f_xy=0.0)
    comp = OpenMDAOCore.DenseADExplicitComp(ad_backend, f_paraboloid!, Y_ca, X_ca)
    return comp
end

The ADTypes.AutoForwardDiff() means that we’ll use ForwardDiff.jl, a forward-mode AD package, to differentiate our paraboloid.

We’ll add that function to src/MyParaboloidPackage.jl, along with some import statements that give us access to the packages we just installed. So now it should look like this:

module MyParaboloidPackage

using ADTypes: ADTypes
using ComponentArrays: ComponentVector
using ForwardDiff: ForwardDiff
using OpenMDAOCore: OpenMDAOCore

function f_paraboloid!(Y, X, params)
    x = @view(X[:x])
    y = @view(X[:y])
    f_xy = @view(Y[:f_xy])
    @. f_xy = (x - 3.0)^2 + x*y + (y + 4.0)^2 - 3.0
    return nothing
end

function get_paraboloid_comp()
    ad_backend = ADTypes.AutoForwardDiff()
    X_ca = ComponentVector(x=1.0, y=1.0)
    Y_ca = ComponentVector(f_xy=0.0)
    comp = OpenMDAOCore.DenseADExplicitComp(ad_backend, f_paraboloid!, Y_ca, X_ca)
    return comp
end

end # module MyParaboloidPackage

We can try out the get_paraboloid_comp function from the normal Julia REPL (not the Pkg REPL—just backspace until you get the julia> prompt back):

julia> using MyParaboloidPackage

julia> comp = MyParaboloidPackage.get_paraboloid_comp()

You’ll probibly see a bunch of output describing in excruciating detail all the type information associated with the DenseADExplicitComp we just created. But as long as you see something that starts with OpenMDAOCore.DenseADExplicitComp, we should be good.

Step 3: The omjlcomps.JuliaExplicitComp#

So far we have created a Julia callback function and a DenseADExplicitComp for our paraboloid. The last step is to turn that DenseADExplicitComp into something we can actually incorporate into an OpenMDAO model. We’ll do that using omjlcomps, a Python package that’s part of OpenMDAO.jl.

But first, we need to figure out a nice way of telling Python about our Julia code. The best way of doing that is using juliapkg, a Python package that allows us to add Julia dependencies to a Python package. We could install it manually ourselves using pip install juliapkg, but if instead we install OpenMDAO with the “julia” extra, we’ll get it automatically:

$ pip install openmdao[julia]

We’ll do that from here in a Jupyter notebook using this command:

!pip install openmdao[julia]

Requirement already satisfied: openmdao[julia] in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (3.43.1.dev0)
Requirement already satisfied: networkx>=3.3 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from openmdao[julia]) (3.6.1)
Requirement already satisfied: numpy!=2.4.0,>=2.0 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from openmdao[julia]) (2.4.2)
Requirement already satisfied: packaging in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from openmdao[julia]) (26.0)
Requirement already satisfied: requests in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from openmdao[julia]) (2.32.5)
Requirement already satisfied: scipy>=1.13 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from openmdao[julia]) (1.17.1)

Collecting omjlcomps>=0.2.6 (from openmdao[julia])

  Downloading omjlcomps-0.2.6-py3-none-any.whl.metadata (1.5 kB)
Collecting juliapkg~=0.1.10 (from omjlcomps>=0.2.6->openmdao[julia])

  Downloading juliapkg-0.1.23-py3-none-any.whl.metadata (6.8 kB)
Collecting juliacall~=0.9.13 (from omjlcomps>=0.2.6->openmdao[julia])

  Downloading juliacall-0.9.31-py3-none-any.whl.metadata (4.5 kB)
Requirement already satisfied: filelock<4.0,>=3.16 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from juliapkg~=0.1.10->omjlcomps>=0.2.6->openmdao[julia]) (3.25.0)
Collecting semver<4.0,>=3.0 (from juliapkg~=0.1.10->omjlcomps>=0.2.6->openmdao[julia])

  Downloading semver-3.0.4-py3-none-any.whl.metadata (6.8 kB)
Requirement already satisfied: tomli<3.0,>=2.0 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from juliapkg~=0.1.10->omjlcomps>=0.2.6->openmdao[julia]) (2.4.0)
Collecting tomlkit<0.15,>=0.13.3 (from juliapkg~=0.1.10->omjlcomps>=0.2.6->openmdao[julia])

  Downloading tomlkit-0.14.0-py3-none-any.whl.metadata (2.8 kB)
Requirement already satisfied: charset_normalizer<4,>=2 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from requests->openmdao[julia]) (3.4.4)
Requirement already satisfied: idna<4,>=2.5 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from requests->openmdao[julia]) (3.11)
Requirement already satisfied: urllib3<3,>=1.21.1 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from requests->openmdao[julia]) (2.6.3)
Requirement already satisfied: certifi>=2017.4.17 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from requests->openmdao[julia]) (2026.2.25)
Downloading omjlcomps-0.2.6-py3-none-any.whl (17 kB)

Downloading juliacall-0.9.31-py3-none-any.whl (12 kB)
Downloading juliapkg-0.1.23-py3-none-any.whl (21 kB)

Downloading semver-3.0.4-py3-none-any.whl (17 kB)
Downloading tomlkit-0.14.0-py3-none-any.whl (39 kB)

Installing collected packages: tomlkit, semver, juliapkg, juliacall, omjlcomps
?25l

   ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 5/5 [omjlcomps]
?25h
Successfully installed juliacall-0.9.31 juliapkg-0.1.23 omjlcomps-0.2.6 semver-3.0.4 tomlkit-0.14.0

Now, we need to use juliapkg to tell our Python environment about MyParaboloidPackage. We do that by creating a file called juliapkg.json in our working directory that points to MyParaboloidPackage:

{"packages": {
    "MyParaboloidPackage": {"uuid": "a013c6e3-dc76-40b3-894d-62618f778e16", "dev": true, "path": "./MyParaboloidPackage"}
    }
}

(To get the correct value for the "uuid" field, copy what’s in the MyParaboloidPackage/Project.toml file. It will be different from what is listed above if you’re trying out these commands yourself.)

That tells juliapkg about MyParaboloidPackage. The "dev": true means that the package will be installed in “develop” mode, meaning any changes in the package will be reflected in code that calls it—it’s the equivalent of pip install -e or pip install --editable in Python.

juliapkg searches for juliapkg.json files in, among other places, each entry in sys.path. This is great for adding Julia dependencies to Python packages: you can add a juliapkg.json to your Python source, and juliapkg will find it automatically if your Python package is installed in the current environment. It also works well for Python scripts run from the command line: since Python automatically adds the directory of the script to sys.path, we could place the juliapkg.json file in the same directory as the run script and it should also be found by juliapkg. But it’s not-so-great for Jupyter notebooks like this one. So we’ll have to manually add what we think is the current working directory to sys.path and cross our fingers.

import os
import sys
d = os.getcwd()
sys.path.append(d)
print(sys.path[-1])

/home/runner/work/OpenMDAO/OpenMDAO/openmdao/docs/openmdao_book/features/experimental

Next, we’ll create a small julia file in the current working directory that will import the get_paraboloid_comp function that we just added to MyParaboloidPackage called paraboloid.jl:

from IPython.display import display, Code
display(Code(os.path.join(d, "paraboloid.jl")))

using MyParaboloidPackage: get_paraboloid_comp

Now we’ll create another small file, this time a Python one, called paraboloid.py that will include that paraboloid.jl julia file using JuliaCall, a Python package for calling Julia code that was automatically installed when we did pip install openmdao[julia]:

display(Code(os.path.join(d, "paraboloid.py")))

import os

# Create a new Julia module that will hold all the Julia code imported into this Python module.
import juliacall
jl = juliacall.newmodule("ParaboloidComponentsStub")

# Get the directory this file is in, then include the `paraboloid.jl` Julia source code.
d = os.path.dirname(os.path.abspath(__file__))
jl.include(os.path.join(d, "paraboloid.jl"))
# Now we have access to everything in `paraboloid.jl` in the `jl` object.

get_paraboloid_comp = jl.get_paraboloid_comp

Now we should be able to use omjlcomps (another Python package that was installed as a side effect of pip install openmdao[julia]) to create a JuliaExplicitComp. We do this by first calling get_paraboloid_comp to get the DenseADExplicitComp struct we created, then pass it as the jlcomp argument to JuliaExplicitComp:

import omjlcomps
from paraboloid import get_paraboloid_comp
jlcomp = get_paraboloid_comp()
comp = omjlcomps.JuliaExplicitComp(jlcomp=jlcomp)

[juliapkg] Found dependencies: /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages/omjlcomps/juliapkg.json
[juliapkg] Found dependencies: /home/runner/work/OpenMDAO/OpenMDAO/openmdao/docs/openmdao_book/features/experimental/juliapkg.json
[juliapkg] Found dependencies: /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages/juliapkg/juliapkg.json
[juliapkg] Found dependencies: /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages/juliacall/juliapkg.json
[juliapkg] Locating Julia ^1.10.3

[juliapkg] Using Julia 1.12.5 at /usr/bin/julia
[juliapkg] Using Julia project at /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/julia_env
[juliapkg] Writing Project.toml:
           | [deps]
           | OpenMDAOCore = "24d19c10-6eee-420f-95df-4537264b2753"
           | LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
           | PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"
           | MyParaboloidPackage = "a013c6e3-dc76-40b3-894d-62618f778e16"
           | OpenSSL_jll = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
           | 
           | [compat]
           | OpenMDAOCore = "^0.3.2"
           | PythonCall = "=0.9.31"
           | OpenSSL_jll = "3.0.0 - 3.6"
[juliapkg] Installing packages:
           | import Pkg
           | Pkg.Registry.update()
           | Pkg.develop([
           |   Pkg.PackageSpec(name="MyParaboloidPackage", uuid="a013c6e3-dc76-40b3-894d-62618f778e16", path=raw"/home/runner/work/OpenMDAO/OpenMDAO/openmdao/docs/openmdao_book/features/experimental/MyParaboloidPackage"),
           | ])
           | Pkg.add([
           |   Pkg.PackageSpec(name="OpenMDAOCore", uuid="24d19c10-6eee-420f-95df-4537264b2753"),
           |   Pkg.PackageSpec(name="LinearAlgebra", uuid="37e2e46d-f89d-539d-b4ee-838fcccc9c8e"),
           |   Pkg.PackageSpec(name="PythonCall", uuid="6099a3de-0909-46bc-b1f4-468b9a2dfc0d"),
           |   Pkg.PackageSpec(name="OpenSSL_jll", uuid="458c3c95-2e84-50aa-8efc-19380b2a3a95"),
           | ])
           | Pkg.resolve()
           | Pkg.precompile()

  Installing known registries into `~/.julia`

       Added `General` registry to ~/.julia/registries

    Updating registry at `~/.julia/registries/General.toml`
   Resolving package versions...

   Installed Scratch ───────────────────── v1.3.0
   Installed IrrationalConstants ───────── v0.2.6
   Installed DiffRules ─────────────────── v1.15.1
   Installed Functors ──────────────────── v0.5.2
   Installed JSON ──────────────────────── v1.4.0
   Installed Adapt ─────────────────────── v4.5.0
   Installed PythonCall ────────────────── v0.9.31
   Installed SciMLPublic ───────────────── v1.0.1
   Installed TableTraits ───────────────── v1.0.1
   Installed DiffResults ───────────────── v1.1.0
   Installed Parsers ───────────────────── v2.8.3
   Installed ADTypes ───────────────────── v1.21.0
   Installed SpecialFunctions ──────────── v2.7.1
   Installed Tables ────────────────────── v1.12.1
   Installed DataAPI ───────────────────── v1.16.0
   Installed IfElse ────────────────────── v0.1.1
   Installed UnitfulAngles ─────────────── v0.7.2

   Installed Unitful ───────────────────── v1.28.0
   Installed Pidfile ───────────────────── v1.3.0
   Installed MicroMamba ────────────────── v0.1.15
   Installed Preferences ───────────────── v1.5.2
   Installed JLLWrappers ───────────────── v1.7.1
   Installed micromamba_jll ────────────── v2.3.1+0
   Installed StaticArraysCore ──────────── v1.4.4
   Installed NaNMath ───────────────────── v1.1.3
   Installed IteratorInterfaceExtensions ─ v1.0.0
   Installed ConstructionBase ──────────── v1.6.0
   Installed DataValueInterfaces ───────── v1.0.0
   Installed OrderedCollections ────────── v1.8.1
   Installed ChainRulesCore ────────────── v1.26.0

   Installed CommonSubexpressions ──────── v0.3.1
   Installed LogExpFunctions ───────────── v0.3.29
   Installed ArrayInterface ────────────── v7.23.0
   Installed ForwardDiff ───────────────── v1.3.3
   Installed PrecompileTools ───────────── v1.3.3
   Installed SparseMatrixColorings ─────── v0.4.26
   Installed DataStructures ────────────── v0.18.22
   Installed MacroTools ────────────────── v0.5.16
   Installed UnsafePointers ────────────── v1.0.0
   Installed Static ────────────────────── v1.3.1
   Installed Compat ────────────────────── v4.18.1
   Installed OpenSpecFun_jll ───────────── v0.5.6+0
   Installed CommonWorldInvalidations ──── v1.0.0
   Installed DifferentiationInterface ──── v0.7.16
   Installed Requires ──────────────────── v1.3.1
   Installed StaticArrayInterface ──────── v1.9.0
   Installed DocStringExtensions ───────── v0.9.5
   Installed StructUtils ───────────────── v2.7.1

   Installed pixi_jll ──────────────────── v0.41.3+0
   Installed OpenMDAOCore ──────────────── v0.3.3
   Installed CondaPkg ──────────────────── v0.2.34

   Installed ComponentArrays ───────────── v0.15.33

  Installing 1 artifacts

   Installed artifact OpenSpecFun 194.9 KiB

    Updating `~/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/julia_env/Project.toml`
  [a013c6e3] + MyParaboloidPackage v0.1.0 `~/work/OpenMDAO/OpenMDAO/openmdao/docs/openmdao_book/features/experimental/MyParaboloidPackage`
  [24d19c10] + OpenMDAOCore v0.3.3
  [6099a3de] + PythonCall v0.9.31
  [37e2e46d] ~ LinearAlgebra ⇒ v1.12.0
  [458c3c95] ~ OpenSSL_jll ⇒ v3.5.4+0
    Updating `~/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/julia_env/Manifest.toml`
  [47edcb42] + ADTypes v1.21.0
  [79e6a3ab] + Adapt v4.5.0
  [4fba245c] + ArrayInterface v7.23.0
  [d360d2e6] + ChainRulesCore v1.26.0
  [bbf7d656] + CommonSubexpressions v0.3.1
  [f70d9fcc] + CommonWorldInvalidations v1.0.0
  [34da2185] + Compat v4.18.1
  [b0b7db55] + ComponentArrays v0.15.33
  [992eb4ea] + CondaPkg v0.2.34
  [187b0558] + ConstructionBase v1.6.0
  [9a962f9c] + DataAPI v1.16.0
⌅ [864edb3b] + DataStructures v0.18.22
  [e2d170a0] + DataValueInterfaces v1.0.0
  [163ba53b] + DiffResults v1.1.0
  [b552c78f] + DiffRules v1.15.1
  [a0c0ee7d] + DifferentiationInterface v0.7.16
  [ffbed154] + DocStringExtensions v0.9.5
  [f6369f11] + ForwardDiff v1.3.3
  [d9f16b24] + Functors v0.5.2
  [615f187c] + IfElse v0.1.1
  [92d709cd] + IrrationalConstants v0.2.6
  [82899510] + IteratorInterfaceExtensions v1.0.0
  [692b3bcd] + JLLWrappers v1.7.1
  [682c06a0] + JSON v1.4.0
  [2ab3a3ac] + LogExpFunctions v0.3.29
  [1914dd2f] + MacroTools v0.5.16
  [0b3b1443] + MicroMamba v0.1.15
  [a013c6e3] + MyParaboloidPackage v0.1.0 `~/work/OpenMDAO/OpenMDAO/openmdao/docs/openmdao_book/features/experimental/MyParaboloidPackage`
  [77ba4419] + NaNMath v1.1.3
  [24d19c10] + OpenMDAOCore v0.3.3
  [bac558e1] + OrderedCollections v1.8.1
  [69de0a69] + Parsers v2.8.3
  [fa939f87] + Pidfile v1.3.0
  [aea7be01] + PrecompileTools v1.3.3
  [21216c6a] + Preferences v1.5.2
  [6099a3de] + PythonCall v0.9.31
  [ae029012] + Requires v1.3.1
  [431bcebd] + SciMLPublic v1.0.1
  [6c6a2e73] + Scratch v1.3.0
  [0a514795] + SparseMatrixColorings v0.4.26
  [276daf66] + SpecialFunctions v2.7.1
  [aedffcd0] + Static v1.3.1
  [0d7ed370] + StaticArrayInterface v1.9.0
  [1e83bf80] + StaticArraysCore v1.4.4
  [ec057cc2] + StructUtils v2.7.1
  [3783bdb8] + TableTraits v1.0.1
  [bd369af6] + Tables v1.12.1
  [1986cc42] + Unitful v1.28.0
  [6fb2a4bd] + UnitfulAngles v0.7.2
  [e17b2a0c] + UnsafePointers v1.0.0
  [efe28fd5] + OpenSpecFun_jll v0.5.6+0
  [f8abcde7] + micromamba_jll v2.3.1+0
  [4d7b5844] + pixi_jll v0.41.3+0
  [0dad84c5] + ArgTools v1.1.2
  [56f22d72] + Artifacts v1.11.0
  [2a0f44e3] + Base64 v1.11.0
  [ade2ca70] + Dates v1.11.0
  [f43a241f] + Downloads v1.7.0
  [7b1f6079] + FileWatching v1.11.0
  [b77e0a4c] + InteractiveUtils v1.11.0
  [ac6e5ff7] + JuliaSyntaxHighlighting v1.12.0
  [4af54fe1] + LazyArtifacts v1.11.0
  [b27032c2] + LibCURL v0.6.4
  [76f85450] + LibGit2 v1.11.0
  [8f399da3] + Libdl v1.11.0
  [37e2e46d] ~ LinearAlgebra ⇒ v1.12.0
  [56ddb016] + Logging v1.11.0
  [d6f4376e] + Markdown v1.11.0
  [ca575930] + NetworkOptions v1.3.0
  [44cfe95a] + Pkg v1.12.1
  [de0858da] + Printf v1.11.0
  [9a3f8284] + Random v1.11.0
  [ea8e919c] + SHA v0.7.0
  [9e88b42a] + Serialization v1.11.0
  [2f01184e] + SparseArrays v1.12.0
  [f489334b] + StyledStrings v1.11.0
  [fa267f1f] + TOML v1.0.3
  [a4e569a6] + Tar v1.10.0
  [8dfed614] + Test v1.11.0
  [cf7118a7] + UUIDs v1.11.0
  [4ec0a83e] + Unicode v1.11.0
  [e66e0078] + CompilerSupportLibraries_jll v1.3.0+1
  [deac9b47] + LibCURL_jll v8.15.0+0
  [e37daf67] + LibGit2_jll v1.9.0+0
  [29816b5a] + LibSSH2_jll v1.11.3+1
  [14a3606d] + MozillaCACerts_jll v2025.11.4
  [4536629a] + OpenBLAS_jll v0.3.29+0
  [05823500] + OpenLibm_jll v0.8.7+0
  [458c3c95] ~ OpenSSL_jll ⇒ v3.5.4+0
  [bea87d4a] + SuiteSparse_jll v7.8.3+2
  [83775a58] + Zlib_jll v1.3.1+2
  [8e850b90] + libblastrampoline_jll v5.15.0+0
  [8e850ede] + nghttp2_jll v1.64.0+1
  [3f19e933] + p7zip_jll v17.7.0+0
        Info Packages marked with ⌅ have new versions available but compatibility constraints restrict them from upgrading. To see why use `status --outdated -m`
   Resolving package versions...

     Project No packages added to or removed from `~/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/julia_env/Project.toml`
    Manifest No packages added to or removed from `~/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/julia_env/Manifest.toml`

Precompiling

 packages...



   1534.5 ms  ✓ DataValueInterfaces
   1531.4 ms  ✓ IfElse
   1532.8 ms  ✓ DocStringExtensions

    689.8 ms  ✓ IteratorInterfaceExtensions
    765.4 ms  ✓ UnsafePointers
   2445.7 ms  ✓ OrderedCollections

    617.9 ms  ✓ CommonWorldInvalidations

    922.1 ms  ✓ DataAPI

   1246.0 ms  ✓ ADTypes
    955.2 ms  ✓ SciMLPublic
   4293.0 ms  ✓ IrrationalConstants

   3127.4 ms  ✓ ConstructionBase

    901.8 ms  ✓ StaticArraysCore

   1676.8 ms  ✓ Requires

    813.9 ms  ✓ Scratch

   2893.1 ms  ✓ NaNMath

   3403.5 ms  ✓ StructUtils
   1185.7 ms  ✓ Preferences

    847.3 ms  ✓ TableTraits
   1228.0 ms  ✓ Pidfile

   6912.6 ms  ✓ MacroTools

   3261.9 ms  ✓ Compat
    891.5 ms  ✓ ConstructionBase → ConstructionBaseLinearAlgebraExt

   1147.1 ms  ✓ LogExpFunctions

    892.5 ms  ✓ ADTypes → ADTypesConstructionBaseExt
    817.1 ms  ✓ DiffResults

    756.4 ms  ✓ Adapt

    741.8 ms  ✓ StructUtils → StructUtilsStaticArraysCoreExt

    872.5 ms  ✓ PrecompileTools

    995.8 ms  ✓ JLLWrappers

   1028.0 ms  ✓ CommonSubexpressions
    825.9 ms  ✓ Compat → CompatLinearAlgebraExt

   4066.9 ms  ✓ DifferentiationInterface

   1173.8 ms  ✓ Adapt → AdaptSparseArraysExt

   3584.4 ms  ✓ Tables

   2689.8 ms  ✓ ArrayInterface

   1857.9 ms  ✓ micromamba_jll

   2251.0 ms  ✓ pixi_jll

   1349.3 ms  ✓ OpenSpecFun_jll

   9411.0 ms  ✓ Static

   3043.2 ms  ✓ DataStructures

   4040.1 ms  ✓ Functors
   4926.0 ms  ✓ ChainRulesCore

    961.6 ms  ✓ StructUtils → StructUtilsTablesExt
   1217.4 ms  ✓ DifferentiationInterface → DifferentiationInterfaceSparseArraysExt

  15005.6 ms  ✓ SparseMatrixColorings
    893.7 ms  ✓ ArrayInterface → ArrayInterfaceStaticArraysCoreExt

   1221.9 ms  ✓ ArrayInterface → ArrayInterfaceSparseArraysExt

   3953.3 ms  ✓ MicroMamba

   5611.2 ms  ✓ SpecialFunctions

   1074.5 ms  ✓ ADTypes → ADTypesChainRulesCoreExt

   3859.2 ms  ✓ ChainRulesCore → ChainRulesCoreSparseArraysExt

   1229.8 ms  ✓ DifferentiationInterface → DifferentiationInterfaceChainRulesCoreExt

   3098.6 ms  ✓ LogExpFunctions → LogExpFunctionsChainRulesCoreExt

   1284.6 ms  ✓ ArrayInterface → ArrayInterfaceChainRulesCoreExt
  27524.8 ms  ✓ Parsers

   1810.7 ms  ✓ DifferentiationInterface → DifferentiationInterfaceSparseMatrixColoringsExt

   1897.8 ms  ✓ DiffRules

   4645.8 ms  ✓ SpecialFunctions → SpecialFunctionsChainRulesCoreExt

   9808.2 ms  ✓ ForwardDiff

  47694.8 ms  ✓ Unitful

  11669.0 ms  ✓ JSON
   1018.2 ms  ✓ Unitful → ConstructionBaseUnitfulExt

   1258.4 ms  ✓ Unitful → PrintfExt

   1257.4 ms  ✓ Unitful → ForwardDiffExt
   1271.4 ms  ✓ Unitful → NaNMathExt

  24966.0 ms  ✓ StaticArrayInterface

   3528.5 ms  ✓ DifferentiationInterface → DifferentiationInterfaceForwardDiffExt

   1030.6 ms  ✓ ComponentArrays
   1833.3 ms  ✓ UnitfulAngles

   1841.5 ms  ✓ OpenMDAOCore

   4862.2 ms  ✓ CondaPkg

   1367.9 ms  ✓ MyParaboloidPackage

  20501.1 ms  ✓ PythonCall
  74 dependencies successfully precompiled in 81 seconds. 33 already precompiled.
  2 dependencies had output during precompilation:
┌ MicroMamba
│   Downloading artifact: micromamba
└  
┌ CondaPkg
│   Downloading artifact: pixi
└  

     Project No packages added to or removed from `~/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/julia_env/Project.toml`
    Manifest No packages added to or removed from `~/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/julia_env/Manifest.toml`

Detected IPython. Loading juliacall extension. See https://juliapy.github.io/PythonCall.jl/stable/compat/#IPython

Now we have a OpenMDAO Component that we can use. Let’s try it out, following the Paraboloid example from the OpenMDAO docs:

import openmdao.api as om

model = om.Group()
model.add_subsystem('parab_comp', comp)

prob = om.Problem(model)

prob.model.add_design_var("parab_comp.x")
prob.model.add_design_var("parab_comp.y")
prob.model.add_objective("parab_comp.f_xy")

prob.driver = om.ScipyOptimizeDriver()
prob.driver.options["optimizer"] = "SLSQP"

prob.setup(force_alloc_complex=True)

prob.set_val("parab_comp.x", 3.0)
prob.set_val("parab_comp.y", -4.0)

prob.run_model()
print(prob["parab_comp.f_xy"])  # Should print `[-15.]`

prob.set_val("parab_comp.x", 5.0)
prob.set_val("parab_comp.y", -2.0)

prob.run_model()
print(prob.get_val("parab_comp.f_xy"))  # Should print `[-5.]`

-15.0
-5.0

Looks good so far. A few things to note:

  • We added the JuliaExplicitComp to the Group in the normal way.

  • The variable names exposed to OpenMDAO match what was used in the input and output ComponentVectors passed to the DenseADExplicitComp constructor.

  • prob.set_val and prob.get_val worked just like usual.

We can also check our derivatives using the usual OpenMDAO methods. We can do that with the finite difference method:

print(prob.check_partials(method="fd"))

------------------------------------------------------------------------------
Component: JuliaExplicitComp 'parab_comp'
------------------------------------------------------------------------------

  parab_comp: 'f_xy' wrt 'x'

    Max Tolerance Violation (Jfwd - Jfd) - (atol + rtol * Jfd) : (-9.996325e-07)
      abs error: 1.000368e-06
      rel error: 5.001840e-07
      fwd value @ max viol: 2.000000e+00
      fd value @ max viol: 2.000001e+00 (fd:forward)

    Raw Forward Derivative (Jfwd)
    [[ 2.000000000000e+00]]

    Raw FD Derivative (Jfd)
    [[ 2.000001000368e+00]]

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  parab_comp: 'f_xy' wrt 'y'

    Max Tolerance Violation (Jfwd - Jfd) - (atol + rtol * Jfd) : (-7.999542e-06)
      abs error: 1.000459e-06
      rel error: 1.111621e-07
      fwd value @ max viol: 9.000000e+00
      fd value @ max viol: 9.000001e+00 (fd:forward)

    Raw Forward Derivative (Jfwd)
    [[ 9.000000000000e+00]]

    Raw FD Derivative (Jfd)
    [[ 9.000001000459e+00]]

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


{'parab_comp': {('f_xy', 'x'): {'J_fwd': array([[2.]]), 'J_fd': array([[2.000001]]), 'rows': None, 'cols': None, 'tol violation': _ErrorData(forward=-9.99632543852158e-07, reverse=None, fwd_rev=None), 'magnitude': _MagnitudeData(forward=2.0, reverse=0.0, fd=2.0000010003684565), 'vals_at_max_error': _ErrorData(forward=(np.float64(2.0), np.float64(2.0000010003684565)), reverse=None, fwd_rev=None), 'abs error': _ErrorData(forward=1.0003684565162985e-06, reverse=None, fwd_rev=None), 'rel error': _ErrorData(forward=5.001839780740122e-07, reverse=None, fwd_rev=None)}, ('f_xy', 'y'): {'J_fwd': array([[9.]]), 'J_fd': array([[9.000001]]), 'rows': None, 'cols': None, 'tol violation': _ErrorData(forward=-7.999542276593274e-06, reverse=None, fwd_rev=None), 'magnitude': _MagnitudeData(forward=9.0, reverse=0.0, fd=9.000001000458724), 'vals_at_max_error': _ErrorData(forward=(np.float64(9.0), np.float64(9.000001000458724)), reverse=None, fwd_rev=None), 'abs error': _ErrorData(forward=1.0004587238654494e-06, reverse=None, fwd_rev=None), 'rel error': _ErrorData(forward=1.1116206807248763e-07, reverse=None, fwd_rev=None)}}}

Or we could use the complex-step method:

print(prob.check_partials(method="cs"))

------------------------------------------------------------------------------
Component: JuliaExplicitComp 'parab_comp'
------------------------------------------------------------------------------

  parab_comp: 'f_xy' wrt 'x'

    Max Tolerance Violation (Jfwd - Jfd) - (atol + rtol * Jfd) : (-2.000000e-06)
      abs error: 0.000000e+00
      rel error: 0.000000e+00
      fwd value @ max viol: 2.000000e+00
      fd value @ max viol: 2.000000e+00 (cs:None)

    Raw Forward Derivative (Jfwd)
    [[ 2.000000000000e+00]]

    Raw CS Derivative (Jfd)
    [[ 2.000000000000e+00]]

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  parab_comp: 'f_xy' wrt 'y'

    Max Tolerance Violation (Jfwd - Jfd) - (atol + rtol * Jfd) : (-9.000000e-06)
      abs error: 0.000000e+00
      rel error: 0.000000e+00
      fwd value @ max viol: 9.000000e+00
      fd value @ max viol: 9.000000e+00 (cs:None)

    Raw Forward Derivative (Jfwd)
    [[ 9.000000000000e+00]]

    Raw CS Derivative (Jfd)
    [[ 9.000000000000e+00]]

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -


{'parab_comp': {('f_xy', 'x'): {'J_fwd': array([[2.]]), 'J_fd': array([[2.]]), 'rows': None, 'cols': None, 'tol violation': _ErrorData(forward=-2e-06, reverse=None, fwd_rev=None), 'magnitude': _MagnitudeData(forward=2.0, reverse=0.0, fd=2.0), 'vals_at_max_error': _ErrorData(forward=(np.float64(2.0), np.float64(2.0)), reverse=None, fwd_rev=None), 'abs error': _ErrorData(forward=0.0, reverse=None, fwd_rev=None), 'rel error': _ErrorData(forward=0.0, reverse=None, fwd_rev=None)}, ('f_xy', 'y'): {'J_fwd': array([[9.]]), 'J_fd': array([[9.]]), 'rows': None, 'cols': None, 'tol violation': _ErrorData(forward=-9e-06, reverse=None, fwd_rev=None), 'magnitude': _MagnitudeData(forward=9.0, reverse=0.0, fd=9.0), 'vals_at_max_error': _ErrorData(forward=(np.float64(9.0), np.float64(9.0)), reverse=None, fwd_rev=None), 'abs error': _ErrorData(forward=0.0, reverse=None, fwd_rev=None), 'rel error': _ErrorData(forward=0.0, reverse=None, fwd_rev=None)}}}

The derivatives look great, so let’s try an optimization:

prob.run_driver()
print(f"f_xy = {prob.get_val('parab_comp.f_xy')}")  # Should print `[-27.333333]`
print(f"x = {prob.get_val('parab_comp.x')}")  # Should print `[6.666666]`
print(f"y = {prob.get_val('parab_comp.y')}")  # Should print `[-7.333333]`

Optimization terminated successfully    (Exit mode 0)
            Current function value: -27.333333333333336
            Iterations: 4
            Function evaluations: 5
            Gradient evaluations: 4
Optimization Complete
-----------------------------------
f_xy = -27.333333333333336
x = 6.666666666666666
y = -7.333333333333333

Victory!

Next Steps#

We’ve shown how to put together a simple OpenMDAO Component using Julia and OpenMDAO.jl. OpenMDAO.jl has more features that you can explore in docs. Some things we haven’t covered:

Contents