Build and play great shmups in the open

// devlog — latest posts

• Game Design · June 30, 2026

  Bullet Pattern Design in Shmups: Parametric Scripting and Spatial Choreography

  Designing readable, learnable bullet patterns requires thinking in polar coordinates, writing patterns as parameterized functions, and respecting the telegraph window that gives the player time to read the attack. A guide to ring bursts, spiral scripting, density math by difficulty tier, and layering complexity without eliminating the safe lane.

• Game Dev · June 28, 2026

  Building a Shmup for a Game Jam: Scope, Speed, and the Art of Shipping

  Shmups are approachable for game jams but easy to scope wrong under time pressure. A realistic 48-hour time breakdown, the four systems you cannot cut, the features to drop without hesitation, and what to protect even in the final hours — plus why web export must be tested at the start, not the end.

• Game Dev · June 28, 2026

  Shader Effects in 2D Shmups: Glow, Distortion, and Visual Polish

  Shaders are the most cost-effective visual upgrade available to a 2D shmup. A practical guide to threshold-based bloom for bullets, per-sprite glow as a lightweight alternative, shield distortion shaders, damage flash implementation, and color-grade post-processing — with the readability constraint that governs all of it.

• Shmup Design · June 28, 2026

  Leaderboards and High Score Tables in Indie Shmups: Design and Implementation

  The high score table is the oldest and still one of the most effective progression loops in gaming. A guide to local table storage and checksumming, per-configuration leaderboard splits, online submission anti-cheat, and the replay attachment that transforms a score into a teaching tool.

• Shmup Design · June 28, 2026

  Enemy AI State Machines in Shmups: Designing Readable Adaptive Behavior

  Finite state machines give shmup enemies predictable, learnable behavior without feeling scripted. A guide to FSM architecture, transition condition design, shared base classes for enemy families, and debugging AI behavior through state overlay logging.

• Game Dev · June 28, 2026

  Sprite Animation for Shmups: Cycles, Frame Timing, and Visual Character

  Sprite animation is how a shmup's ships and enemies communicate life and intention. A practical guide to idle cycles, banking and tilt for player ships, enemy attack-tell animations, explosion frame design, and managing the sprite budget under a heavy entity load.

• Game Programming · June 28, 2026

  Fixed Timestep and Delta Time in Shmups: Determinism and Smooth Motion

  The frame-update strategy determines whether bullet patterns are deterministic, replays are trustworthy, and the game feels identical on 60 Hz and 144 Hz monitors. A deep look at fixed timestep accumulation, the spiral-of-death failure mode, and interpolated rendering for visual smoothness.

• Shmup Design · June 25, 2026

  Co-Op Shmup Design: Balancing Two Players Without Punishing Either

  Adding a second player changes nearly every design assumption in a solo shmup. A practical guide to co-op difficulty scaling, shared versus individual lives, friendly fire tradeoffs, power-up distribution, and screen-space management for two ships.

• Shmup Design · June 25, 2026

  Level Pacing in Shmups: Designing the Arc of a Stage

  A shmup level is a directed arc, not a bag of waves. A design guide to opening orientation, tension-and-relief cycling, mid-level signature encounters, scroll speed as a pacing lever, and structuring the final approach to the boss.

• Game Dev · June 25, 2026

  Particle Effects in Shmups: Explosions, Bullet Trails, and Visual Clarity

  Particle effects in a shmup must serve readability before aesthetics. A practical guide to explosion draw-order, bullet trail design, impact flash hierarchies, and performance budgeting for particle pools under high bullet-count scenarios.

• Shmup Design · June 25, 2026

  Scoring Systems in Shmups: Combos, Extends, and the Loop That Keeps Players Coming Back

  A good shmup scoring system is a second game running beneath the survival game. A design guide covering chain combos, score extends, risk-reward pickup systems, and how score structure drives replay motivation across many sessions.

• Game Programming · August 9, 2026

  Debugging Collision Detection Bugs in 2D Shmups

  Phantom deaths and bullets that pass through enemies are both collision bugs. A debugging guide covering hitbox overlays, bullet tunneling and swept detection, frame-order ghost hits, broadphase performance, and replay-based diagnosis for intermittent failures.

• Game Dev · August 2, 2026

  Spawning Systems and Wave Design in Shmups: Building a Level From Nothing

  A shmup level is a directed sequence of enemy appearances driven by a spawner system. A technical and design guide to data-driven wave definitions, time versus trigger spawning, formation design logic, and difficulty scaling through the spawner.

• Game Dev · July 26, 2026

  Vector vs Raster Art for Indie Shmups: Tradeoffs and Workflows

  Pixel art versus vector graphics is one of the first decisions in an indie shmup and one of the hardest to reverse. A practical comparison covering scaling behavior, animation pipelines, performance, and visual hierarchy in bullet-dense play fields.

• Shmup Design · July 19, 2026

  Save States and Continue Systems in Shmups: Balancing Access and Challenge

  How a shmup handles continues, stage select, and saving shapes who can finish it. A design guide covering the tradeoffs between arcade-authentic one-credit challenges and accessible progression systems that serve a wider audience.

• Game Dev · July 12, 2026

  Camera Shake and Screen Effects for Shmup Game Feel

  Camera shake, screen flash, freeze frames, and hit stop are the feedback layer that makes impacts feel real. A practical implementation guide calibrated to the visual readability demands of a bullet-hell play field.

• Game Programming · July 5, 2026

  Input Handling in Shmups: Responsiveness and Player Control Feel

  Input handling determines whether a shmup feels tight and responsive or sluggish and frustrating. A guide to polling vs event-driven input, diagonal normalization, gamepad deadzone calibration, and focus-loss stuck-key bugs.

• Game Dev · June 28, 2026

  Porting Your Godot Shmup to the Web: What Actually Breaks

  Godot's HTML5 export is reliable for many game types, but a precision-sensitive shmup hits specific friction points: audio autoplay restrictions, Web Audio latency, keyboard focus loss, mobile performance, and file size. A practical fix guide.

• Shmup Design · June 21, 2026

  Boss Fight Design for Indie Shmups: Phases, Tells, and Player Communication

  A well-designed boss fight is a compressed test of everything the preceding level taught. Phase structure, attack telegraphing, health-threshold transitions, and the death sequence all require careful thought to land the way they should.

• Game Dev · June 14, 2026

  Chiptune and Retro Music for Shmups: What Makes It Work

  Chiptune persists in the shmup genre for reasons beyond nostalgia. A look at why sparse waveforms mix better with sound effects, how tempo interacts with bullet density, loop structure for extended play, and free tools for the job.

• Shmup Design · June 7, 2026

  Power-Up Systems in Shmups: Risk, Reward, and Weapon Feel

  Power-ups create the weapon progression arc that gives a run its shape. A look at stacking versus switching models, drop rate tuning, the design of power loss on death, and making each upgrade feel like a tangible gain.

• Game Programming · May 31, 2026

  Screen Scrolling Techniques in 2D Shmups: Parallax, Speed, and Direction

  Scrolling determines how fast threat arrives and how large the world feels. A technical and design overview of vertical versus horizontal scrolling, variable scroll speed, multi-layer parallax, and forced versus free-scroll tradeoffs.

• Shmup Design · May 24, 2026

  Hitbox Design in Shmups: Making Unfair Situations Feel Fair

  The difference between a bullet-hell that feels brutal-but-fair and one that feels cheap often comes down to a few pixels. A design breakdown of small player hitboxes, grace periods, grazing mechanics, and invincibility frames.

• Shmup Design · May 17, 2026

  Enemy Movement Patterns in Shmups: From Formations to Flocking

  Enemy movement is half the game in a shoot-em-up. Bullets get the attention, but it is the motion of the enemies themselves that sets rhythm and pressure. A breakdown of scripted paths, sine weaves, homing logic, and formation cohesion.

• Game Dev · February 22, 2026

  Playtesting Your Indie Game: Methods That Actually Work

  Watching someone else play your game for the first time is humbling and invaluable. Playtesting is not QA — it is design research. Here is how to structure sessions, what to observe, and what to do with what you learn.

• Tools · March 1, 2026

  Free and Open-Source Tools for 2D Game Development

  You do not need a commercial engine or paid tools to build a 2D shmup. From Godot to LibreSprite, the open-source toolchain is more complete than it has ever been. A curated overview of what is worth your time.

• Game Dev · March 8, 2026

  Game Audio for Indie Developers: Sound on a Small Budget

  Audio does more work in a shmup than players realise — hit feedback, music intensity, and UI sounds are all part of the game feel. A guide to sourcing, editing, and implementing audio without a dedicated sound team.

• Open Source · March 15, 2026

  How to Contribute to an Open-Source Game Project

  Contributing code to an open-source game is different from contributing to a library. Art pipelines, asset licensing, and playtesting all come into play. A practical guide to making your first meaningful contribution.

• Game Dev · March 22, 2026

  Level Editors in Games: Why Built-In Tools Change Everything

  Flukz shipped with a built-in level editor from its first public release. That decision shaped the community around it. A look at why editor-first design matters for small open-source projects and how to build one that people actually use.

• Shmup Design · March 29, 2026

  Designing Difficulty Curves That Feel Fair

  A game that kills you repeatedly is not automatically hard — it may just be poorly balanced. Difficulty curves should teach, then challenge, then reward. Here is how to design a progression that respects the player.

• Game Programming · April 5, 2026

  Sprites and Collision Detection: The Shmup Foundation

  Shmup gameplay lives or dies on collision detection. AABB, circle overlap, pixel-perfect — each approach has tradeoffs. A guide to choosing the right method for a 2D shoot-em-up and implementing it without bugs.

• Game Programming · April 12, 2026

  Building a Simple Game Loop for a 2D Shmup

  Every game runs on a loop: read input, update state, render, repeat. Getting that loop right is more subtle than it looks. Here is a practical breakdown, with code sketches, for a basic shoot-em-up architecture.

• Open Source · April 19, 2026

  GPL Licensing for Games: What It Means in Practice

  Releasing a game under the GPL is not the same as releasing a library under it. Art assets, music, and engine code create overlapping licensing questions. A plain-language guide to what the GPL actually requires for a game project.

• Genre History · April 26, 2026

  A Brief History of Shoot-'Em-Ups: From Space Invaders to Touhou

  Shmups have a richer history than their reputation as quarter-munchers suggests. From fixed shooters through scrolling space games to the bullet-hell wave, the genre has been in constant technical and artistic evolution.

• Shmup Design · May 10, 2026

  Bullet-Hell Patterns Explained: Rings, Fans, and Spirals

  Bullet-hell games are not random chaos. They use a small vocabulary of geometric patterns to create readable, learnable challenges. A breakdown of the most common formations and the design logic behind them.

• Shmup Design · May 3, 2026

  What Makes a Great Shoot-'Em-Up

  Great shmups share a few non-negotiable qualities: responsive controls, readable bullet patterns, and feedback loops that reward skilled play. Here is what separates the memorable from the merely competent.