Building an automated missile interception algorithm (ongoing)

This post is intentionally dense: lists, blockquotes, math, tables, images with captions, and footnotes that link out (and even sneak in a line of code). If the layout survives this, it survives anything.¹

Overview

The project is a 3D-ish intercept simulation: incoming threats move along ballistic-ish arcs; a defender learns when to launch and how to steer mid-course corrections so the interceptor meets the threat. Think less “production missile defense” and more “gym environment where I can iterate on reward shaping without filing export paperwork.”²

Unordered laundry list of what actually exists in the repo today:

• Simulation core: discrete time steps, configurable gravity, drag hacks³, noisy sensors.
• Policy: started with a hand-tuned PD-ish baseline, moving toward PPO/SAC-style updates (see log).
• Visualization: WebGL preview + offline GIF exports for debugging angles and bone rig stupidity.

What “done” means (for now)

1. Reproducible training runs with a fixed seed.
2. Intercept rate above random on a held-out threat distribution.
3. A single command to record a rollout GIF for the README.
4. Stop lying to myself in the README about how finished any of this is.

Note: The hardest part hasn’t been neural networks. It’s time. When your simulation step isn’t aligned with how you log events, you get “ghost” intercepts that never happened — only your instrumentation thinks they did.

Nested blockquote, because why not:

Early prototype mantra:

Make it run. Make it right. Make it fast.
(I’m still somewhere between one and two.)

Log and Notes

A longer, messier stream of thoughts + experiments lives in the dedicated notes page: missile interception — log + notes. Below is the “executive summary” version with figures.

Vocabulary (definition list)

Kramdown-style definitions — handy for glossaries:

RL loop

Agent observes state \(s_t\), emits action \(a_t\), environment returns \(s_{t+1}\) and reward \(r_t\). Rinse⁴.

Interceptor

The controllable object trying to meet the threat; not assumed to have unlimited lateral acceleration.

Threat

Anything you want to not reach the protected volume — modeled as a point mass first, fancier later.

Simulation sketch (code)

Python — environment step (toy)

@dataclass
class Vec3:
    x: float
    y: float
    z: float

    def __add__(self, o: "Vec3") -> "Vec3":
        return Vec3(self.x + o.x, self.y + o.y, self.z + o.z)

    def scale(self, s: float) -> "Vec3":
        return Vec3(self.x * s, self.y * s, self.z * s)

def step(pos: Vec3, vel: Vec3, acc: Vec3, dt: float) -> tuple[Vec3, Vec3]:
    """Semi-implicit Euler — good enough until energy blows up."""
    vel_next = vel + acc.scale(dt)
    pos_next = pos + vel_next.scale(dt)
    return pos_next, vel_next

Bash — one-liner to grep my own chaos

rg -n "TODO|FIXME|WTF" src/ notes/ --glob '!_site/**'

JavaScript — time slider mental model (what broke my brain)

// Discrete ticks; "continuous" feel is just small dt + good interpolation.
function clamp(x, lo, hi) {
  return Math.min(hi, Math.max(lo, x));
}

export function advanceTime(t, dt, tMax) {
  return clamp(t + dt, 0, tMax);
}

GLSL — fake “heat” in the debug view (fragment idea)

precision mediump float;
varying vec2 vUv;
uniform float uTime;
uniform vec2 uThreatPos;
uniform vec2 uInterceptPos;

void main() {
  float dThreat = distance(vUv, uThreatPos);
  float dIntercept = distance(vUv, uInterceptPos);
  float heat = exp(-12.0 * dThreat) + 0.6 * exp(-10.0 * dIntercept);
  vec3 col = mix(vec3(0.05, 0.07, 0.12), vec3(1.0, 0.35, 0.1), heat);
  gl_FragColor = vec4(col, 1.0);
}

JSON — config fragment

{
  "simulation": {
    "dt": 0.02,
    "max_episode_seconds": 45,
    "integrator": "semi_implicit_euler"
  },
  "rewards": {
    "intercept_bonus": 100.0,
    "distance_shaping": true
  }
}

Reward hacking (ordered list of failure modes)

1. Agent learns to stall just inside the success radius without intercepting — looks good in logs, is cowardice.
2. Huge terminal reward causes value explosions; advantage estimates go brrr.
3. Shaped distance rewards fight terminal sparse rewards unless you schedule curriculum.
4. You “fix” (3) by adding more terms until the reward is a Christmas tree and nobody knows what’s being optimized.

Table: what I thought vs what the metrics said

Links, footnotes, and cross-refs

• Internal: writing index · this site’s notes
• External resources I keep reopening: Spinning Up in Deep RL · Stable-Baselines3 docs

Reward shaping sketch (don’t copy-paste blindly):⁵

Table stress tests (long cells, code, TeX, dollars)

Footer: three-column layout with inline code and inline math \(\mathbb{E}[\cdot]\).

Footer: currency + a deliberately verbose third column.

Extreme table torture

Pure layout stress: horizontal scroll, vertical scroll, dense grids, mixed modalities. If anything looks off, tweak .page-content table in fugg2.css — not your prose.

Absurdly wide grid (12 columns × 17 data rows)

Wide grid footer — check overflow-x, cell padding, and last-column long text.

Absurdly tall runbook (4 columns × 54 data rows)

Tall runbook footer — row hover, alternating statuses, one obese note row.

Dense numeric matrix (16 × 16, every cell filled)

Dense matrix footer — typography at small sizes, column alignment, thead vs tbody.

Mixed chaos (empty cells, long strings — pipes only as delimiters)

Chaos footer — empty cells, code with pipe characters inside backticks, ultra-long strings.

Screenshot archaeology

Sometimes the most “real” artifact is a random screengrab from a late night:

Exported screenshot from an older debug UI — buttons everywhere, soul nowhere.

Status: ongoing. If you’re reading this in the future and the project is still “ongoing,” then: same.