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.45.0)
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.6)
Requirement already satisfied: packaging in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from openmdao[julia]) (26.2)
Requirement already satisfied: requests in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from openmdao[julia]) (2.34.2)
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.0)
Requirement already satisfied: omjlcomps>=0.2.6 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from openmdao[julia]) (0.2.7)
Requirement already satisfied: juliapkg~=0.1.10 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from omjlcomps>=0.2.6->openmdao[julia]) (0.1.24)
Requirement already satisfied: juliacall~=0.9.13 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from omjlcomps>=0.2.6->openmdao[julia]) (0.9.35)
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.29.4)
Requirement already satisfied: semver<4.0,>=3.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]) (3.0.4)
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.1)
Requirement already satisfied: tomlkit<0.16,>=0.13.3 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]) (0.15.1)
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.7)
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.18)
Requirement already satisfied: urllib3<3,>=1.26 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from requests->openmdao[julia]) (2.7.0)
Requirement already satisfied: certifi>=2023.5.7 in /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/lib/python3.13/site-packages (from requests->openmdao[julia]) (2026.6.17)

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/_executed_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/juliacall/juliapkg.json
[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/.pixi/envs/dev/lib/python3.13/site-packages/juliapkg/juliapkg.json
[juliapkg] Found dependencies: /home/runner/work/OpenMDAO/OpenMDAO/openmdao/docs/_executed_book/features/experimental/juliapkg.json
[juliapkg] Locating Julia ^1.10.3
[juliapkg] Using Julia 1.12.6 at /opt/hostedtoolcache/julia/1.12.6/x64/bin/julia
[juliapkg] Finding libjulia:
           | using Libdl
           | print(abspath(Libdl.dlpath("libjulia")))

[juliapkg] Using Julia project at /home/runner/work/OpenMDAO/OpenMDAO/.pixi/envs/dev/julia_env
[juliapkg] Writing Project.toml:
           | [deps]
           | PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"
           | OpenSSL_jll = "458c3c95-2e84-50aa-8efc-19380b2a3a95"
           | OpenMDAOCore = "24d19c10-6eee-420f-95df-4537264b2753"
           | LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
           | MyParaboloidPackage = "a013c6e3-dc76-40b3-894d-62618f778e16"
           | 
           | [compat]
           | PythonCall = "=0.9.35"
           | OpenSSL_jll = "3.0.0 - 3.6"
           | OpenMDAOCore = "^0.3.2"
[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/_executed_book/features/experimental/MyParaboloidPackage"),
           | ])
           | Pkg.add([
           |   Pkg.PackageSpec(name="PythonCall", uuid="6099a3de-0909-46bc-b1f4-468b9a2dfc0d"),
           |   Pkg.PackageSpec(name="OpenSSL_jll", uuid="458c3c95-2e84-50aa-8efc-19380b2a3a95"),
           |   Pkg.PackageSpec(name="OpenMDAOCore", uuid="24d19c10-6eee-420f-95df-4537264b2753"),
           |   Pkg.PackageSpec(name="LinearAlgebra", uuid="37e2e46d-f89d-539d-b4ee-838fcccc9c8e"),
           | ])
           | 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 DiffRules ─────────────────── v1.16.0
   Installed Adapt ─────────────────────── v4.7.0
   Installed Functors ──────────────────── v0.5.2
   Installed JSON ──────────────────────── v1.6.1
   Installed MicroMamba ────────────────── v0.1.15
   Installed IrrationalConstants ───────── v0.2.6
   Installed PythonCall ────────────────── v0.9.35
   Installed SciMLPublic ───────────────── v1.2.3
   Installed TableTraits ───────────────── v1.0.1
   Installed DiffResults ───────────────── v1.1.0
   Installed ADTypes ───────────────────── v1.22.2
   Installed Tables ────────────────────── v1.13.0
   Installed Parsers ───────────────────── v2.8.6
   Installed DataAPI ───────────────────── v1.16.0
   Installed SpecialFunctions ──────────── v2.8.0
   Installed Unitful ───────────────────── v1.28.0

   Installed IfElse ────────────────────── v0.1.1
   Installed Preferences ───────────────── v1.5.2
   Installed micromamba_jll ────────────── v2.3.1+0
   Installed Pidfile ───────────────────── v1.3.0
   Installed NaNMath ───────────────────── v1.1.4
   Installed IteratorInterfaceExtensions ─ v1.0.0
   Installed DataValueInterfaces ───────── v1.0.0
   Installed ConstructionBase ──────────── v1.6.0
   Installed OrderedCollections ────────── v1.8.2
   Installed ArrayInterface ────────────── v7.27.0
   Installed UnitfulAngles ─────────────── v0.7.2
   Installed ForwardDiff ───────────────── v1.4.1
   Installed CommonSubexpressions ──────── v0.3.1
   Installed LogExpFunctions ───────────── v1.0.1
   Installed JLLWrappers ───────────────── v1.8.0
   Installed PrecompileTools ───────────── v1.3.4

   Installed StaticArraysCore ──────────── v1.4.4
   Installed UnsafePointers ────────────── v1.0.0
   Installed OpenSpecFun_jll ───────────── v0.5.6+0
   Installed CommonWorldInvalidations ──── v1.1.1
   Installed SparseMatrixColorings ─────── v0.4.27
   Installed Static ────────────────────── v1.4.4
   Installed CondaPkg ──────────────────── v0.2.36
   Installed DataStructures ────────────── v0.18.22
   Installed MacroTools ────────────────── v0.5.16
   Installed DifferentiationInterface ──── v0.7.20

   Installed pixi_jll ──────────────────── v0.63.2+0
   Installed StructUtils ───────────────── v2.8.2
   Installed DocStringExtensions ───────── v0.9.5
   Installed OpenMDAOCore ──────────────── v0.3.3
   Installed Compat ────────────────────── v4.18.1
   Installed StaticArrayInterface ──────── v1.10.0
   Installed ChainRulesCore ────────────── v1.26.1
   Installed ComponentArrays ───────────── v0.15.42

  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/_executed_book/features/experimental/MyParaboloidPackage`
  [24d19c10] + OpenMDAOCore v0.3.3
  [6099a3de] + PythonCall v0.9.35
  [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.22.2
  [79e6a3ab] + Adapt v4.7.0
  [4fba245c] + ArrayInterface v7.27.0
  [d360d2e6] + ChainRulesCore v1.26.1
  [bbf7d656] + CommonSubexpressions v0.3.1
  [f70d9fcc] + CommonWorldInvalidations v1.1.1
  [34da2185] + Compat v4.18.1
  [b0b7db55] + ComponentArrays v0.15.42
  [992eb4ea] + CondaPkg v0.2.36
  [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.16.0
  [a0c0ee7d] + DifferentiationInterface v0.7.20
  [ffbed154] + DocStringExtensions v0.9.5
  [f6369f11] + ForwardDiff v1.4.1
  [d9f16b24] + Functors v0.5.2
  [615f187c] + IfElse v0.1.1
  [92d709cd] + IrrationalConstants v0.2.6
  [82899510] + IteratorInterfaceExtensions v1.0.0
  [692b3bcd] + JLLWrappers v1.8.0
  [682c06a0] + JSON v1.6.1
  [2ab3a3ac] + LogExpFunctions v1.0.1
  [1914dd2f] + MacroTools v0.5.16
  [0b3b1443] + MicroMamba v0.1.15
  [a013c6e3] + MyParaboloidPackage v0.1.0 `~/work/OpenMDAO/OpenMDAO/openmdao/docs/_executed_book/features/experimental/MyParaboloidPackage`
  [77ba4419] + NaNMath v1.1.4
  [24d19c10] + OpenMDAOCore v0.3.3
⌅ [bac558e1] + OrderedCollections v1.8.2
  [69de0a69] + Parsers v2.8.6
  [fa939f87] + Pidfile v1.3.0
  [aea7be01] + PrecompileTools v1.3.4
  [21216c6a] + Preferences v1.5.2
  [6099a3de] + PythonCall v0.9.35
  [431bcebd] + SciMLPublic v1.2.3
  [6c6a2e73] + Scratch v1.3.0
  [0a514795] + SparseMatrixColorings v0.4.27
  [276daf66] + SpecialFunctions v2.8.0
  [aedffcd0] + Static v1.4.4
  [0d7ed370] + StaticArrayInterface v1.10.0
  [1e83bf80] + StaticArraysCore v1.4.4
  [ec057cc2] + StructUtils v2.8.2
  [3783bdb8] + TableTraits v1.0.1
  [bd369af6] + Tables v1.13.0
  [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.63.2+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...

   1157.8 ms  ✓ DataValueInterfaces
   1188.0 ms  ✓ IfElse

   1383.3 ms  ✓ DocStringExtensions

   1135.1 ms  ✓ UnsafePointers
    949.4 ms  ✓ Adapt

   1037.3 ms  ✓ IteratorInterfaceExtensions

   1494.6 ms  ✓ CommonWorldInvalidations

   1386.9 ms  ✓ DataAPI

   5681.1 ms  ✓ OrderedCollections
   4627.6 ms  ✓ ConstructionBase

   6748.8 ms  ✓ IrrationalConstants
   2084.8 ms  ✓ ADTypes

   1384.0 ms  ✓ SciMLPublic

   1457.3 ms  ✓ StaticArraysCore

   1541.7 ms  ✓ Scratch

   4596.4 ms  ✓ NaNMath

   5410.8 ms  ✓ StructUtils

   9638.8 ms  ✓ MacroTools
   1354.5 ms  ✓ Pidfile

   2471.2 ms  ✓ Preferences
   5145.0 ms  ✓ Compat

    948.3 ms  ✓ ConstructionBase → ConstructionBaseLinearAlgebraExt
   1127.2 ms  ✓ TableTraits
   1565.4 ms  ✓ Adapt → AdaptSparseArraysExt

    942.0 ms  ✓ ADTypes → ADTypesConstructionBaseExt

   1721.7 ms  ✓ LogExpFunctions

   1233.3 ms  ✓ DiffResults

   4403.6 ms  ✓ ArrayInterface
   1413.9 ms  ✓ StructUtils → StructUtilsStaticArraysCoreExt

   1854.5 ms  ✓ CommonSubexpressions

   1493.5 ms  ✓ PrecompileTools

   1724.6 ms  ✓ JLLWrappers

   1110.1 ms  ✓ Compat → CompatLinearAlgebraExt

   5580.8 ms  ✓ DifferentiationInterface

   1553.2 ms  ✓ ArrayInterface → ArrayInterfaceSparseArraysExt
   1183.4 ms  ✓ ArrayInterface → ArrayInterfaceStaticArraysCoreExt

   5704.1 ms  ✓ Tables

   3261.8 ms  ✓ micromamba_jll

   2736.0 ms  ✓ pixi_jll

   1148.9 ms  ✓ OpenSpecFun_jll

   5370.9 ms  ✓ DataStructures

  23707.8 ms  ✓ SparseMatrixColorings

  25261.6 ms  ✓ Parsers

   9149.1 ms  ✓ ChainRulesCore

   2016.4 ms  ✓ DifferentiationInterface → DifferentiationInterfaceSparseArraysExt

   1490.7 ms  ✓ StructUtils → StructUtilsTablesExt

   5646.4 ms  ✓ Functors

   5639.2 ms  ✓ MicroMamba
   2921.6 ms  ✓ DifferentiationInterface → DifferentiationInterfaceSparseMatrixColoringsExt

   7059.9 ms  ✓ SpecialFunctions

   1385.3 ms  ✓ ADTypes → ADTypesChainRulesCoreExt

   4996.9 ms  ✓ ChainRulesCore → ChainRulesCoreSparseArraysExt

   1366.4 ms  ✓ ArrayInterface → ArrayInterfaceChainRulesCoreExt

   1911.0 ms  ✓ DifferentiationInterface → DifferentiationInterfaceChainRulesCoreExt

   5594.0 ms  ✓ LogExpFunctions → LogExpFunctionsChainRulesCoreExt

   2607.7 ms  ✓ DiffRules

   5393.9 ms  ✓ SpecialFunctions → SpecialFunctionsChainRulesCoreExt

  17934.5 ms  ✓ JSON

  69788.1 ms  ✓ Unitful

   1773.4 ms  ✓ Unitful → ConstructionBaseUnitfulExt
   1790.1 ms  ✓ Unitful → PrintfExt

  57527.0 ms  ✓ Static

  14453.6 ms  ✓ ForwardDiff

   1684.0 ms  ✓ Unitful → NaNMathExt

  10049.3 ms  ✓ CondaPkg

   2116.1 ms  ✓ Unitful → ForwardDiffExt

   4366.1 ms  ✓ UnitfulAngles

   4263.2 ms  ✓ DifferentiationInterface → DifferentiationInterfaceForwardDiffExt
   4914.3 ms  ✓ StaticArrayInterface

   1466.9 ms  ✓ ComponentArrays

   3066.6 ms  ✓ OpenMDAOCore

   2319.9 ms  ✓ MyParaboloidPackage

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

     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