SymbolicAWEModels

Overview

SymbolicAWEModels.jl is a compiler for mechanical systems, built for Airborne Wind Energy (AWE) modelling. It takes a structural description of a system — defined in Julia code or a YAML file — and compiles it into an efficient ODE problem using ModelingToolkit.jl.

 Define Components         Assemble             Compile            Simulate
┌──────────────────┐    ┌──────────────┐     ┌─────────────────┐     ┌────────────┐
│ Point, Segment,  │───▶│ System       │────▶│ SymbolicAWE     │────▶│ init!()    │
│ Wing, Winch, ... │    │ Structure    │     │ Model           │     │ next_step! │
│                  │    │              │     │ (symbolic eqs → │     │ sim!()     │
│ Julia or YAML    │    │ (resolves    │     │  ODEProblem)    │     │            │
│                  │    │  references) │     │                 │     │            │
└──────────────────┘    └──────────────┘     └─────────────────┘     └────────────┘

The first compilation is slow (minutes) as ModelingToolkit generates and simplifies the symbolic equations. The result is cached to a binary file, making subsequent runs fast (seconds).

What can it model?

SymbolicAWEModels provides building blocks for flexible mechanical systems:

• Point masses — static, dynamic, or quasi-static nodes
• Segment spring-dampers — with per-unit-length stiffness, damping, and drag
• Tethers — collections of segments controlled by a winch
• Winches — torque-controlled motors with Coulomb and viscous friction
• Pulleys — equal-tension constraints between segments
• Wings — rigid body quaternion dynamics with aerodynamic forces from the Vortex Step Method
• Groups — twist degrees of freedom for aeroelastic coupling
• Transforms — spherical coordinate positioning of components

These components can be combined to model a wide range of systems, from simple hanging masses to complex kite power systems with multiple tethers, bridles, and wings.

---

Quick Start

Install Julia using juliaup:

curl -fsSL https://install.julialang.org | sh
juliaup add release
juliaup default release

Create a project and add SymbolicAWEModels:

mkdir my_project && cd my_project
julia --project="."

using Pkg
pkg"add SymbolicAWEModels"
pkg"add GLMakie"

Minimal example — a pendulum

using SymbolicAWEModels
using SymbolicAWEModels: Point
using GLMakie
using KiteUtils: init!, next_step!
SymbolicAWEModels.copy_data()
set_data_path("data/base")

set = Settings("system.yaml")
set.v_wind = 0.0

# Define components using symbolic names
points = [
    Point(:anchor, [0, 0, 0], STATIC; transform=:tf),
    Point(:mass, [0, 0, -50], DYNAMIC; extra_mass=1.0, transform=:tf),
]
segments = [Segment(:spring, :anchor, :mass,
    614600.0, 473.0, 0.004)]
transforms = [Transform(:tf, deg2rad(-70), 0.0, 0.0;
    base_pos=[0, 0, 50], base_point=:anchor, rot_point=:mass)]

# Assemble and compile
sys = SystemStructure("pendulum", set; points, segments, transforms)
sam = SymbolicAWEModel(set, sys)
init!(sam)
plot(sam.sys_struct)

# Simulate with live visualization
dt = 0.05
for _ in 1:500
    t_start = time()
    next_step!(sam; dt)
    plot!(sam.sys_struct)
    sleep(max(0, dt - (time() - t_start)))
end

For the full tutorial, see Building a System using Julia. For YAML-based model definition, see Building a System using YAML.

Note: The first run will be slow (several minutes) due to compilation. Subsequent runs will be much faster thanks to binary caching.

See the Getting Started Guide for detailed instructions.

---

Kite Models

SymbolicAWEModels provides the building blocks for assembling kite models from YAML or Julia constructors. Ready-to-use kite models live in dedicated packages:

• RamAirKite.jl — Ram air kite with bridle system, 4-tether steering, and deformable wing groups
• V3Kite.jl — TU Delft V3 leading-edge-inflatable kite, YAML-based configuration

2-Plate Kite Example

A minimal coupled aero-structural model included in data/2plate_kite/:

using SymbolicAWEModels, VortexStepMethod, GLMakie
using SymbolicAWEModels: Point
using KiteUtils: init!, next_step!
SymbolicAWEModels.copy_data()

set_data_path("data/2plate_kite")

struc_yaml = joinpath(get_data_path(),
    "refine_struc_geometry.yaml")

# Load settings and VSM configuration
set = Settings("system.yaml")
vsm_set = VortexStepMethod.VSMSettings(
    joinpath(get_data_path(), "vsm_settings.yaml");
    data_prefix=false)

# Build system structure from YAML
sys = load_sys_struct_from_yaml(struc_yaml;
    system_name="2plate_kite", set, vsm_set)
sys.segments[:kcu_steering_right].l0 += 0.1
sys.segments[:kcu_steering_left].l0 -= 0.1
sys.winches[:main_winch].brake = true

sam = SymbolicAWEModel(set, sys)
init!(sam; remake=false, lin_vsm=false)
plot(sam.sys_struct)

# Simulate with live visualization
dt = 0.01
for step in 1:1000
    t_start = time()
    next_step!(sam; dt, vsm_interval=1)
    plot!(sam.sys_struct)
    sleep(max(0, dt - (time() - t_start)))
end

Running examples

Copy examples to your project and run the interactive menu:

using SymbolicAWEModels
using GLMakie
SymbolicAWEModels.copy_data()
SymbolicAWEModels.copy_examples()
include("examples/menu.jl")

using GLMakie enables the built-in plotting extension. See the Examples page for details.

---

Testing

Each component is tested in isolation using minimal models built from constructors, with results verified against analytical solutions. This proves that the underlying dynamics are physically correct — for example, that angular momentum is conserved, that terminal velocity matches the analytical prediction, and that spring-damper forces follow the expected constitutive law.

# Run all tests
julia --project=. -e 'using Pkg; Pkg.test()'

# Run a specific test file
julia --project=test test/test_point.jl

Test file	What it verifies
test_point	Gravity free-fall, damping, quasi-static equilibrium
test_segment	Spring-damper forces, stiffness, drag
test_wing	QUATERNION and REFINE wing construction, VSM coupling
test_wing_dynamics	Rigid body torque response, precession, angular momentum
test_tether_winch	Reel-out, Coulomb/viscous friction, terminal velocity
test_pulley	Equal-tension constraints, multi-segment pulleys
test_transform	Spherical coordinate positioning
test_quaternion_conversions	Quaternion ↔ rotation matrix
test_quaternion_auto_groups	Auto-generated twist DOFs
test_principal_body_frame	Principal vs body frame separation
test_heading_calculation	Kite heading from tether geometry
test_section_alignment	VSM section ↔ structural point mapping
test_match_aero_sections	Asymmetric aero/structural section matching, polar interpolation
test_profile_law	Atmospheric wind profile verification
test_bench	Performance regression tracking

---

Ecosystem

Key related packages:

• RamAirKite.jl — ram air kite model
• V3Kite.jl — TU Delft V3 kite model
• KiteUtils.jl — shared types and utilities
• VortexStepMethod.jl — aerodynamic solver
• AtmosphericModels.jl — wind profiles
• KiteModels.jl — non-symbolic, predefined kite models
• KiteSimulators.jl — meta-package
• KiteControllers.jl — control algorithms

Visualisation uses the built-in GLMakie extension (ext/SymbolicAWEModelsMakieExt.jl) — just using GLMakie to enable plotting.

• Research Fechner — scientific background for winches and tethers

---

Questions?

• Submit an issue
• Start a discussion
• Ask on Julia Discourse
• Email Bart van de Lint: bart@vandelint.net

Authors: Bart van de Lint (bart@vandelint.net) Uwe Fechner (uwe.fechner.msc@gmail.com) Jelle Poland

---

License

This project is licensed under the MPL-2.0 License.

---

Citing SymbolicAWEModels

If you use SymbolicAWEModels in your research, please cite this repository:

@misc{SymbolicAWEModels,
  author = {Bart van de Lint, Uwe Fechner, Jelle Poland},
  title = {{SymbolicAWEModels}: Symbolic airborne wind energy system models},
  year = {2025},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{[https://github.com/OpenSourceAWE/SymbolicAWEModels.jl]}},
}

Copyright Notice

Technische Universiteit Delft hereby disclaims all copyright interest in the package "SymbolicAWEModels.jl" (symbolic models for airborne wind energy systems) written by the Author(s).

Prof.dr. H.G.C. (Henri) Werij, Dean of Aerospace Engineering, Technische Universiteit Delft.

See copyright notices in the source files and the list of authors in AUTHORS.md.