Robot Dragonfly Prototype: Dissected, Simulated and Built

The short answer

Dragon Flycore is an engineering concept of a security robot dragonfly: four flapping wings for lift, an electric ducted fan in the chest that pushes air out of the tail, four small thrusters on the legs, folding wings and two scanning cameras. It was built part by part in Blender at real scale, with working gears and linkages and a mass for every part.

• Simulate it in Unreal Engine 5 (Chaos physics, async physics tick) or Unity 6 (PhysX, fixed steps of 1 to 2 ms). Neither engine knows how a flapping wing makes lift, so you add a blade-element aerodynamics module: the code and a tested Python reference are below.
• Build a robot dragonfly prototype at 0.45 m long, 0.70 m span and about 300 g, close to the size of Festo’s flying BionicOpter (44 cm, 63 cm span, 175 g) [1]. The full 0.81 m, 1.73 kg concept loads each square metre of wing about six times harder than P1 does, too much for flapping wings.
• The turbines are electric ducted fans. The fire in the 3D model and the videos is a visualization of thrust: an electric fan blows plain, invisible air.

Dissect it in 3D

Press Play to load the robot (5.3 MB). Pick a part in the list or tap the model: the camera flies to it and a card explains what it does, with the part you would use on a real prototype. X-ray fades the shells so you can watch the gears and cranks turn, Explode pulls the subsystems apart, and the clip buttons switch between the seven flight modes.

Interactive 3D · GLB

Dissect Dragon Flycore in 3D

Seven flight clips with Blender-rendered thruster fire, 14 parts explained, X-ray and exploded views.

Play in 3D5.3 MB GLB · loads only when you press Play

Keys: 1 to 7 switch clips, Space pauses, X toggles X-ray, Esc closes the card. The wing beats play 16 times slower than real time so that a 24 Hz beat stays readable.

Concept and prototype: two machines

The Blender model is a concept: it answers “could every part fit and move?”. Every joint sits on its pin, the crank-rocker linkages are solved exactly (the rod length never changes by more than 0.00007 mm over a beat), and the mass of each of its more than 300 parts comes from its volume and material. The robot dragonfly prototype, P1, answers a different question: what can you build and fly with parts you can buy and print today?

Exploded view: the subsystems

Pulled apart along their mounting directions, the 15 subsystems show the logic of the layout: sensors forward, the heavy drive and battery in the thorax between the wing roots (the centre of gravity sits between the fore and hind wing roots), the long abdomen as a duct and a lever for the tail jet.

How it flies: the logic

The rule behind the whole design: the wings lift, the fan pushes. All thrusters together give 8.6 N, half the 17 N weight, so every mode with the wings folded is a short manoeuvre that lives on speed or height the robot already has. These are first-order hand calculations from the CAD files, not flight tests.

What real dragonflies teach the design

Dragonflies drive each of their four wings with their own muscles, beat the fore and hind pairs out of phase, and hover on an inclined stroke plane where drag, not lift, carries about three quarters of the weight [2]. The pterostigma, the dark cell near each wing tip, is a small weight that sets how the wing pitches [3]. The robot copies all three ideas: two drive trains, a 90° phase between the pairs, and a tungsten-filled pterostigma.

22 s · Commons

17 s · Commons

Every motor and turbine, dissected

The concept carries dozens of actuators, from the wing drives to the iris blades of its zoom lens. The table takes the ones that matter for flight and pairs each with the real part class that does the same job on P1. Masses are planning estimates for P1; weigh your parts.

1. The wing drive: motor, gears, crank-rocker

A brushless motor turns fast and weakly; a wing must swing slowly and strongly. The gearbox trades speed for torque (8.44:1 in the CAD, about 16:1 on P1), and the crank-rocker turns rotation into a back-and-forth swing. The two output gears mesh with each other, so they turn in opposite directions and the left and right wings are always exact mirror images: the stroke cannot roll the robot by accident. Roll comes from the feather servos instead.

13 s · Commons

Wing inertia is the hidden load. Each beat the wings stop and reverse, and the gears must carry that peak torque: about 0.8 N·m per wing pair on P1 at hover frequency and 1.7 N·m at 16 Hz. That energy goes out and comes back each stroke, so the motor mostly pays for the air. Insects store it in an elastic protein (resilin) at the hinge; a spring at the wing root does the same for a robot and lowers the gear load.

2. Feather, fold and paddle servos

Small servos change the shape of the stroke rather than drive it. Twisting the left wing up and the right wing down rolls the robot like ailerons; twisting both more on the downstroke than the upstroke makes a net vertical force, the paddling that lets a level body hover. The fold actuator uses a worm stage because a worm cannot be back-driven: it holds the wing open or folded with the power off.

14 s · Commons

The fold borrows from Grumman’s Sto-Wing [4]: any change of orientation is a single rotation about one axis, so one fixed, skewed pin can fold a wing back along the body. Dragon Flycore’s pins were solved to stand vertical at flap 0, with 14.8 mm of clearance along the whole swing.

3. The “turbines”: electric ducted fans and the fire

The chest fan is an electric ducted fan (EDF): a brushless motor spins a many-bladed rotor inside a duct, and fixed stator vanes behind it straighten the swirl into thrust. In the CAD the 7 rotor blades and 11 vanes are co-prime numbers, so no blade passes all the vanes at once and the tone stays lower. Its air splits like a turbofan’s: 47 g/s down the abdomen to the 22 mm tail nozzle (4.7 N), 35 g/s over the batteries and out through the slits under the first segment (1.6 N).

Why not a real turbine with real fire? The smallest model turbojets give about 24 N for roughly 350 g [5]: more than P1 weighs, with a hot exhaust, kerosene and a fire risk next to a film wing. A 30 mm EDF of about 12 g gives roughly 1 N at about 100 W (seller data) [6], which is 0.36 times P1’s weight, almost the same ratio as the concept’s 0.37. So the fire you see is drawn on purpose, shaped after real afterburner exhaust with its shock diamonds.

13 s · Commons

14 s · Commons

Four paddles at the nozzle exit turn the jet, as on NASA’s X-31 [7]: about 0.3° of jet per degree of paddle. Yaw in the turns, pitch in the climb.

4. Sensors, scanners and the brain

The wide camera sits on a 2-axis gimbal. In front of each lens a 2° glass wedge spins: two rotating wedges, or Risley prisms, steer a beam around a cone, the way some lidars scan. Each scanner projects a 650 nm laser line. For P1, a multizone time-of-flight chip of about a gram replaces the scanning optics, and a small camera module replaces the zoom lens.

23 s · Commons

Part A · Build a simulator in Unreal Engine 5 or Unity

A game engine gives you rigid bodies, joints, contacts and beautiful rendering. It does not know how a flapping wing makes lift: no engine does. So a flapping-robot simulator is an engine plus four modules you write: aerodynamics, actuators, power and sensors, with a flight controller in the loop.

Which software to use

Pick Unreal Engine 5 if the simulator is also a showcase (cinematic look, large outdoor maps, Niagara fire) or you want the AirSim heritage for sensors. Pick Unity for fast iteration in C#, the URDF importer and ML-Agents for training controllers. The physics that matters, the wing model, is the same in both.

The physics: a quasi-steady blade-element model

Cut each wing into 12 to 20 strips from root to tip. For every strip, every physics step:

1. Find how fast the strip moves through the air: flapping speed + the body’s velocity + its rotation, minus the downwash the wings push down.
2. Find the angle of attack α between that airflow and the wing’s chord.
3. Look up lift and drag coefficients measured on flapping wings [16]: C_L = 0.225 + 1.58 sin(2.13α − 7.2°), C_D = 1.92 − 1.55 cos(2.04α − 9.82°).
4. Force = ½ ρ U² × chord × strip width × C. Lift is normal to the airflow, drag is along it. Apply it at the strip’s quarter-chord point.

Two corrections make the numbers honest. The fruit-fly coefficients come from a tiny wing at a Reynolds number near 100; P1’s wing runs near 54,150, with a flexible film and a hind wing in the fore wing’s wake, and quasi-steady models are known to underestimate drag [17]. So the reference multiplies lift by 0.7 and drag by 1.25. It also adds the rotational lift of the flip at each stroke reversal [18] and a uniform downwash from momentum theory.

Time step: a 16 Hz beat needs at least 40 samples per stroke for stable forces, so run the aerodynamics at 1 to 2 kHz, on the physics thread. For a game that only needs the look, average the forces over one beat and apply them at 60 to 120 Hz.

Posture matters: with the flap hinges along the body, as on Dragon Flycore, symmetric feathering pushes along the body axis. Level, that is thrust; pitched nose-up, it is lift. The engine code below computes forces from the strip’s real motion and the wing’s real orientation, so it gets this right for any posture: it reproduces the reference exactly (4.283 N at 12 Hz) when the stroke plane is horizontal, and gives the forward thrust when the body is level.

Unity 6: FlycoreWingAero.cs

1. Import the robot. Put one Rigidbody on the body with the CAD mass and centre of mass (or import the URDF as ArticulationBodies).
2. Set Project Settings › Time › Fixed Timestep to 0.001–0.002 s, or switch to SimulationMode.Script and call Physics.Simulate in fixed sub-steps [19].
3. Drive the wing transforms from the animation clips or a crank script, then add this component to each of the four wings and set its span and chord axes.
4. Add an EDF thruster (thrust ∝ rpm² with a first-order lag of about 50 ms), servo rate limits and a battery model with voltage sag.

// FlycoreWingAero.cs - quasi-steady blade-element aerodynamics for one flapping wing (Unity 6, built-in PhysX).
// robotanimator.org, Dragon Flycore prototype guide. Port of flycore_quasi_steady.py: compare its printed numbers with your scene.
// Put it on the wing's Transform (animated by clips, a crank script or joints). It reads where each wing strip really moves,
// so it works in hover and in forward flight, and pushes the robot's Rigidbody with AddForceAtPosition.
// Left out on purpose (add them once the basics match your bench data): the rotational-lift term of the Python model, added mass, wing-wing interaction.
// Run physics fast enough for the beat: Project Settings > Time > Fixed Timestep = 0.001 to 0.002 s (500 to 1000 Hz).
using UnityEngine;

public class FlycoreWingAero : MonoBehaviour
{
    [Header("Wing geometry (metres, in this Transform's local axes)")]
    public Rigidbody body;                         // the robot's main Rigidbody
    public Vector3 spanAxis = Vector3.right;        // local direction from wing root to tip
    public Vector3 chordAxis = Vector3.forward;     // local direction from trailing edge to leading edge
    public float rootOffset = 0.035f;               // hinge to wing root
    public float length = 0.30f;                    // root to tip
    public float chordMax = 0.08f;                  // semi-elliptic planform
    [Range(4, 40)] public int strips = 16;

    [Header("Air and safety factors")]
    public float airDensity = 1.20f;                // kg/m3
    public float kLift = 0.7f, kDrag = 1.25f;       // same derating as the Python reference
    public Vector3 downwash = Vector3.zero;         // optional uniform induced velocity (world, m/s), e.g. from momentum theory

    [Header("Read-only")]
    public Vector3 lastForce;                       // world N, this step

    Vector3[] prev;
    bool primed;

    static float CL(float aDeg) => 0.225f + 1.58f * Mathf.Sin((2.13f * aDeg - 7.2f) * Mathf.Deg2Rad);   // Dickinson et al. 1999
    static float CD(float aDeg) => 1.92f - 1.55f * Mathf.Cos((2.04f * aDeg - 9.82f) * Mathf.Deg2Rad);

    float Chord(float rn) => chordMax * Mathf.Sqrt(Mathf.Max(0f, 1f - (2f * rn - 1f) * (2f * rn - 1f)));

    Vector3 StripPoint(int i, out float dr, out float c)
    {
        dr = length / strips;
        float rn = (i + 0.5f) / strips;
        c = Chord(rn);
        // the span axis should run along the wing's quarter-chord line, where the force acts
        return transform.TransformPoint(spanAxis.normalized * (rootOffset + rn * length));
    }

    void FixedUpdate()
    {
        if (body == null) return;
        float dt = Time.fixedDeltaTime;
        if (prev == null || prev.Length != strips) { prev = new Vector3[strips]; primed = false; }
        Vector3 n = transform.TransformDirection(Vector3.Cross(chordAxis, spanAxis).normalized);   // wing normal
        Vector3 s = transform.TransformDirection(spanAxis.normalized);
        Vector3 ch = transform.TransformDirection(chordAxis.normalized);
        Vector3 total = Vector3.zero;
        for (int i = 0; i < strips; i++)
        {
            Vector3 p = StripPoint(i, out float dr, out float c);
            Vector3 v = primed ? (p - prev[i]) / dt : body.GetPointVelocity(p);   // world velocity of the strip (flapping + body motion)
            prev[i] = p;
            Vector3 u = downwash - v;                                           // air velocity seen by the strip
            u -= Vector3.Dot(u, s) * s;                                         // spanwise flow carries no blade-element force
            float speed = u.magnitude;
            if (speed < 1e-4f) continue;
            Vector3 uh = u / speed;
            float alpha = Mathf.Acos(Mathf.Clamp01(Mathf.Abs(Vector3.Dot(uh, ch)))) * Mathf.Rad2Deg; // 0..90 deg
            Vector3 nn = Mathf.Sign(Vector3.Dot(u, n)) * n;                    // the air pushes the plate along its normal component
            Vector3 eL = (nn - Vector3.Dot(nn, uh) * uh).normalized;           // lift: normal to the flow, in the flow-normal plane
            float q = 0.5f * airDensity * speed * speed * c * dr;
            Vector3 f = kLift * q * CL(alpha) * eL + kDrag * q * CD(alpha) * uh; // drag acts along the air velocity
            body.AddForceAtPosition(f, p, ForceMode.Force);
            total += f;
        }
        primed = true;
        lastForce = total;
    }
}

Unreal Engine 5: FlycoreAero on the async physics tick

1. Enable Project Settings › Physics › Tick Physics Async and set the async fixed time step to 1–2 ms [20].
2. Make a Pawn with one simulating body (CAD mass, centre of mass at the actor origin) and the skeletal mesh for the look.
3. Compute the wing loads on the physics thread every step and add them as force and torque. Animation follows the same phase for the visuals.
4. Remember Unreal’s units: 1 N is 100 kg·cm/s² and 1 N·m is 10 000 kg·cm²/s².

// FlycoreAero.h - quasi-steady blade-element loads of one flapping wing, engine-independent (metres, newtons, radians).
// robotanimator.org, Dragon Flycore prototype guide. Same math as FlycoreWingAero.cs and general_check.py, which reproduces
// flycore_quasi_steady.py exactly (4.283 N at 12 Hz for the P1 wings, horizontal stroke plane, no rotational term).
// Body frame = Unreal actor frame: X forward, Y right, Z up. The flap hinge runs along X; feather turns the wing about its span.
#pragma once
#include "CoreMinimal.h"

struct FFlycoreWing
{
    FVector HingeM = FVector::ZeroVector;  // hinge point in the body frame, metres
    float Side = 1.f;                      // +1 right wing, -1 left wing
    float RootOffsetM = 0.035f, LengthM = 0.30f, ChordMaxM = 0.08f;
    float StrokeDeg = 90.f;                // peak to peak
    float AlphaMidDeg = 40.f;              // mid-stroke angle of attack
    float FlipFraction = 0.22f;            // share of the period spent flipping at each reversal
    float PhaseRad = 0.f;                  // hind wings: the fore pair leads by 90 deg on Dragon Flycore
    float TwistBiasDeg = 0.f;              // control input: + pitches the leading edge up on both strokes (asymmetry = paddling)
};

namespace FlycoreAero
{
    constexpr float KLift = 0.7f, KDrag = 1.25f, Rho = 1.2f;
    inline float CL(float A) { return 0.225f + 1.58f * FMath::Sin(FMath::DegreesToRadians(2.13f * A - 7.2f)); }
    inline float CD(float A) { return 1.92f - 1.55f * FMath::Cos(FMath::DegreesToRadians(2.04f * A - 9.82f)); }

    // Loads of one wing at time TimeS, in the body frame: force (N) and moment about the body origin (N m).
    // BodyVelMS and BodyOmega (rad/s) are the body's velocity and angular velocity, also in the body frame.
    // DownwashMS is an optional uniform induced velocity (body frame, m/s): air moving towards -Z when hovering.
    void WingLoads(const FFlycoreWing& W, float FlapHz, float TimeS, const FVector& BodyVelMS, const FVector& BodyOmega,
                   const FVector& DownwashMS, FVector& OutForceN, FVector& OutMomentNm, int32 Strips = 16);
}

// FlycoreAero.cpp - see FlycoreAero.h. robotanimator.org
#include "FlycoreAero.h"

namespace
{
    // angle of attack (deg) over one period: AlphaMid in mid-stroke, a smooth flip through 90 deg at each reversal (tn = 0 and 0.5)
    float PitchLaw(float Tn, float AlphaMid, float Flip)
    {
        float Best = 2.f;
        for (float Tr : {0.f, 0.5f, 1.f}) { const float D = Tn - Tr; if (FMath::Abs(D) < FMath::Abs(Best)) Best = D; }
        const float H = Flip * 0.5f;
        if (FMath::Abs(Best) >= H) return AlphaMid;
        const float X = Best / H;                                             // -1 .. 1 through the flip
        const float S = 0.5f * (1.f - FMath::Cos(PI * (X + 1.f) * 0.5f));
        return AlphaMid + (90.f - AlphaMid) * (1.f - FMath::Abs(2.f * S - 1.f));
    }
    float ChordAt(float Rn, float CMax) { const float K = 2.f * Rn - 1.f; return CMax * FMath::Sqrt(FMath::Max(0.f, 1.f - K * K)); }
}

void FlycoreAero::WingLoads(const FFlycoreWing& W, float FlapHz, float TimeS, const FVector& BodyVelMS, const FVector& BodyOmega,
                            const FVector& DownwashMS, FVector& OutForceN, FVector& OutMomentNm, int32 Strips)
{
    OutForceN = FVector::ZeroVector; OutMomentNm = FVector::ZeroVector;
    const float Omega = 2.f * PI * FlapHz;
    const float Amp = FMath::DegreesToRadians(W.StrokeDeg) * 0.5f;
    const float Ph = Omega * TimeS + W.PhaseRad;
    const float Phi = Amp * FMath::Cos(Ph);
    const float DPhi = -Amp * Omega * FMath::Sin(Ph);
    const float Tn = FMath::Frac(Ph / (2.f * PI));
    const float AGeo = PitchLaw(Tn, W.AlphaMidDeg, W.FlipFraction);
    // feather: the leading edge points into the motion (sign of DPhi); TwistBias adds the same pitch-up on both strokes
    const float Theta = FMath::DegreesToRadians(FMath::Sign(DPhi) * (90.f - AGeo) + W.TwistBiasDeg);

    const FVector Span(0.f, W.Side * FMath::Cos(Phi), FMath::Sin(Phi));        // root -> tip
    const FVector N0(0.f, -W.Side * FMath::Sin(Phi), FMath::Cos(Phi));        // zero-feather normal = stroke tangent
    const FVector Chord = FMath::Cos(Theta) * FVector::ForwardVector + FMath::Sin(Theta) * N0;   // towards the leading edge
    const FVector Normal = -FMath::Sin(Theta) * FVector::ForwardVector + FMath::Cos(Theta) * N0;

    const float Dr = W.LengthM / Strips;
    for (int32 i = 0; i < Strips; ++i)
    {
        const float Rn = (i + 0.5f) / Strips;
        const float R = W.RootOffsetM + Rn * W.LengthM;
        const float C = ChordAt(Rn, W.ChordMaxM);
        const FVector P = W.HingeM + Span * R;                                // quarter-chord point, body frame
        const FVector V = BodyVelMS + FVector::CrossProduct(BodyOmega, P) + N0 * (R * DPhi);
        FVector U = DownwashMS - V;                                           // air velocity seen by the strip
        U -= FVector::DotProduct(U, Span) * Span;
        const float Speed = U.Size();
        if (Speed < 1e-4f) continue;
        const FVector Uh = U / Speed;
        const float Alpha = FMath::RadiansToDegrees(FMath::Acos(FMath::Min(1.f, FMath::Abs(FVector::DotProduct(Uh, Chord)))));
        const FVector Nn = FMath::Sign(FVector::DotProduct(U, Normal)) * Normal;
        const FVector EL = (Nn - FVector::DotProduct(Nn, Uh) * Uh).GetSafeNormal();
        const float Q = 0.5f * Rho * Speed * Speed * C * Dr;
        const FVector F = KLift * Q * CL(Alpha) * EL + KDrag * Q * CD(Alpha) * Uh;
        OutForceN += F;
        OutMomentNm += FVector::CrossProduct(P, F);
    }
}

/* ---------------------------------------------------------------- how a pawn uses it (a sketch; check the Chaos names in your engine version)
   Project Settings > Physics > Framerate: enable "Tick Physics Async" and set the async fixed time step to 0.001 to 0.002 s.

   AFlycorePawn::AFlycorePawn() { bAsyncPhysicsTickEnabled = true; }

   void AFlycorePawn::AsyncPhysicsTickActor(float DeltaTime, float SimTime)
   {
       Super::AsyncPhysicsTickActor(DeltaTime, SimTime);
       FBodyInstance* BI = BodyMesh->GetBodyInstance();
       Chaos::FRigidBodyHandle_Internal* H = BI && BI->GetPhysicsActorHandle() ? BI->GetPhysicsActorHandle()->GetPhysicsThreadAPI() : nullptr;
       if (!H) return;
       const FTransform Pose(H->R(), H->X());                               // world, centimetres
       const FVector VelB = Pose.InverseTransformVectorNoScale(H->V()) / 100.f;   // body frame, m/s
       const FVector OmB = Pose.InverseTransformVectorNoScale(H->W());             // rad/s
       FVector FB = FVector::ZeroVector, MB = FVector::ZeroVector;
       for (const FFlycoreWing& W : Wings)                                // 4 wings, read-only copies made on the game thread
       {
           FVector F, M; FlycoreAero::WingLoads(W, FlapHz, SimTime, VelB, OmB, FVector(0, 0, -DownwashMS), F, M);
           FB += F; MB += M;
       }
       // Unreal units: 1 N = 100 kg cm/s^2, 1 N m = 10000 kg cm^2/s^2. Moments here are about the body origin: put it at the centre of mass.
       H->AddForce(Pose.TransformVectorNoScale(FB) * 100.f, false);
       H->AddTorque(Pose.TransformVectorNoScale(MB) * 10000.f, false);
   }
   Only touch physics-thread data inside AsyncPhysicsTickActor; pass control inputs (FlapHz, TwistBiasDeg) in from the game thread
   through atomics or the async input objects, never by reading components there. */

Flight control and learning

Write the controller in plain C so the same code runs in the simulator and on the robot’s microcontroller (software in the loop). If you prefer a full autopilot, ArduPilot’s SITL accepts physics from any program over a simple UDP JSON link [11]: your engine sends the robot state and receives servo outputs. For learned control, train in the engine with domain randomization (mass, centre of mass, motor delay, gusts): a drone controller trained this way in simulation has beaten human champions [21].

Validate it

A simulator is only as good as the numbers you feed it. Mount one wing pair on a load cell, record the mean lift and the motor current from 8 to 16 Hz, and fit the two safety factors (0.7 and 1.25) to your data. Then film a tethered hover at high frame rate and compare the body motion with the simulation.

Part B · Build a real prototype: P1

A realistic size: 45 cm long, 70 cm span, 300 g

How big should a robot dragonfly prototype be? Real flapping robots that fly today sit between 30 and 65 cm of span and 30 and 180 g [22] [23] [1]. P1 sits at the top of that range, so there is room for a camera, a ducted fan and real perching legs, while staying a size you can build on a desk.

P1 by the numbers

Mass budget

Motors and turbines for P1

• Flapping: two brushless outrunners of the 1404 class (about 9–10 g each), each with a two-stage spur gearbox (about 16:1, module 0.3–0.5) and a crank-rocker. One motor per wing pair keeps the fore-hind phase adjustable.
• Control: four 2–4 g servos twist the wings (roll, pitch, paddling), as on Festo’s BionicOpter, which flaps with one brushless motor and steers with servos on the wings.
• Thrust: one 30 mm EDF in the chest (≈ 1 N at ≈ 100 W on 2S, seller data [6]) with a printed S-duct to the tail and two paddle servos.
• Brain: a small flight controller with a 6-axis IMU. The Flapper Nimble+ flies on the open-source Crazyflie Bolt 1.1 (STM32F405) with a fork of the Crazyflie firmware [23]; it is a proven starting point for flapping-wing control.
• Sensors: a micro camera, an 8 × 8 zone time-of-flight sensor for landing and obstacles.

Materials and 3D printing

14 s · Commons

Making the wings

1. Print a flat jig with grooves for the spar and the vein rods, mirrored for the left and right wings.
2. Lay the 3.0/2.0 mm spar along the leading edge and the 1 mm rods along the vein lines; glue the joints with thin CA.
3. Spray adhesive on the frame, lay the film over it under light, even tension, and trim with a hot knife 1 mm outside the frame.
4. Add a few grams of tip weight (the pterostigma) to tune the passive pitch, then weigh each wing: pairs should match within 0.1 g.
5. Check the first bending mode: tap the tip and film it, or excite it on a speaker. It must stay above twice the top beat frequency.

Build and test plan

Downloads

The 3D model and renders: robotanimator.org, CC BY 4.0. The code: free to use and change. More robots, rigs and prototypes are in the Robot Animator portfolio.

FAQ

Sources and credits

1. Festo (2013). BionicOpter: inspired by dragonfly flight. Technical data sheet. Link
2. Wang, Z. J. (2004). The role of drag in insect hovering. J. Exp. Biol. 207: 4147-4155. Link
3. Norberg, R. Å. (1972). The pterostigma of insect wings, an inertial regulator of wing pitch. J. Comp. Physiol. 81: 9-22. Link
4. ASME. Historic Mechanical Engineering Landmark #238: the Grumman Wildcat “Sto-Wing” wing-folding mechanism (1941). Link
5. JetCat P20-SX product page (about 24 N; retailers list about 350 g). Link
6. Lindinger: PICHLER THRUST 30 mm impeller drive, KV 8000 (12 g, 108 g thrust, 98 W, 2S; seller data). Link
7. NASA. X-31 enhanced fighter maneuverability: thrust-vectoring paddles (NTRS 19960029101). Link
8. Unity Robotics Hub: URDF Importer and ROS-TCP-Connector. Link
9. Colosseum: the community port of Microsoft AirSim to Unreal Engine 5. Link
10. Project AirSim (IAMAI fork, MIT licence). Link
11. ArduPilot developer docs: SITL with the JSON interface for external physics. Link
12. Unreal Engine API: Learning Agents plugin. Link
13. Unity ML-Agents Toolkit (package 4.x requires Unity 6). Link
14. MuJoCo documentation: fluid forces (inertia and ellipsoid models). Link
15. PX4 user guide: Gazebo simulation. Link
16. Dickinson, M. H., Lehmann, F.-O. & Sane, S. P. (1999). Wing rotation and the aerodynamic basis of insect flight. Science 284: 1954-1960. Link
17. Sane, S. P. & Dickinson, M. H. (2001). The control of flight force by a flapping wing: lift and drag production. J. Exp. Biol. 204: 2607-2626. Link
18. Sane, S. P. & Dickinson, M. H. (2002). The aerodynamic effects of wing rotation and a revised quasi-steady model of flapping flight. J. Exp. Biol. 205: 1087-1096. Link
19. Unity scripting reference: Physics.Simulate and SimulationMode.Script. Link
20. Unreal Engine API: AsyncPhysicsTickComponent (async physics tick). Link
21. Kaufmann, E., Bauersfeld, L., Loquercio, A., Müller, M., Koltun, V. & Scaramuzza, D. (2023). Champion-level drone racing using deep reinforcement learning. Nature 620: 982-987. Link
22. Karásek, M., Muijres, F. T., De Wagter, C., Remes, B. D. W. & de Croon, G. C. H. E. (2018). A tailless aerial robotic flapper reveals that flies use torque coupling in rapid banked turns. Science 361: 1089-1094. Link
23. Flapper Drones. Flapper Nimble+ specifications (49 cm span, 114 g, Crazyflie Bolt 1.1). Link
24. FAA: how to register your drone (250 g threshold). Link
25. EASA: open category, low-risk civil drones (class C0 under 250 g). Link

CAD numbers come from the Dragon Flycore engineering files (design specification, engineering checks, flight modes). P1 numbers come from flycore_quasi_steady.py. All renders, videos and the GLB: robotanimator.org, CC BY 4.0.