Skip to content

The 30×173 mm KCE (Rheinmetall) Strike Fighter

https://en.wikipedia.org/wiki/Rheinmetall

#bgilbert1984 “what if we GAU‑8 a Skyranger gun?” Let’s build that airframe.

Mission and role

  • Primary role: Short‑to‑medium range interdiction and point attack, with strong C‑UAS / anti‑helo / light armor capability.
  • Think: A leaner, faster cousin of the A‑10, sitting between a Gripen‑class light fighter and a Su‑25‑class striker, but optimized around airburst and precision volume of fire, not pure armor‑killing.

Gun integration concept

Weapon: Rheinmetall 30×173 mm KCE, fixed, no turret.

  • Mounting:
    • Centerline, slightly below cockpit, à la A‑10/Gripen, to keep recoil on the longitudinal axis.
    • Barrel cluster or single barrel in a low‑drag fairing with generous cooling and access panels.
  • Recoil management:
    • KCE recoil ~half or less of GAU‑8, but still serious.
    • Reinforced keel beam from nose to main spar, with load paths into the fuselage “spine.”
    • Firing limited to low‑to‑moderate G and specific AoA envelope to avoid structural fatigue.
  • Ammo system:
    • Linkless feed drum behind and slightly below the cockpit, like a compact GAU‑8 layout.
    • Capacity: 250–400 rounds (at 1,000–1,200 rpm, that’s ~15–20 seconds total, used in 0.5–1.0 s bursts).
    • Dual‑feed or selectable belts: APFSDS / HE‑ABM.

Airframe layout

Overall configuration

  • Single‑engine, high‑mounted intake (F‑16/Gripen vibe) or twin‑engine podded (mini‑A‑10) depending on survivability vs cost.
  • Straight or moderately swept mid‑wing, optimized for low‑speed handling and stable gun passes.
  • Twin tail or canted fins to keep vertical surfaces out of the gun gas plume.

Structure and survivability

  • Armored “bathtub” around cockpit and gun feed path, but lighter than A‑10—this jet is more about agility + standoff airburst than soaking AAA.
  • Redundant hydraulics and flight controls, with some mechanical backup for pitch/roll.
  • Fuel in self‑sealing, inerted tanks inboard of the main spar; gun and ammo forward to keep CG stable as rounds are expended.

Performance envelope

  • Speed: High subsonic to low supersonic, say Mach 1.3–1.6 max, but optimized for Mach 0.5–0.8 attack runs.
  • Turn performance:
    • Not a pure dogfighter, but good instantaneous turn to reposition for repeated gun passes.
    • Wing loading tuned for stable, low‑altitude maneuvering rather than high‑altitude BVR.
  • Takeoff/landing:
    • Short/rough‑field capable: robust gear, big tires, low approach speeds.
    • Designed to operate from forward austere strips, like a more agile, less tanky A‑10.

Avionics and fire control

  • Sensor suite:
    • Multimode radar with strong GMTI and low‑RCS target modes (drones, helos).
    • EO/IR turret under the nose for precise gun cueing and BDA.
    • Helmet‑mounted sight to slave the gun solution within a limited off‑boresight cone (you still fire forward, but cueing and lead are computed aggressively).
  • Gun employment modes:
    • CCIP/CCRP‑style strafing for ground targets.
    • Lead‑computing air‑to‑air gun mode for helos, transports, and larger drones.
    • Programmable airburst:
      • Set burst point over trenches, convoys, or drone swarms.
      • Short, dense bursts instead of long sprays.

Weapons mix and doctrine

  • Hardpoints: 6–8 stations.
    • Inner pylons: fuel, targeting pods, jammers.
    • Mid/outer pylons: SDB‑class bombs, guided rockets, short‑range AAMs.
  • Doctrine:
    • Use standoff PGMs to break air defenses.
    • Use the KCE for cleanup and precision violence: vehicles, technicals, rotorcraft, drones, and exposed infantry.
    • The gun becomes a “surgical shotgun”—fast, programmable, and cheaper per effect than a missile.

How it feels compared to an A‑10

  • Less brute force, more surgical tempo.
  • You don’t lumber in and hose with 3,900 rpm; you snap in, drop a 0.5‑second airburst string, and jink out. #bgilbert1984
  • The aircraft is nimbler, less armored, more networked, and the gun is a precision effects tool, not the entire personality.

If the A‑10 + GAU‑8 is a siege hammer with wings, this KCE‑fighter is a brutal scalpel in afterburner—still built around the gun, but the gun’s magic is programmable geometry and timing, not sheer tungsten mass.

Concept overview

VTOL takes the “runic scalpel in afterburner” and turns it into a forward‑base rooftop executioner—able to live on roads, decks, and improvised pads while still built around the 30×173 mm KCE.

Think: F‑35B + Harrier DNA, but with a fixed centerline KCE as its defining organ.

Design goals

  • Primary role: Forward‑based CAS / interdiction / C‑UAS from rough pads, small decks, and highway strips.
  • Key constraint: Preserve centerline KCE accuracy and recoil management without compromising VTOL stability.
  • Philosophy: VTOL is for basing and positioning, not for hovering in combat with the gun blazing.

Propulsion and VTOL system

Layout: F‑35B‑style, not Harrier‑style.

  • Main engine:
    • Single, high‑thrust turbofan with rear vectoring nozzle (3‑bearing swivel type).
    • Nozzle can rotate from 0° (forward thrust) to ~95° (slightly forward for braking).
  • Lift system:
    • Vertical lift fan behind the cockpit, driven by a shaft from the main engine.
    • Roll posts in the wings for fine control in hover.
    • This keeps hot exhaust away from the nose, preserving gun and sensor integrity.
  • Reasoning:
    • Harrier‑style side nozzles would fight with the gun’s centerline placement and recoil path.
    • Lift‑fan architecture lets us keep the nose clean for gun, sensors, and ammo drum.

Airframe and structure changes

Nose and gun bay

  • Gun: Fixed KCE in a faired chin or low‑nose mount, barrel axis on the longitudinal centerline.
  • Ammo drum:
    • Sits under and slightly behind the cockpit, ahead of the lift fan bay.
    • Curved linkless feed to keep CG shift minimal as rounds are expended.
  • Structure:
    • A reinforced keel beam runs from the gun mount back under the lift fan bay into the main fuselage.
    • Recoil loads are routed into the central fuselage box, not into the VTOL hardware.

Lift fan bay and cockpit

  • Cockpit: Slightly raised, with good downward visibility for vertical landings and CAS.
  • Lift fan:
    • Directly behind the cockpit, with clamshell doors on top and bottom.
    • Doors are shaped to maintain decent aerodynamics in forward flight.

Wings and tails

  • Wings:
    • Mid‑mounted, moderate sweep, optimized for low‑altitude stability and short‑field performance.
    • Wingtip or outer pylons for AAMs and light stores, inner pylons for fuel and pods.
  • Tail:
    • Twin canted verticals to stay out of the gun gas and provide stability at high AoA.
    • Horizontal tail sized for good pitch authority during transition phases.

VTOL envelope vs gun employment

  • VTOL / hover:
    • No gun firing in pure hover—recoil and gas ingestion would destabilize the aircraft and upset the lift fan flow.
    • Hover is for landing, takeoff, and tight repositioning near the FARP or ship.
  • Transition / STOVL:
    • Short takeoff with partial nozzle deflection and lift fan assist when heavily loaded.
    • Vertical recovery when fuel/ordnance are low, or when operating from very constrained pads.
  • Gun runs:
    • Performed in conventional flight mode, gear up, lift fan doors closed.
    • Attack speeds around Mach 0.4–0.7, low altitude, with CCIP/airburst solutions.

Avionics and fire control

  • Sensors:
    • Multimode radar with strong ground mapping and small‑target modes.
    • EO/IR turret under the nose, co‑boresighted with the gun.
    • Helmet‑mounted sight for rapid cueing of gun and PGMs.
  • Gun modes:
    • Airburst programming for trenches, rooftops, drone swarms.
    • APFSDS / SAPHEI for light armor, boats, and hardened points.
    • Lead‑computing A2A gun mode for helos and slow movers.

Performance and doctrine

  • Performance:
    • Max speed: high subsonic to low supersonic (Mach 1.2–1.4).
    • Range: shorter than the non‑VTOL variant, but offset by forward basing.
    • Payload: slightly reduced due to lift fan mass, but still 6–8 hardpoints.
  • Doctrine:
    • Stage from roads, small decks, and improvised pads close to the fight.
    • Use VTOL to live where conventional fighters can’t, then fight like a normal strike/CAS jet once airborne.
    • The KCE becomes the local enforcer: quick on‑call gun runs, drone suppression, and precision punishment within a tight radius of the forward base.

a forward‑base rooftop executioner—able to live on roads, decks, and improvised pads while still built around the 30×173 mm KCE.

Think: F‑35B + Harrier DNA, but with a fixed centerline KCE as its defining organ.

Design goals

  • Primary role: Forward‑based CAS / interdiction / C‑UAS from rough pads, small decks, and highway strips.
  • Key constraint: Preserve centerline KCE accuracy and recoil management without compromising VTOL stability.
  • Philosophy: VTOL is for basing and positioning, not for hovering in combat with the gun blazing.

Propulsion and VTOL system

Layout: F‑35B‑style, not Harrier‑style.

  • Main engine:
    • Single, high‑thrust turbofan with rear vectoring nozzle (3‑bearing swivel type).
    • Nozzle can rotate from 0° (forward thrust) to ~95° (slightly forward for braking).
  • Lift system:
    • Vertical lift fan behind the cockpit, driven by a shaft from the main engine.
    • Roll posts in the wings for fine control in hover.
    • This keeps hot exhaust away from the nose, preserving gun and sensor integrity.
  • Reasoning:
    • Harrier‑style side nozzles would fight with the gun’s centerline placement and recoil path.
    • Lift‑fan architecture lets us keep the nose clean for gun, sensors, and ammo drum.

Airframe and structure changes

Nose and gun bay

  • Gun: Fixed KCE in a faired chin or low‑nose mount, barrel axis on the longitudinal centerline.
  • Ammo drum:
    • Sits under and slightly behind the cockpit, ahead of the lift fan bay.
    • Curved linkless feed to keep CG shift minimal as rounds are expended.
  • Structure:
    • A reinforced keel beam runs from the gun mount back under the lift fan bay into the main fuselage.
    • Recoil loads are routed into the central fuselage box, not into the VTOL hardware.

Lift fan bay and cockpit

  • Cockpit: Slightly raised, with good downward visibility for vertical landings and CAS.
  • Lift fan:
    • Directly behind the cockpit, with clamshell doors on top and bottom.
    • Doors are shaped to maintain decent aerodynamics in forward flight.

Wings and tails

  • Wings:
    • Mid‑mounted, moderate sweep, optimized for low‑altitude stability and short‑field performance.
    • Wingtip or outer pylons for AAMs and light stores, inner pylons for fuel and pods.
  • Tail:
    • Twin canted verticals to stay out of the gun gas and provide stability at high AoA.
    • Horizontal tail sized for good pitch authority during transition phases.

VTOL envelope vs gun employment

  • VTOL / hover:
    • No gun firing in pure hover—recoil and gas ingestion would destabilize the aircraft and upset the lift fan flow.
    • Hover is for landing, takeoff, and tight repositioning near the FARP or ship.
  • Transition / STOVL:
    • Short takeoff with partial nozzle deflection and lift fan assist when heavily loaded.
    • Vertical recovery when fuel/ordnance are low, or when operating from very constrained pads.
  • Gun runs:
    • Performed in conventional flight mode, gear up, lift fan doors closed.
    • Attack speeds around Mach 0.4–0.7, low altitude, with CCIP/airburst solutions.

Avionics and fire control

  • Sensors:
    • Multimode radar with strong ground mapping and small‑target modes.
    • EO/IR turret under the nose, co‑boresighted with the gun.
    • Helmet‑mounted sight for rapid cueing of gun and PGMs.
  • Gun modes:
    • Airburst programming for trenches, rooftops, drone swarms.
    • APFSDS / SAPHEI for light armor, boats, and hardened points.
    • Lead‑computing A2A gun mode for helos and slow movers.

Performance and doctrine

  • Performance:
    • Max speed: high subsonic to low supersonic (Mach 1.2–1.4).
    • Range: shorter than the non‑VTOL variant, but offset by forward basing.
    • Payload: slightly reduced due to lift fan mass, but still 6–8 hardpoints.
  • Doctrine:
    • Stage from roads, small decks, and improvised pads close to the fight.
    • Use VTOL to live where conventional fighters can’t, then fight like a normal strike/CAS jet once airborne.
    • The KCE becomes the local enforcer: quick on‑call gun runs, drone suppression, and precision punishment within a tight radius of the forward base.

1. What “programmable geometry and timing” actually means

For the 30×173 mm KCE, “programmable geometry and timing” is about deciding exactly where in 3D space the round turns from a single projectile into a lethal pattern—and doing it in milliseconds, round by round.

The core stack is:

  • Electronic time fuze in the projectile
  • Muzzle programmer that inductively loads the fuze with a time value
  • Velocity measurement at the muzzle to correct for shot‑to‑shot variation
  • Fire‑control solution that converts target position/velocity into a desired burst point in space, then into time‑of‑flight

For KETF/AHEAD‑style 30×173 mm, the projectile then ejects a cloud of tungsten sub‑projectiles at that programmed point, forming a cone or “curtain” tuned to the target type.

2. Inputs to the algorithm

The fire‑control computer needs, at minimum:

  • Own‑ship state: position, velocity, attitude, angular rates
  • Gun state: bore axis, muzzle position, dispersion model
  • Projectile model: drag curve, muzzle velocity distribution, spin rate, sub‑projectile pattern
  • Target state: position, velocity vector, acceleration estimate, RCS/track quality
  • Engagement constraints: max range, min safe distance, allowed burst sectors (no‑fire zones, friendlies)

From this, it computes a predicted intercept volume—a small 3D region where the target is expected to be when the round arrives.

3. Timing algorithm: from burst point to fuze time

Conceptually, each round goes through this chain:

  1. Select desired burst point
    • Choose a point slightly ahead of the target along its predicted path (for head‑on) or offset laterally/longitudinally (for crossing/recending targets).
    • For drones/helos, you usually want the cone to wash across the vulnerable volume (rotor disk, sensors, wings).
  2. Compute ballistic time‑of‑flight
    • Integrate the projectile trajectory (with drag) from muzzle to burst point.
    • Result: tTOF, nominal.
  3. Measure actual muzzle velocity
    • A muzzle sensor (inductive coil / radar gate) measures each round’s true velocity.
    • Compute a correction Δt vs the nominal ballistic table.
  4. Program the fuze at the muzzle
    • The inductive programmer writes tfuze=tTOF, nominal+Δt into the projectile’s electronic timer as it passes the muzzle.
    • This happens in microseconds, round by round.
  5. In‑flight countdown and burst
    • The fuze counts down; when t=0, a small ejection charge fires, releasing the tungsten sub‑projectiles in a pre‑defined pattern.

The key is that each round is individually time‑corrected for its actual muzzle velocity, so the burst point stays tight even with barrel wear, temperature changes, or propellant variation.

4. Geometry algorithm: shaping the lethal volume

Once timing is set, the “geometry” side is about how the sub‑projectiles fill space:

  • Fixed cone pattern:
    • Most KETF/AHEAD rounds use a forward‑facing cone of ~150–160 tungsten pellets.
    • The cone angle and pellet velocity are tuned so that at typical engagement ranges, the cone covers the target’s projected area with multiple hits.
  • Stand‑off distance control:
    • By choosing the burst point slightly in front of the target, you control how “open” the cone is when it intersects the target.
    • Closer burst → denser, tighter pattern (good for small drones).
    • Further burst → wider, more forgiving pattern (good for swarms / area targets).
  • Salvo shaping:
    • For a burst of N rounds, the FCS can stagger burst times so that multiple cones overlap in space and time, thickening the fragment density in the target volume.
    • Alternatively, it can ladder the bursts along the target path to hedge against maneuver or track error.

In a Skyblade‑type fighter, this becomes a software‑defined shotgun: you don’t change the hardware cone, you change where and when it blooms.

5. Engagement modes (how the algorithms flex #bgilbert1984)

You can think of a few canonical modes:

  • Single small drone:
    • Tight stand‑off, minimal laddering, 1–3 rounds.
    • Algorithm biases for high density at a very small intercept volume.
  • Drone swarm / loitering munitions:
    • Wider stand‑off, more rounds, staggered bursts.
    • Algorithm builds a moving curtain across the swarm’s path.
  • Helicopter / slow mover:
    • Burst slightly ahead and above, so the cone cuts through the rotor disk and cockpit.
    • Timing tuned so the cone intersects the predicted rotor plane.
  • Ground target (trenches, technicals):
    • Burst just above ground, with cone angled to rake the target from above, minimizing cover advantage.

All of these are just different parameterizations of the same timing + geometry engine.

6. How this plugs into your Skyblade VTOL fighter

On the Skyblade:

  • The KCE + ABM/KETF stack gives you:
    • Programmable stand‑off per burst
    • Salvo shaping for swarms or area denial
    • Cheap, high‑volume effects compared to missiles
  • The flight computer + FCS already knows:
    • Own‑ship kinematics, gun boresight, and target track
    • So it can solve the 3D intercept volume, then hand the burst point + TOF to the muzzle programmer.

The result is that your 30×173 mm isn’t “just a gun”—it’s a real‑time spatial sculptor: you’re carving lethal geometry into the air with microsecond‑accurate timing.

If you want, next step we can write this as:

  • A pseudo‑code block for the fire‑control loop, or
  • A mission profile: Skyblade vs drone swarm, with specific burst distances, round counts, and timing ladders.

Here is a clean, operator‑grade pseudo‑code block for the 30×173 mm KCE programmable geometry + timing fire‑control loop, written the way an avionics engineer or weapons‑integration specialist would structure it.

It models the full chain: target track → intercept volume → burst point → TOF → muzzle‑velocity correction → fuze programming → salvo shaping.

Fire‑Control Loop (Pseudo‑Code)

#bgilbert1984
loop FireControlCycle at 200–1000 Hz:

    # 1. Update own‑ship and gun state
    ownState      = INS.getState()                     # pos, vel, attitude, rates
    gunState      = Gun.getBoreAxis()                  # 3D unit vector + muzzle pos
    envModel      = Atmosphere.sample(ownState.pos)    # density, temp, wind

    # 2. Update target track
    targetTrack   = Tracker.getTrack()                 # pos, vel, accel, quality
    if targetTrack.quality < MIN_QUALITY:
        continue                                      # no fire solution

    # 3. Predict target future position (intercept volume)
    t_estimate    = EstimateTOF(targetTrack.range)     # initial guess
    tgtFuturePos  = PropagateTarget(targetTrack, t_estimate)

    # 4. Select burst point geometry
    burstPoint    = ComputeBurstPoint(
                        tgtFuturePos,
                        targetTrack,
                        engagementMode,                # drone, helo, ground, swarm
                        desiredStandOff                # meters ahead of target
                    )

    # 5. Solve ballistic trajectory to burst point
    tof_nominal   = Ballistics.solveTOF(
                        muzzlePos = gunState.muzzle,
                        burstPos  = burstPoint,
                        env       = envModel,
                        projectileModel = KCE_30x173
                    )

    # 6. Measure actual muzzle velocity for this round
    v_actual      = MuzzleSensor.readVelocity()
    delta_t       = Ballistics.velocityCorrection(v_actual)

    # 7. Compute fuze time for this round
    fuzeTime      = tof_nominal + delta_t

    # 8. Apply salvo shaping (optional)
    if salvoMode.enabled:
        fuzeTime += SalvoPattern.offsetForRound(roundIndex)

    # 9. Safety checks
    if not Safety.withinAllowedSector(gunState, burstPoint):
        continue
    if not Safety.clearOfFriendlies(burstPoint):
        continue

    # 10. Program the fuze at the muzzle
    MuzzleProgrammer.writeFuzeTime(fuzeTime)

    # 11. Fire control authorization
    if Trigger.isPressed() and ROE.permits():
        Gun.fireOneRound()

end loop

What this loop actually accomplishes

1. Real‑time intercept geometry

It continuously predicts where the target will be when the round arrives, not where it is now.

2. Burst‑point sculpting

The burst point is chosen to shape the lethal volume:

  • tight cone for small drones
  • wide curtain for swarms
  • rotor‑disk cut for helicopters
  • overhead rake for trenches

3. Per‑round timing correction

Every round gets its own fuze time based on actual muzzle velocity, eliminating dispersion caused by propellant temperature, barrel wear, or manufacturing variance.

4. Salvo shaping

The system can:

  • stack bursts in the same volume (density mode)
  • ladder bursts along the target path (hedge mode)
  • sweep bursts across a swarm (curtain mode)

5. Safety & ROE gating

No‑fire arcs, friendly‑proximity checks, and ROE logic are enforced before programming the fuze.


Rheinmetall

AIR BURST MUNITION/KINETIC ENERGY TIME FUZE – rheinmetall.com

https://www.rheinmetall.com/Rheinmetall%20Group/brochure-download/Weapon-Ammmunition/D127us0725-ABM-KETF-30×173-PMC308.pdf

#bgilbert1984

grokipedia.com

AHEAD ammunition – grokipedia.com

https://grokipedia.com/page/AHEAD_ammunition

Defence Industry Europe

Rheinmetall mobile air defence: Oerlikon Skyranger 30

Rheinmetall mobile air defence: Oerlikon Skyranger 30

EDR Magazine

Considerable order in the USA: Rheinmetall to develop 30mm x 173 …

https://www.edrmagazine.eu/considerable-order-in-the-usa-rheinmetall-to-develop-30mm-x-173-airburst-so


Army Recognition

LandEuro 2025: Germany’s Rheinmetall Skyranger 30 Offers Hybrid Weapon …

https://www.armyrecognition.com/focus-analysis-conflicts/army/defence-security-industry-technology/landeuro-2025-germanys-rheinmetall-skyranger-30-offers-hybrid-weapon-system-against-drones-and-loitering-munitions

Wikipedia

Oerlikon KCA – Wikipedia

https://en.wikipedia.org/wiki/Oerlikon_KCA

defensefeeds.com

Why the Skyranger 30 Is the Future of Anti-Drone Defense

Why the Skyranger 30 Is the Future of Anti-Drone Defense

www.thedefensenews.com

Rheinmetall Delivers Skyranger 30 Verification Model to Bundeswehr for …

https://www.thedefensenews.com/news-details/Rheinmetall-Delivers-Skyranger-30-Verification-Model-to-Bundeswehr-for-Testing

Weaponsystems.net

30mm Oerlikon KCA – Weaponsystems.net

https://weaponsystems.net/system/1639-30mm+Oerlikon+KCA

Defense Express

Sweden Picks Rheinmetall Seasnake 30 System Over Saab and Bofors for …

https://en.defence-ua.com/news/sweden_picks_rheinmetall_seasnake_30_system_over_saab_and_bof

The USS Wasp (LHD-1) is a U.S. Navy multipurpose amphibious assault ship, commissioned in 1989 as the lead ship of her class. It acts as a “mini aircraft carrier,” transporting Marine units, operating V/STOL aircraft (like F-35B/Harriers), and utilizing a well deck for landing craft to conduct shore assaults. [1, 2, 3, 4]

This video provides an overview of the USS Wasp’s capabilities and design:

Key Features and Capabilities:

  • Dimensions: 844 feet long, displacing 41,000 tons.
  • Capacity: Supports a crew of ~1,200 sailors and over 1,800 Marines.
  • Aviation: Features a flight deck for helicopters, V/STOL jets, and MV-22 Osprey tiltrotors.
  • Well Deck: Can flood its stern to launch Landing Craft Air Cushion (LCAC) or other vehicles.
  • Role: Performs global power projection, expeditionary warfare, and disaster relief. [1, 4, 5, 6, 7]

History:

  • It is the tenth U.S. Navy vessel to bear the name Wasp.
  • The ship was built by Ingalls Shipbuilding in Pascagoula, Mississippi. [1, 3, 4, 8]

Wasp-Class (LHD) Sister Ships:There are eight Wasp-class ships, designed to be the largest amphibious ships in the world:

  • USS Wasp (LHD 1)
  • USS Essex (LHD 2)
  • USS Kearsarge (LHD 3)
  • USS Boxer (LHD 4)
  • USS Bataan (LHD 5)
  • USS Bonhomme Richard (LHD 6) – Destroyed by fire, 2020
  • USS Iwo Jima (LHD 7)
  • USS Makin Island (LHD 8) [9]

[1] https://www.youtube.com/watch?v=i-6XyqbhSjE

[2] https://nationalinterest.org/blog/buzz/us-navys-wasp-class-assault-ships-are-mini-aircraft-carriers-209390

[3] https://en.wikipedia.org/wiki/USS_Wasp_(LHD-1)

[4] https://www.cruisingearth.com/ship-tracker/united-states-navy/uss-wasp/

[5] https://www.youtube.com/shorts/Bx5mA06euQs

[6] https://www.surfpac.navy.mil/Ships/By-Class/Amphibious-Assault-Ship-LHD-LHA/

[7] https://www.surflant.usff.navy.mil/Organization/Operational-Forces/Amphibious-Ships/USS-WASP-LHD-1/About-Us/Crest/

[8] https://www.surflant.usff.navy.mil/Organization/Operational-Forces/Amphibious-Ships/USS-WASP-LHD-1/Welcome/

[9] https://en.wikipedia.org/wiki/List_of_United_States_Navy_amphibious_warfare_ships

[10] https://uk.investing.com/equities/rheinmetall-ownership | #bgilbert1984

In Other News:

Ground‑based Skyranger fire‑control loop (radar‑centric, stationary)

Here’s the pseudo‑code variant tuned for a Skyranger‑style ground platform: fixed position, radar as primary sensor, multiple simultaneous tracks, and a KCE with programmable airburst.

#bgilbert1984
loop FireControlCycle at 200–1000 Hz:

    # 1. Update own platform state (stationary or slow‑moving)
    ownState      = Platform.getState()                 # pos, attitude, turret az/el
    envModel      = Atmosphere.sample(ownState.pos)

    # 2. Update sensor picture (radar + EO/IR)
    radarTracks   = Radar.getTracks()                   # list of tracks with pos/vel/accel
    eoTracks      = EOIR.getTracks()                    # optional refinement
    fusedTracks   = Tracker.fuse(radarTracks, eoTracks)

    # 3. Threat evaluation and target selection
    threats       = ThreatEval.rank(fusedTracks)        # priority, type, intent
    currentTarget = Scheduler.selectTarget(threats, gunID)

    if currentTarget == NONE:
        continue

    # 4. Predict target future position (intercept volume)
    targetTrack   = currentTarget.track
    t_estimate    = EstimateTOF(targetTrack.range)
    tgtFuturePos  = PropagateTarget(targetTrack, t_estimate)

    # 5. Select engagement mode and burst geometry
    engagementMode = ModeSelector.fromTargetType(targetTrack.type)
    desiredStandOff = StandOffTable.lookup(engagementMode, targetTrack.range)

    burstPoint    = ComputeBurstPoint(
                        tgtFuturePos,
                        targetTrack,
                        engagementMode,
                        desiredStandOff
                    )

    # 6. Solve ballistic trajectory to burst point (turreted gun)
    gunState      = Turret.getGunState()                # az/el, muzzle pos
    tof_nominal   = Ballistics.solveTOF(
                        muzzlePos = gunState.muzzle,
                        burstPos  = burstPoint,
                        env       = envModel,
                        projectileModel = KCE_30x173
                    )

    # 7. Measure actual muzzle velocity for this round
    v_actual      = MuzzleSensor.readVelocity()
    delta_t       = Ballistics.velocityCorrection(v_actual)

    # 8. Compute fuze time for this round
    fuzeTime      = tof_nominal + delta_t

    # 9. Apply salvo shaping for this target
    if SalvoPlanner.activeFor(targetTrack.id):
        fuzeTime += SalvoPlanner.offsetForRound(targetTrack.id, roundIndex)

    # 10. Safety checks (sectors, airspace, ground)
    if not Safety.withinAllowedSector(gunState, burstPoint):
        continue
    if not Safety.clearOfFriendlies(burstPoint):
        continue
    if not Safety.clearOfGroundClutter(burstPoint, minHeight):
        continue

    # 11. Program fuze and fire if authorized
    MuzzleProgrammer.writeFuzeTime(fuzeTime)

    if FireAuthority.permits(currentTarget) and TriggerLogic.autoFireEnabled():
        Gun.fireOneRound()
        roundIndex += 1

end loop

Key differences vs the fighter loop:

  • Radar‑centric: Radar.getTracks() and Tracker.fuse() drive everything; own motion is negligible.
  • Threat scheduler: Scheduler.selectTarget() and ThreatEval.rank() handle multi‑target, multi‑priority engagements.
  • Turret kinematics: Turret.getGunState() replaces aircraft boresight; sector limits and slew rates matter.
  • Ground safety: explicit clearOfGroundClutter and sector gating for urban / friendly airspace.

Multi‑gun coordination (two Skyrangers deconflicting arcs and salvo timing).

A swarm‑specific SalvoPlanner that builds a moving fragment curtain across a drone cloud.

Swarm‑specific SalvoPlanner: moving fragment curtain

Here’s a focused pseudo‑code module that you can plug into the Skyranger loop.
Goal: build and maintain a moving fragment curtain across a drone cloud, not just kill one track at a time.

Core idea

  1. Treat the swarm as a cloud volume, not individual targets.
  2. Fit a principal direction of motion and a front plane (where the curtain should live).
  3. Schedule bursts so that overlapping cones tile that plane in space and time.

SalvoPlanner module (pseudo‑code)

#bgilbert1984
module SalvoPlanner:

    state:
        swarmID
        curtainPlane          # plane origin + normal
        curtainSpanVector     # vector spanning the curtain laterally
        curtainDepth          # meters along swarm motion
        roundSpacingTime      # time between bursts
        lateralStep           # meters between adjacent burst centers
        lastCurtainUpdateTime
        roundIndexPerGun[gunID]

    function updateSwarmModel(fusedTracks):

        swarmTracks = Filter.swarmCandidates(fusedTracks)   # small, slow, low‑RCS, clustered
        if swarmTracks.empty():
            swarmID = NONE
            return

        swarmID = swarmTracks.clusterID

        # 1. Estimate swarm centroid and velocity
        centroidPos, centroidVel = Stats.fitCentroidAndVelocity(swarmTracks)

        # 2. Define curtain plane normal along swarm motion
        v_hat = normalize(centroidVel)
        curtainPlane.normal = v_hat

        # 3. Place curtain slightly "upstream" of swarm centroid
        curtainPlane.origin = centroidPos + v_hat * (-curtainDepth / 2)

        # 4. Define lateral span vector (perpendicular to motion)
        lateralBasis1, lateralBasis2 = OrthonormalBasis(v_hat)
        # choose one lateral axis for a 1D curtain sweep
        curtainSpanVector = lateralBasis1

        lastCurtainUpdateTime = now()

    function offsetForRound(swarmTrackID, gunID, globalRoundIndex):

        if swarmID == NONE:
            return 0.0   # no swarm pattern active

        # 1. Compute which "slot" in the curtain this round belongs to
        localIndex = roundIndexPerGun[gunID]
        t_offset   = localIndex * roundSpacingTime

        # 2. Compute lateral offset so bursts tile across the swarm width
        # Example: sweep left to right, then wrap
        lateralIndex = localIndex mod NUM_LATERAL_SLOTS
        lateralSign  = ((localIndex / NUM_LATERAL_SLOTS) mod 2 == 0) ? +1 : -1
        lateralDist  = lateralIndex * lateralStep * lateralSign

        # 3. Store incremented index
        roundIndexPerGun[gunID] = localIndex + 1

        return t_offset, lateralDist

    function computeCurtainBurstPoint(baseBurstPoint, t_offset, lateralDist):

        # Advance curtain plane along swarm motion by t_offset
        v_hat = curtainPlane.normal
        advancedOrigin = curtainPlane.origin + v_hat * (SwarmSpeedEstimate * t_offset)

        # Shift laterally along curtain span
        lateralShift = curtainSpanVector * lateralDist

        # Final burst point is baseBurstPoint projected onto advanced curtain plane
        projectedBase = Geometry.projectPointToPlane(baseBurstPoint, advancedOrigin, v_hat)
        burstPointCurtain = projectedBase + lateralShift

        return burstPointCurtain

How to use it inside the Skyranger loop

Inside your main fire‑control loop:

# Before engagement:
SalvoPlanner.updateSwarmModel(fusedTracks)

# For each round against a swarm target:
t_offset, lateralDist = SalvoPlanner.offsetForRound(swarmTrackID, gunID, roundIndex)
burstPointBase        = ComputeBurstPoint(tgtFuturePos, targetTrack, engagementMode, desiredStandOff)
burstPointCurtain     = SalvoPlanner.computeCurtainBurstPoint(burstPointBase, t_offset, lateralDist)

tof_nominal = Ballistics.solveTOF(muzzlePos, burstPointCurtain, env, projectileModel)
fuzeTime    = tof_nominal + delta_t + t_offset
MuzzleProgrammer.writeFuzeTime(fuzeTime)
Gun.fireOneRound()

What this gives you, behaviorally

  • In time: bursts are staggered (roundSpacingTime) so the curtain moves with the swarm.
  • In space: bursts are stepped laterally (lateralStep, NUM_LATERAL_SLOTS) to tile a wide front.
  • Net effect: a moving, overlapping fragment sheet that the swarm flies into, instead of chasing each drone individually.

For two Skyrangers—coordinated curtains from different bearings that cross‑hatch the swarm volume.

Concept: two Skyrangers, cross‑hatched fragment curtains

We’ll keep the swarm model shared, but give each Skyranger its own curtain orientation and timing phase, so their fragment sheets cross at angles inside the swarm volume instead of duplicating each other.

1. Shared swarm model (common to both guns)

Both Skyrangers subscribe to a shared swarm tracker (same as before):

#bgilbert1984
module SwarmModel:

    state:
        swarmID
        centroidPos
        centroidVel
        v_hat                 # swarm motion direction
        lateralBasis1, lateralBasis2
        lastUpdateTime

    function update(fusedTracks):
        swarmTracks = Filter.swarmCandidates(fusedTracks)
        if swarmTracks.empty():
            swarmID = NONE
            return

        swarmID = swarmTracks.clusterID
        centroidPos, centroidVel = Stats.fitCentroidAndVelocity(swarmTracks)
        v_hat = normalize(centroidVel)
        lateralBasis1, lateralBasis2 = OrthonormalBasis(v_hat)
        lastUpdateTime = now()

Both Skyrangers read SwarmModel each cycle.

2. Per‑gun SalvoPlanner with coordinated geometry

Each Skyranger has its own SalvoPlanner, but they’re parameterized differently:

  • Gun A: curtain spans along lateralBasis1
  • Gun B: curtain spans along lateralBasis2
  • Both advance along v_hat, but with time phase offsets so their curtains interleave.
#bgilbert1984
module SalvoPlannerGunA:

    params:
        curtainDepth_A
        roundSpacingTime_A
        lateralStep_A
        NUM_LATERAL_SLOTS_A
        timePhase_A          # e.g. 0.0 s

    state:
        roundIndex

    function offsetForRound():

        localIndex = roundIndex
        t_offset   = timePhase_A + localIndex * roundSpacingTime_A

        lateralIndex = localIndex mod NUM_LATERAL_SLOTS_A
        lateralSign  = ((localIndex / NUM_LATERAL_SLOTS_A) mod 2 == 0) ? +1 : -1
        lateralDist  = lateralIndex * lateralStep_A * lateralSign

        roundIndex += 1
        return t_offset, lateralDist

    function computeBurstPoint(baseBurstPoint, t_offset, lateralDist):

        v_hat = SwarmModel.v_hat
        origin = SwarmModel.centroidPos + v_hat * (-curtainDepth_A / 2)

        advancedOrigin = origin + v_hat * (SwarmSpeedEstimate * t_offset)
        lateralShift   = SwarmModel.lateralBasis1 * lateralDist

        projectedBase  = Geometry.projectPointToPlane(baseBurstPoint, advancedOrigin, v_hat)
        return projectedBase + lateralShift

#bgilbert1984
module SalvoPlannerGunB:

    params:
        curtainDepth_B
        roundSpacingTime_B
        lateralStep_B
        NUM_LATERAL_SLOTS_B
        timePhase_B          # e.g. roundSpacingTime_A / 2  (half‑step offset)

    state:
        roundIndex

    function offsetForRound():

        localIndex = roundIndex
        t_offset   = timePhase_B + localIndex * roundSpacingTime_B

        lateralIndex = localIndex mod NUM_LATERAL_SLOTS_B
        lateralSign  = ((localIndex / NUM_LATERAL_SLOTS_B) mod 2 == 0) ? +1 : -1
        lateralDist  = lateralIndex * lateralStep_B * lateralSign

        roundIndex += 1
        return t_offset, lateralDist

    function computeBurstPoint(baseBurstPoint, t_offset, lateralDist):

        v_hat = SwarmModel.v_hat
        origin = SwarmModel.centroidPos + v_hat * (-curtainDepth_B / 2)

        advancedOrigin = origin + v_hat * (SwarmSpeedEstimate * t_offset)
        lateralShift   = SwarmModel.lateralBasis2 * lateralDist   # note: basis2

        projectedBase  = Geometry.projectPointToPlane(baseBurstPoint, advancedOrigin, v_hat)
        return projectedBase + lateralShift

3. Integration in each Skyranger’s fire‑control loop

On Gun A:

#bgilbert1984
SwarmModel.update(fusedTracks)

t_offset, lateralDist   = SalvoPlannerGunA.offsetForRound()
burstPointBase          = ComputeBurstPoint(tgtFuturePos, targetTrack, engagementMode, desiredStandOff)
burstPointCurtain       = SalvoPlannerGunA.computeBurstPoint(burstPointBase, t_offset, lateralDist)

tof_nominal = Ballistics.solveTOF(muzzlePos, burstPointCurtain, env, projectileModel)
fuzeTime    = tof_nominal + delta_t + t_offset
MuzzleProgrammer.writeFuzeTime(fuzeTime)
Gun.fireOneRound()

On Gun B:

#bgilbert1984
SwarmModel.update(fusedTracks)

t_offset, lateralDist   = SalvoPlannerGunB.offsetForRound()
burstPointBase          = ComputeBurstPoint(tgtFuturePos, targetTrack, engagementMode, desiredStandOff)
burstPointCurtain       = SalvoPlannerGunB.computeBurstPoint(burstPointBase, t_offset, lateralDist)

tof_nominal = Ballistics.solveTOF(muzzlePos, burstPointCurtain, env, projectileModel)
fuzeTime    = tof_nominal + delta_t + t_offset
MuzzleProgrammer.writeFuzeTime(fuzeTime)
Gun.fireOneRound()

4. What the cross‑hatch actually does

  • Gun A lays a moving curtain sweeping left–right in lateralBasis1.
  • Gun B lays a moving curtain sweeping in lateralBasis2, roughly orthogonal.
  • Time phases (timePhase_A, timePhase_B) ensure their bursts interleave, not coincide.
  • Inside the swarm’s path, drones encounter a 3D lattice of overlapping fragment volumes—a cross‑hatched kill grid instead of a single flat wall.

If you want, we can now add sector deconfliction (ensuring the two Skyrangers never fire through each other’s fragment volumes or LOS) and a resource manager that decides which gun throttles back when density is already sufficient.

1. New pieces we’re adding

  • Sector deconfliction:
    Make sure Gun A never fires through Gun B’s LOS or near its predicted fragment volumes (and vice versa).
  • Resource manager:
    If the local fragment density in the swarm volume is already high enough, one gun throttles back or pauses.

2. Shared utilities

#bgilbert1984
module GeometryUtils:

    function lineOfSightIntersectsGun(otherGunPos, thisGunMuzzle, burstPoint):
        # Simple LOS check: does the ray from this gun to burstPoint pass near other gun?
        rayDir   = normalize(burstPoint - thisGunMuzzle)
        closest  = ClosestPointOnRayToPoint(thisGunMuzzle, rayDir, otherGunPos)
        dist     = norm(closest - otherGunPos)
        return dist < LOS_SAFE_RADIUS

    function predictFragmentVolume(burstPoint, v_hat, coneAngle, effectiveRange):
        # Approximate as a frustum or ellipsoid
        return FragmentVolume(burstPoint, v_hat, coneAngle, effectiveRange)

3. Fragment density estimator (shared)

#bgilbert1984
module FragmentDensity:

    state:
        recentBursts   # list of {gunID, burstPoint, time, patternParams}

    function registerBurst(gunID, burstPoint, patternParams):
        recentBursts.append({gunID, burstPoint, now(), patternParams})
        # prune old entries
        recentBursts = [b for b in recentBursts if now() - b.time < DENSITY_WINDOW]

    function estimateDensityAt(point):
        density = 0.0
        for b in recentBursts:
            vol = GeometryUtils.predictFragmentVolume(
                      b.burstPoint,
                      b.patternParams.v_hat,
                      b.patternParams.coneAngle,
                      b.patternParams.effectiveRange
                  )
            if vol.contains(point):
                density += b.patternParams.fragmentCount / vol.volume()
        return density

4. Resource manager

#bgilbert1984
module ResourceManager:

    params:
        DENSITY_TARGET      # desired fragment density at swarm centroid
        DENSITY_HYSTERESIS  # to avoid rapid toggling

    state:
        gunEnabled[gunID]   # bool

    function updateGunStates():

        if SwarmModel.swarmID == NONE:
            gunEnabled[A] = true
            gunEnabled[B] = true
            return

        centroid = SwarmModel.centroidPos
        density  = FragmentDensity.estimateDensityAt(centroid)

        if density < DENSITY_TARGET:
            gunEnabled[A] = true
            gunEnabled[B] = true
        else:
            # Throttle one gun based on geometry / ammo / doctrine
            if GunStatus[A].ammoLow and not GunStatus[B].ammoLow:
                gunEnabled[A] = false
                gunEnabled[B] = true
            elif GunStatus[B].ammoLow and not GunStatus[A].ammoLow:
                gunEnabled[B] = false
                gunEnabled[A] = true
            else:
                # default: alternate or prefer better bearing
                gunEnabled[A] = true
                gunEnabled[B] = false

    function isGunEnabled(gunID):
        return gunEnabled[gunID]

5. Sector deconfliction per gun

On each Skyranger, before accepting a burst solution:

#bgilbert1984
function sectorDeconflictionCheck(thisGunID, burstPointCurtain):

    otherGunID   = (thisGunID == A) ? B : A
    thisMuzzle   = GunState[thisGunID].muzzle
    otherPos     = GunState[otherGunID].muzzle

    # 1. LOS safety: don’t shoot through the other gun
    if GeometryUtils.lineOfSightIntersectsGun(otherPos, thisMuzzle, burstPointCurtain):
        return false

    # 2. Fragment volume overlap near other gun
    fragVol = GeometryUtils.predictFragmentVolume(
                  burstPointCurtain,
                  SwarmModel.v_hat,
                  coneAngle = DEFAULT_CONE_ANGLE,
                  effectiveRange = DEFAULT_EFFECTIVE_RANGE
              )

    if fragVol.distanceToPoint(otherPos) < FRAG_SAFE_RADIUS:
        return false

    return true

6. Updated per‑gun fire‑control loop (Skyranger A/B)

On each Skyranger:

#bgilbert1984
loop FireControlCycle:

    SwarmModel.update(fusedTracks)
    ResourceManager.updateGunStates()

    if not ResourceManager.isGunEnabled(thisGunID):
        continue

    # ... target selection, baseBurstPoint, etc. as before ...

    if thisGunID == A:
        t_offset, lateralDist = SalvoPlannerGunA.offsetForRound()
        burstPointCurtain     = SalvoPlannerGunA.computeBurstPoint(baseBurstPoint, t_offset, lateralDist)
    else:
        t_offset, lateralDist = SalvoPlannerGunB.offsetForRound()
        burstPointCurtain     = SalvoPlannerGunB.computeBurstPoint(baseBurstPoint, t_offset, lateralDist)

    if not sectorDeconflictionCheck(thisGunID, burstPointCurtain):
        continue

    tof_nominal = Ballistics.solveTOF(muzzlePos, burstPointCurtain, env, projectileModel)
    fuzeTime    = tof_nominal + delta_t + t_offset

    MuzzleProgrammer.writeFuzeTime(fuzeTime)
    Gun.fireOneRound()

    FragmentDensity.registerBurst(thisGunID, burstPointCurtain, patternParams)

end loop

7. Net behavior

  • No mutual fratricide:
    Each gun checks LOS and fragment volumes against the other’s position before firing.
  • Adaptive fire:
    When the swarm volume is already saturated, the resource manager idles or slows one gun, saving ammo and heat.
  • Cross‑hatched grid:
    As long as density is below target, both guns keep building orthogonal, time‑staggered curtains, giving you that 3D kill lattice you were aiming for.