Research procedural 2D animation techniques
Transcript
Thinking21:38:33
I should look into this using web search and fetch tools, so I need to pull up their schemas via tool search first.
ToolSearch (select:WebSearch,WebFetch)
Thinking21:38:36
I'll kick off several web searches in parallel to gather the research I need.
WebSearchRain World procedural animation GDC 2017 Joar Jakobsson James Primate slugcat21:38:42Output not recorded
Rain World procedural animation GDC 2017 Joar Jakobsson James Primate slugcatWebSearchDavid Rosen GDC 2014 Animation Bootcamp Indie Approach to Procedural Animation Overgrowth transcript21:38:42Output not recorded
David Rosen GDC 2014 Animation Bootcamp Indie Approach to Procedural Animation Overgrowth transcriptWebSearch2D two bone inverse kinematics law of cosines tutorial Alan Zucconi21:38:42Output not recorded
2D two bone inverse kinematics law of cosines tutorial Alan ZucconiWebSearchCeleste hair p8 Maddy Thorson procedural secondary motion code21:38:42Output not recorded
Celeste hair p8 Maddy Thorson procedural secondary motion codeWebSearchRyan Juckett damped spring interpolation game animation21:38:42Output not recorded
Ryan Juckett damped spring interpolation game animationWebSearchprocedural walk cycle foot planting stepping IK game programming21:38:42Output not recorded
procedural walk cycle foot planting stepping IK game programmingThinking21:38:51
I should search more specifically now—looking into Gibbon's procedural brachiation, Sebastian Lague's spider-leg IK, the actual Celeste hair source code, Rain World's reaching mechanics, Overgrowth's limb systems, foot placement logic, and squash-and-stretch juice techniques.
WebSearchSebastian Lague procedural animation spider legs IK stepping video21:38:56Output not recorded
Sebastian Lague procedural animation spider legs IK stepping videoWebFetchhttps://www.gameanim.com/2017/07/24/rain-world-animation-process/21:38:56Output not recorded
https://www.gameanim.com/2017/07/24/rain-world-animation-process/WebSearchceleste.p8 source code hair points chain lag github21:38:56Output not recorded
celeste.p8 source code hair points chain lag githubWebSearch"Gibbon: Beyond the Trees" procedural animation arms reaching brachiation devlog21:38:56Output not recorded
"Gibbon: Beyond the Trees" procedural animation arms reaching brachiation devlogWebSearchsquash and stretch velocity lean acceleration game feel juice Vlambeer21:38:56Output not recorded
squash and stretch velocity lean acceleration game feel juice VlambeerThinking21:39:08
I want to gather more targeted sources — Alan Zucconi's IK articles, Little Polygon's loco blog, Ryan Juckett's damped springs writeup, the Gibbon animation pieces from Game Anim and Game Developer, the Rain World dev coverage, and any Rosen notes on Are.na — plus search for specifics on Rain World's IK grab-point reaching. I'll run these fetches in parallel.
WebFetchhttps://blog.littlepolygon.com/posts/loco1/21:39:15Output not recorded
https://blog.littlepolygon.com/posts/loco1/WebFetchhttps://www.ryanjuckett.com/damped-springs/21:39:15Output not recorded
https://www.ryanjuckett.com/damped-springs/WebFetchhttps://www.gameanim.com/2022/09/24/the-procedural-animation-of-gibbon-beyond-the-trees/21:39:15Output not recorded
https://www.gameanim.com/2022/09/24/the-procedural-animation-of-gibbon-beyond-the-trees/WebFetchhttps://www.alanzucconi.com/2018/05/02/ik-2d-2/21:39:15Output not recorded
https://www.alanzucconi.com/2018/05/02/ik-2d-2/WebFetchhttps://www.alanzucconi.com/2018/05/02/ik-2d-1/21:39:15Output not recorded
https://www.alanzucconi.com/2018/05/02/ik-2d-1/WebFetchhttps://www.gamedeveloper.com/programming/deep-dive-physics-based-animation-in-gibbon-beyond-the-trees21:39:15Output not recorded
https://www.gamedeveloper.com/programming/deep-dive-physics-based-animation-in-gibbon-beyond-the-treesThinking21:39:28
I still need more specific material—Rain World's IK/body chain details, the Rosen talk notes, Celeste hair specifics, part two of the littlepolygon stepping approach, and a game feel juice reference like Making Things Move or Squeeze. Let me pull the are.na block for the Rosen notes and the gameanim article on procedural animation next.
WebFetchhttps://www.are.na/block/1025955821:39:32Output not recorded
https://www.are.na/block/10259558WebFetchhttps://www.gameanim.com/2018/03/04/indie-approach-procedural-animation/21:39:32Output not recorded
https://www.gameanim.com/2018/03/04/indie-approach-procedural-animation/WebSearchRain World slugcat "always something" idle animation devlog reaching grab points body simulation21:39:32Output not recorded
Rain World slugcat "always something" idle animation devlog reaching grab points body simulationWebFetchhttps://blog.littlepolygon.com/posts/loco2/21:39:32Output not recorded
https://blog.littlepolygon.com/posts/loco2/WebSearchCeleste hair physics pico-8 source code "hair" table points trail21:39:32Output not recorded
Celeste hair physics pico-8 source code "hair" table points trailThinking21:39:43
I should pull up the actual Celeste hair implementation source to see the concrete details like the hair color and movement functions.
WebSearchRain World GDC talk transcript "grasp" limbs reach points procedural creature Joar Jakobsson body parts21:39:49Output not recorded
Rain World GDC talk transcript "grasp" limbs reach points procedural creature Joar Jakobsson body partsWebFetchhttps://gist.github.com/ARival/0aeb903deed022b7040e2fa9b0b9258621:39:49Output not recorded
https://gist.github.com/ARival/0aeb903deed022b7040e2fa9b0b92586Thinking21:39:53
Good, that confirms the procedural animation approach with connected points in space. I should pull up the gamedeveloper "Video: Animating Rain World" article and the "Road to IGF" piece for more on the body chain description.
WebFetchhttps://www.gamedeveloper.com/art/video-animating-i-rain-world-i-and-its-many-squishy-stretchy-creatures21:39:58Output not recorded
https://www.gamedeveloper.com/art/video-animating-i-rain-world-i-and-its-many-squishy-stretchy-creaturesWebFetchhttps://www.gamedeveloper.com/business/road-to-the-igf-videocult-s-i-rain-world-i-21:39:58Output not recorded
https://www.gamedeveloper.com/business/road-to-the-igf-videocult-s-i-rain-world-i-I now have enough material to write a thorough, well-sourced report.
WebSearchExanima procedural animation pose blend physics ragdoll Bare Mettle21:40:07Output not recorded
Exanima procedural animation pose blend physics ragdoll Bare MettleWebSearch"Making Things Move" 2D game animation squash stretch tutorial platformer character21:40:07Output not recorded
"Making Things Move" 2D game animation squash stretch tutorial platformer characterI have sufficient sourced material now to write the report.
WebSearchGodot 2D IK Skeleton2D tutorial two bone constraint platformer21:40:18Output not recorded
Godot 2D IK Skeleton2D tutorial two bone constraint platformerGood, that's enough for the Godot citation. Now I'll compile the full report.
Procedural animation for a tiny code-drawn platformer character
1. David Rosen — "Animation Bootcamp: An Indie Approach to Procedural Animation" (GDC 2014)
Rosen's talk (drawn from Overgrowth, Receiver, and Black Shades) is the foundational reference for exactly this kind of build: a small number of authored poses driven by code rather than frame-by-frame animation. No full public transcript exists, but the talk itself and secondary write-ups converge on the same core ideas:
- A handful of key poses, not frames. Instead of animating a run cycle frame-by-frame, you author a few static "key poses" (e.g., contact pose, passing pose, apex pose for a stride) as target positions/rotations for each bone or limb-end. Everything else is generated at runtime.
- State-driven interpolation. Movement state (grounded/airborne, speed, crouching, etc.) selects and blends between key poses rather than playing a timeline. A run cycle is literally "blend from pose A to pose B based on stride phase," where phase is derived from distance traveled or speed, not wall-clock time — this is why Overgrowth's characters can change speed or reverse direction without foot-sliding or popping.
- Physics-driven secondary motion. On top of the base pose, simple physics (springs, velocity/acceleration reactions) drives ears, tails, cloth, and loose limbs so they lag and overshoot believably — this is layered after the base pose is computed, as an additive offset.
- Mirroring. Because most creatures/characters are left-right symmetric, only one side's pose needs to be authored; the other limb is the same pose mirrored and phase-offset (e.g., left leg = right leg pose at phase + 0.5). This immediately halves the authoring burden and is directly applicable to a 2D biped's two legs/two arms.
- Blending as the animation system's actual job. The "animation" is really a continuous blend controller: current pose = weighted mix of nearby key poses, updated every tick as state changes, so transitions are automatic rather than authored per-transition.
For a 2D limb character, this maps directly: author key poses as sets of 2D limb-end targets (hand/foot positions relative to the body) for stand, contact-step, passing-step, crouch, jump-apex, etc.; drive the blend weight/phase from horizontal speed and air/ground state; mirror the leg/arm pair; add spring-driven secondary motion on top.
Sources: GDC Vault — Animation Bootcamp: An Indie Approach to Procedural Animation, YouTube upload of the talk, Game Developer write-up/video summary, GameAnim summary, Internet Archive copy.
2. Rain World's procedural animation (Joar Jakobsson & James Therrien, GDC 2016 "Animation Bootcamp: Rainworld Animation Process")
Note: the talk is commonly mis-cited as 2017; GDC's own listing dates it 2016, credited to Jakobsson and James Therrien ("James Primate" is Therrien's musician alias). No open transcript exists, but consistent secondary descriptions give the mechanism:
- Body as a chain of points with distance constraints. The slugcat (and other creatures) is represented as a set of points in space connected by fixed-distance links — essentially a verlet/rope-like chain — rather than a rigid skeleton with rotation joints. This is why the creature reads as "squishy and stretchy": the chain can bend, compress and stretch within the constraint tolerances.
- Limbs reach for grab points (IK toward targets). Rather than predefined animations, the game "defines limbs and tells creatures how to use them": each limb has logic that decides where to reach (a graspable point — a ledge, a pole, terrain) and then solves toward that target, effectively a simple IK/attraction system layered on the point-chain body.
- "Always doing something" idle/continuous motion. Even when nominally idle, the body chain keeps settling, adjusting balance, and micro-adjusting limb holds under gravity, so the creature never looks frozen — this emerges from the constraint solver and reach logic running continuously rather than from an authored idle animation.
- Interplay of animation and AI. The GDC talk explicitly frames the session as being about the animation process and its intersection with creature AI — the AI decides intent (where to move, what to grab), and the procedural body figures out the physical execution.
For your 2D character, the relevant translation is: treat "grab points" (ledges, ropes, wall surfaces) as explicit targets that hand/foot IK reach toward when in ledge-hang/climb/rope states, and let a lightweight physical settle (spring or verlet-style relaxation) keep the pose alive at rest instead of a static held frame.
Sources: GDC Vault — Animation Bootcamp: 'Rainworld' Animation Process, YouTube — The Rain World Animation Process, GameAnim summary, Game Developer video summary, Road to the IGF: Videocult's Rain World.
3. 2D two-bone IK (closed form) and walk-cycle foot placement
Two-bone IK via law of cosines. Alan Zucconi's two-part tutorial is the clearest public reference. Given a fixed root (e.g., shoulder/hip), a target (hand/foot position), and two segment lengths a (upper) and b (lower), you know all three sides of the triangle formed by root, joint, and target (the third side is the root→target distance, clamped to a+b if the target is out of reach). The law of cosines gives the interior angles directly:
- angle at the root: α = acos((d² + a² − b²) / (2·d·a)), where d is root-to-target distance
- angle at the "elbow/knee": β = acos((a² + b² − d²) / (2·a·b))
The root bone's world angle is (angle to target) ± α, and the joint bends by π − β. Bend direction (elbow/knee side) is chosen by the sign you apply to α: adding vs. subtracting picks the "elbow forward" vs. "elbow back" solution — of the two valid IK solutions, you pick whichever matches the character's facing/knee convention (for legs you almost always want the knee bending forward/same side consistently, which you enforce by fixing the sign rather than solving for it). When the target is farther than a+b, just fully extend toward it (zero bend) instead of failing.
Sources: Alan Zucconi — Inverse Kinematics in 2D, Part 1 (math), Part 2 (code); Godot's built-in equivalent is SkeletonModification2DTwoBoneIK, documented at Godot docs — SkeletonModification2DTwoBoneIK and covered in community 2D-rig tutorials referencing Skeleton2D cutout rigs (see 2D skeletons — Godot docs).
Foot placement / stepping logic. The clearest concrete write-up is the Little Polygon "Procedural Animation: Locomotion" series:
- Part 1 sets up the body: lean angle is derived from the cross product of "up" with acceleration (then low-pass filtered so it doesn't snap), hip bob/roll comes from a sine oscillator whose amplitude is driven by speed, and every one of these signals (lean, hip amplitude, rotation) is smoothed with a damped spring, not a raw lerp.
- Part 2 adds the actual stepping system: each foot is "pinned" (planted, not moving in world space) while grounded, phase-offset by π from the other foot (this is essentially a mirrored gait). A
StepExtrapterm projects the target foot placement ahead of the body using current velocity, so feet land in front of the body's motion rather than directly underneath (this is the general "step when the planted foot lags too far behind the body" rule you asked about — concretely: measure the distance between the foot's current planted position and its ideal position under the moving body; once that error exceeds a threshold, release the foot and start a step toward the new ideal position). The lift/land motion uses a custom up-then-ease-out arc (not a plain circular arc) so the foot "glides" into contact rather than stomping.
This generalizes cleanly to 16×24px sprites at low speed by just using very few (2–3) phase segments per step and heavily damping the lean/hip terms so they don't read as noisy at small scale.
Sources: Little Polygon — Procedural Animation: Locomotion, Part 1, Part 2 (stepping) at the same blog under /posts/loco2/; general foot-IK/raycast grounding framing in Wayline — Breathing Life into Games: Procedural Animation Techniques.
4. Spring-based pose interpolation, squash/stretch, lean, landing recovery
Damped springs (Ryan Juckett). Juckett's widely-ported reference models each animated quantity (a limb-target coordinate, a body offset, a lean angle) as a damped harmonic oscillator: a + 2ωζv + ω²x = 0, where ω (angular frequency) sets speed and ζ (damping ratio) sets bounciness — ζ<1 underdamped (oscillates/overshoots, good for a bouncy landing recovery), ζ=1 critically damped (fastest no-overshoot settle, good for general pose-target following), ζ>1 overdamped (slow, no overshoot). The trick that makes it fast enough for many simultaneous springs (one per limb-end, one per body-offset axis, etc.) is precomputing four coefficients per (ω, ζ, fixed-timestep) combination, then each tick just doing newPos = c1*pos + c2*vel + c3*targetPos, newVel = ... — cheap enough for dozens of springs at 120 Hz. This is exactly the mechanism to make "state changes animate themselves": you don't tween from pose A to pose B, you just change the spring's target and let it chase.
Applications directly relevant to your character:
- Pose interpolation: each limb-end/body-offset target is a 2D spring; switching stand→walk→jump just changes the spring's target point per state, and the spring produces the transition motion for free.
- Squash-and-stretch from velocity: scale the body silhouette (or offset head/feet) along the velocity vector — stretch along motion direction proportional to speed, squash perpendicular to preserve volume — is the standard 12-principles application; a GameMaker-focused platformer tutorial demonstrates this concretely for a small sprite-based character (relevant even though your character is primitive-drawn, since squash/stretch there just becomes scaling the primitives or offsetting a couple of joint points along the velocity axis).
- Lean from acceleration: same cross-product / low-pass technique as the Little Polygon post — lean angle target ∝ acceleration, spring-damped so it doesn't jitter on every input tick.
- Landing-recovery bounce: on landing, feed a velocity impulse (proportional to fall speed) into the vertical-offset spring instead of directly setting position; an underdamped spring naturally produces a squash-and-recover bounce over a few ticks with zero authored frames.
- Juice framing: Jan Willem Nijman's (Vlambeer) "Art of Screenshake" talk is the classic source for treating squash/stretch, recoil, and secondary reactions as compounding, cheap "juice" layered on top of core motion — useful as the design rationale even though it isn't a springs-math source.
Sources: Ryan Juckett — Damped Springs (math + C++ reference implementation, ported widely e.g. C# gist); Little Polygon locomotion posts (springs applied to lean/hip/rotation); Game Developer — Squeezing more juice out of your game design (Vlambeer's Art of Screenshake); GameMaker platformer squash-and-stretch tutorial.
5. Secondary motion: hair/scarf/tail chains that lag
celeste.p8's hair is the standard minimal reference and is public. The implementation is a tiny chain of nodes, each pulled toward the previous node with exponential smoothing (a first-order lag, the discrete cousin of a spring):
create_hair = function(obj)
obj.hair = {}
for i=0,4 do
add(obj.hair,{x=obj.x, y=obj.y, size=max(1,min(2,3-i))})
end
end
draw_hair = function(obj, facing)
local last = {x=obj.x+4-facing*2, y=obj.y+(btn(k_down) and 4 or 3)}
foreach(obj.hair, function(h)
h.x += (last.x-h.x)/1.5
h.y += (last.y+0.5-h.y)/1.5
...
last = h
end)
endEach of the five hair nodes chases the node ahead of it (ultimately the head anchor) by moving 1/1.5 of the remaining distance each frame; node size shrinks toward the tip. This is a critically-damped-ish exponential follow (not a full spring — no overshoot), which is why Madeline's ponytail visibly lags behind head movement and streams backward under acceleration/direction changes, cheaply communicating velocity/direction at a tiny sprite size (this same trick generalizes to a scarf, cape, tail, or antenna — just change chain length, per-node lag factor, and taper). Because it's a positional lag chain rather than a rotation-based skeleton, it's very cheap and trivially extends to any point-follows-anchor-with-delay case (e.g., a tail following the hip, antennae following the head) — you'd typically give leading segments a tighter follow (smaller lag divisor) and tip segments a looser one for a whip-like taper.
Source: celeste.p8 PICO-8 source, publicly mirrored e.g. Celeste PICO-8 source gist; background on the PICO-8 prototype and its relation to the full game in Wikipedia — Celeste (video game)) and Maddy Thorson's own posts on Medium — Celeste and TowerFall Physics (movement/physics notes, not hair-specific, but same author/codebase philosophy of small hand-tuned constants over generality).
6. Open-source / concrete examples of small limbed characters with reach/wall/climb poses
- Gibbon: Beyond the Trees (Broken Rules, prototyped by David Rosen/Wolfire) is the most relevant "reaching for grab points" case study beyond Rain World. The gibbon is modeled at multiple levels of detail — a 2-point rig (hand + center of mass) for swing/launch decisions, escalating to a 5-point then 14-point rig for display — and the key finding is that grab-arm reach direction is chosen to be roughly perpendicular to current velocity (minimizing energy loss on grab), with the flight arc between handholds picked by generating and scoring several candidate ballistic arcs rather than a closed-form solution. This is directly analogous to a ledge-grab/rope-climb reach target selection: the hand's target isn't just "the ledge point," it's chosen relative to the character's current velocity vector for a natural-looking catch. Sources: Game Developer — Deep Dive: Physics-based animation in Gibbon: Beyond the Trees, GameAnim — The Procedural Animation of Gibbon: Beyond the Trees, Hemisphere Games mirror of the deep dive.
- Overgrowth / Receiver / Black Shades (Wolfire) — same Rosen key-pose + blend system described in §1; Overgrowth is the fullest public example of the technique applied to a humanoid.
- Rain World — full body-chain + limb-reach system, §2 above; closest analogue to a "creature made of points with constrained distances reaching for grab points," which is essentially what a 2D ledge-hang/climb pose needs (hands as targets, body as a soft chain).
- Sebastian Lague-style spider-leg IK — while I could not confirm a specific Sebastian Lague video in this search, the same "leg lags behind body until error exceeds threshold, then steps in an arc to a new raycast-found foothold" pattern (identical in spirit to Little Polygon's stepping logic in §3) shows up in many open Unity procedural-spider projects, e.g. PhilS94 — Unity-Procedural-IK-Wall-Walking-Spider (GitHub), useful mainly as a second worked example of the "distance-triggered step" rule generalized to N legs.
- Godot 2D IK tooling —
SkeletonModification2DTwoBoneIKin Godot'sSkeleton2Dsystem is a ready reference implementation of the exact law-of-cosines solver described in §3, usable as a working-code cross-check: Godot docs — SkeletonModification2DTwoBoneIK, and a community itch.io tech demo built around the same idea: 2D Procedural / IK walk demo. - Exanima (Bare Mettle) is the 3D pose-blend-plus-physics case you asked about; I was not able to retrieve a detailed public technical write-up beyond general "blend keyframed pose with a physics/ragdoll pose, with a blend window" descriptions common to that genre of technique (e.g. MoCap Online — Ragdoll Physics in Games: How to Blend Animation); treat this one as conceptually consistent with, but not independently confirmed beyond, the general animation-physics-blend pattern.
Recommended minimal architecture
Authored per pose (data only, no code): for each named pose (stand, walk-contact, walk-pass, run-contact, run-pass, crouch, jump, fall, wall-slide, ledge-hang, climb-up-start/end, rope-climb-A/B, hurt, dead) author just:
- a body/hip offset (2D point, relative to the character's anchor) and optionally a body tilt angle,
- a head offset (2D point) and head tilt,
- one 2D target point per limb end (hand-L, hand-R, foot-L, foot-R) in body-local space.
That's on the order of 6–10 numbers per pose — small enough to hand-place by eye for a 16×24px sprite, and small enough that mirroring (left/right swap) can be automatic for symmetric poses, halving the authoring again per Rosen's approach.
What's procedural, layered in this order each simulation tick:
- State machine → pose selection. Movement state (grounded/air/wall/ledge/rope/hurt/dead) plus a phase variable (for cyclic states: stride phase driven by distance traveled, not time, so speed changes don't cause foot-sliding) picks either one static pose (stand, jump, hurt) or two poses to blend between (walk-contact↔walk-pass, or the current/target pose during a state transition).
- Pose blend. Linearly interpolate the two selected poses' body offset, head offset, and each limb-end target by the phase or transition weight. This is the direct output of the "key pose" system — cheap and deterministic.
- Spring smoothing. Feed the blended targets (body offset, head offset, each limb-end) into per-quantity damped springs (Juckett-style) rather than snapping to them directly. This is what makes every state change "animate itself": crouching, landing, and turning all get their transition motion for free from the spring's own response curve, with no authored in-between frames. Use a stiffer/critically-damped spring for limb-ends (so they track responsively) and a slightly underdamped one for the body's vertical offset (so landings/jumps get a bit of bounce/recovery).
- Procedural overrides for reach states. In wall-slide, ledge-hang, climb, and rope-climb, override the relevant hand/foot target(s) with the actual world-space grab point (ledge corner, rope segment, wall surface point) transformed into body-local space, then solve two-bone IK (law of cosines, §3) for the elbow/knee bend, with a fixed bend-direction convention (elbow back, knee forward) chosen per limb. This is the Rain-World/Gibbon "limbs reach for targets" layer sitting on top of the authored-pose layer.
- Continuous "alive" motion. Add a small always-on idle drift (slow sine or low-frequency noise on body offset/head offset) so held poses (stand, ledge-hang) never look frozen — Rain World's "always doing something" principle — cheap to fake at this scale as a low-amplitude spring target that itself drifts slightly.
- Derived juice, computed from velocity/acceleration, applied as a final additive/multiplicative pass: squash-and-stretch scale from speed and vertical velocity (stretch on fast fall/jump, squash on landing impact, feeding an impulse into the landing spring rather than setting position directly), lean angle from acceleration (low-pass filtered, itself spring-smoothed), and any secondary chains (a cape/hair/ear if the character has one) updated last since they must read the already-moved head/body position from this tick.
- IK solve for legs against ground contact, if you want feet to avoid interpenetrating uneven ground: recompute foot targets from a downward probe near the blended pose's foot position, apply the same distance-threshold "step" rule as Little Polygon's system (if planted-foot error exceeds a threshold, release and animate a step arc to the new target), then solve two-bone IK for the leg.
The dependency order matters: pose-select → blend → spring-smooth → reach/IK overrides → idle drift → juice (squash/lean) → secondary chains, each stage consuming the previous stage's output as its input, all recomputed every tick at 120 Hz. Nothing here requires storing more than a few key poses and a handful of spring states per limb — which is exactly the point of Rosen's, Rain World's, and Gibbon's shared approach: author intent (poses, targets), let cheap runtime dynamics (blends, springs, IK, chains) generate the motion.
Sources: GDC Vault — Rosen, Animation Bootcamp · GameAnim summary of Rosen's talk · GDC Vault — Rainworld Animation Process · GameAnim — Rain World process · Alan Zucconi — 2D IK Part 1 / Part 2 · Godot SkeletonModification2DTwoBoneIK · Little Polygon — Locomotion Part 1 (Part 2 at the same blog) · Ryan Juckett — Damped Springs · Game Developer — Vlambeer/Art of Screenshake juice write-up · celeste.p8 hair source (gist mirror) · Maddy Thorson — Celeste and TowerFall Physics · Game Developer — Deep Dive: Gibbon: Beyond the Trees · GameAnim — Gibbon procedural animation · Unity procedural wall-walking spider (GitHub).