Enter your vehicle and mission, or drag the start, velocity and goal. Every planner solves the same problem in the plant your numbers define, and you can train the network on it.

Drag start, velocity and goal · Double-click to set the goal · R random · Space play
t = 4.00 s

Train a model for your vehicle.

Step 0
live

Training log updates live while training

Every
steps
Validation metrics are measured on the same fixed set of unseen missions at every row. Δ val is the change from the row below. Time excludes compilation and pauses.

How it works

OTiS plans simulated maneuvers for a rocket, a drone (UAV), or a surface boat (USV). Set a starting position, velocity and goal, then compare the paths and see how close each planner gets for the effort it spends.

The interesting question is whether a neural network can learn to produce a useful plan in one pass, instead of solving an optimization problem afresh for every mission. OTiS checks that learned shortcut against the convex optimum: the best score available under the same model and thrust limits.

From a mission to 50 commands

  1. Describe the mission

    The network reads six numbers: two for position, two for velocity and two for the goal. It outputs 50 two-axis thrust commands at once. Each command is held for an equal slice of the mission time.

  2. Learn through practice

    Training draws random simulated missions and flies the network's plans. The simulator is differentiable: it tells training how changing a command would change the score. Those gradients, or directions for improvement, update the network without a collection of expert flight plans.

  3. Balance miss and effort

    The score combines squared final miss distance with control effort, the sum of squared thrust commands. Effort is a fuel proxy, not a measurement of propellant burned. A larger fuel weight puts more value on gentle commands; a smaller one favors accuracy.

Try it and compare

Choose Rocket, UAV or USV in the Simulator. Drag the start, velocity arrow or goal, or edit the vehicle parameters. Compare paths, final miss, effort and planning time on the same mission.

The neural planner is an approximation, not a guarantee of the best plan. The convex / KKT optimum is the reliable reference for this model, so check the score gap as well as the path.

Available neural weights, live training and recorded training replays depend on the running app. Its Network and Training panels show what is available for the selected parameters.

Know what arrival means

This is a fly-through, not a landing. The score cares about position at the end of the mission, but does not require a final velocity or a soft stop. A miss is penalized, not forbidden, so even the optimum may trade some accuracy for less effort.

Apollo E-guidance is a bounded steering law: a formula that repeatedly aims toward the goal while respecting thrust limits. It is not a reachability guarantee. Saturation (requested thrust exceeding the limit) and drag compensation can cause misses even on reachable missions. It does not match a final velocity either.

Technical details

The model and its exact transition

All three presets use a two-dimensional point-mass model: position and velocity, without attitude, obstacles or detailed aerodynamics. Thrust accelerates the vehicle, linear drag slows it, and gravity acts downward. Units are SI.

dp/dt = vdv/dt = (Fmax/m)u − (c/m)v − [0, g]

Here p and v are two-axis position and velocity; Fmax is maximum thrust per axis, m is mass, c is the linear drag coefficient and g is gravity. Each throttle component u is bounded between −1 and 1.

Python and the browser use an exact linear zero-order-hold transition: they solve this model over each step with thrust held constant, rather than approximating it with RK4. With step length h = mission time / 50, define k = c/m and a = (Fmax/m)u − [0, g].

e = exp(−k h),   τ = (1 − e)/k,   q = (h − τ)/kpnext = p + τv + qavnext = ev + τa

The implementation uses expm1 and small-drag series to avoid cancellation: subtracting nearly equal numbers would otherwise lose precision. At zero drag, e = 1, τ = h and q = h2/2. Exact refers to this simplified model, subject to floating-point precision, not to real-world flight.

The legacy stiffness admission limit remains: combinations with (c/m)h > 32 are rejected, corresponding to more than 64 former RK4 substeps. This is a retained parameter guard, not the integrator used today.

What training minimizes

J = ‖p50 − pgoal‖2+ λ ∑i=049 (ui,x2 + ui,y2)

λ is lambda_fuel, the weight on effort. There is no terminal-velocity term. The same objective scores the neural and convex plans; the effort sum is not a physical fuel-consumption model.

Linear dynamics and box-bounded commands make this a convex quadratic problem: a problem whose optimum can be found reliably rather than guessed. The KKT optimality conditions provide a numerical reference by bisection. The Python app can also solve the same problem with CVXPY and Clarabel; the browser uses the KKT solution.

The learned shortcut

The policy is a residual multilayer perceptron: connected layers with skip connections that help training. Pre-layer normalization rescales internal features, GELU is a smooth activation, and a final tanh plus clipping bounds the commands. One forward pass means running these layers once to produce the whole open-loop plan, without replanning during that rollout.

Inputs include scaled position, velocity and goal, goal-minus-position, and a zero-effort-miss feature: a simple estimate of the miss without thrust using initial velocity and a gravity correction. That feature is not the exact drag-aware free-flight solution; the simulator still uses drag when scoring the plan.

Weights are tied to thrust-to-mass, gravity, drag-to-mass, mission time and effort weight. A plan learned for one setting should not be treated as validated for another. JAX, Flax and Optax support training; the interface uses plain HTML, CSS and JavaScript, with no build step or external math library.