littlejsengine 1.18.12 → 1.18.15

package/FAQ.md

@@ -4,7 +4,7 @@ Welcome to the LittleJS FAQ!
 This document addresses common questions and issues to help developers get started and troubleshoot their projects.
 If you don't find an answer here, feel free to ask the community or check the documentation.
 
-Getting Started
+**Getting Started**
 - [What is LittleJS, and how is it different from other JavaScript game engines?](#what-is-littlejs-and-how-is-it-different-from-other-javascript-game-engines)
 - [How do I set up a basic LittleJS project?](#how-do-i-set-up-a-basic-littlejs-project)
 - [How do I use LittleJS as an ES module?](#how-do-i-use-littlejs-as-an-es-module)
@@ -12,11 +12,14 @@ Getting Started
 - [Why do I see a blank screen when I run my game?](#why-do-i-see-a-blank-screen-when-i-run-my-game)
 - [Do I need a local server to run LittleJS games, and how do I set one up?](#do-i-need-a-local-server-to-run-littlejs-games-and-how-do-i-set-one-up)
 - [How does the camera and world coordinate systems work?](#how-does-the-camera-and-world-coordinate-systems-work)
+- [How do I configure engine settings?](#how-do-i-configure-engine-settings)
+- [What plugins ship with LittleJS?](#what-plugins-ship-with-littlejs)
 - [How do I use Vite with LittleJS?](#how-do-i-use-vite-with-littlejs)
 - [How do I use Box2D with Vite?](#how-do-i-use-box2d-with-vite)
 - [How do I build and publish my game?](#how-do-i-build-and-publish-my-game)
+- [How do I shrink my game for js13kGames?](#how-do-i-shrink-my-game-for-js13kgames)
 
-Graphics and Sound
+**Graphics and Sound**
 - [How do I load and add images to my game?](#how-do-i-load-and-add-images-to-my-game)
 - [What is the tile function and how do tile indexes work?](#what-is-the-tile-function-and-how-do-tile-indexes-work)
 - [Can I add and switch between multiple sprites for a game object?](#can-i-add-and-switch-between-multiple-sprites-for-a-game-object)
@@ -25,20 +28,25 @@ Graphics and Sound
 - [How do I control the camera in LittleJS?](#how-do-i-control-the-camera-in-littlejs)
 - [How do I use post-processing shaders?](#how-do-i-use-post-processing-shaders)
 - [How do I play sounds in LittleJS?](#how-do-i-play-sounds-in-littlejs)
+- [How do I play music?](#how-do-i-play-music)
+- [Why doesn't my audio play until the user clicks something?](#why-doesnt-my-audio-play-until-the-user-clicks-something)
 - [If I load several images, how do I control which is used?](#if-i-load-several-images-how-do-i-control-which-is-used)
 - [How can I check if an object is on screen?](#how-can-i-check-if-an-object-is-on-screen)
 
-Gameplay and Programming
+**Gameplay and Programming**
 - [How do I add keyboard or mouse input to my game?](#how-do-i-add-keyboard-or-mouse-input-to-my-game)
 - [How does touch input work on mobile?](#how-does-touch-input-work-on-mobile)
 - [How do I create and update game objects?](#how-do-i-create-and-update-game-objects)
+- [How do I use parent/child objects?](#how-do-i-use-parentchild-objects)
+- [How do collisions work?](#how-do-collisions-work)
 - [How can I load a 2D level map?](#how-can-i-load-a-2d-level-map)
 - [Can I use physics with LittleJS?](#can-i-use-physics-with-littlejs)
 - [How do I add particle effects to my game?](#how-do-i-add-particle-effects-to-my-game)
+- [How do I use timers?](#how-do-i-use-timers)
 - [How do I save and load game state?](#how-do-i-save-and-load-game-state)
 - [How do I use the medals (achievements) system?](#how-do-i-use-the-medals-achievements-system)
 
-Debugging and Development
+**Debugging and Development**
 - [How do I debug my game in LittleJS?](#how-do-i-debug-my-game-in-littlejs)
 
 ---
@@ -47,9 +55,9 @@ Debugging and Development
 ### What is LittleJS, and how is it different from other JavaScript game engines?
 
 LittleJS is a lightweight, high-performance JavaScript game engine designed for simplicity and speed.
-It offers a hybrid rendering system that combines the advantages of WebGL and 2D Canvas.
-Unlike larger, feature-heavy engines, LittleJS focuses on 2D games and providing a comprehensive set of simple, easy to use features.
-LittleJS is perfect for developers who want a minimal yet powerful engine to bring their 2D game ideas to life without the complexity of larger frameworks.
+It offers a hybrid rendering system that combines the advantages of WebGL and 2D Canvas, and in our sprite-rendering benchmarks it outperforms larger engines like Phaser, Pixi, and Kaboom.
+Unlike those feature-heavy engines, LittleJS focuses on 2D games and providing a comprehensive set of simple, easy to use features.
+LittleJS is perfect for developers who want a minimal yet powerful engine to bring their 2D game ideas to life without the complexity of larger frameworks, and it's especially well suited for size-constrained competitions like js13kGames.
 
 ### How do I set up a basic LittleJS project?
 
@@ -67,6 +75,7 @@ The most basic example is just an empty project.
 
 <script src=../../dist/littlejs.js></script>
 <script src=game.js></script>
+</body></html>
 ```
 
 [Empty Example JavaScript file:](https://github.com/KilledByAPixel/LittleJS/blob/main/examples/empty/game.js)
@@ -198,9 +207,54 @@ Another option is to setup a simple local web server like [http-server](https://
 
 LittleJS drawing functions are all handled in world coordinates by default.
 The conversion from world to screen is determined by the camera position and scale as well as the canvas size in pixels.
-Camera scale determines how many screen pixels equals 1 world unit while the cameraPosition is the offset in world units.
+Camera scale determines how many screen pixels equals 1 world unit while the cameraPos is the offset in world units.
 There is also a function you can use called getCameraSize() to get the viewable camera window in world coordinates.
 
+One thing to keep in mind: in **world space**, Y increases *upward* and tile coordinates use a bottom-left origin. This often surprises developers coming from Canvas2D or other 2D libraries. **Screen space** (used when you pass `screenSpace=true` to a draw function, or when reading `mousePosScreen`) follows the Canvas2D convention instead — Y increases *downward* with a top-left origin. Pick the right one for what you're doing: world space for gameplay, screen space for HUDs and UI overlays.
+
+### How do I configure engine settings?
+
+LittleJS exposes settings through `setX()` functions for every tunable value. Most settings need to be applied **before** `engineInit()` because they affect canvas creation, WebGL setup, or input registration:
+
+```javascript
+setCanvasFixedSize(vec2(640, 480));   // lock canvas to a fixed resolution
+setCanvasPixelated(true);             // crisp pixel-art scaling
+setGLEnable(false);                   // Canvas2D only (no WebGL)
+setShowSplashScreen(false);           // skip the LittleJS splash
+setGravity(vec2(0, -.02));            // global gravity for physics
+setTileDefaultSize(vec2(8));          // default tile size for tile()
+
+engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost, ['tiles.png']);
+```
+
+A few common categories of settings:
+
+- **Canvas** — `setCanvasFixedSize`, `setCanvasMaxSize`, `setCanvasMinAspect`, `setCanvasPixelated`, `setCanvasPixelRatio`
+- **Rendering** — `setGLEnable`, `setTilesPixelated`, `setCanvasClearColor`
+- **Physics** — `setGravity`, `setObjectDefaultDamping`, `setObjectDefaultRestitution`, `setEnablePhysicsSolver`
+- **Audio** — `setSoundEnable`, `setSoundVolume`, `setSoundDefaultRange`
+- **Input** — `setTouchInputEnable`, `setTouchGamepadEnable`, `setInputWASDEmulateDirection`
+
+Camera settings (`setCameraPos`, `setCameraScale`, `setCameraAngle`) are safe to call at runtime — typically from `gameInit` or `gameUpdate`. See [src/engineSettings.js](src/engineSettings.js) for the full list with defaults.
+
+### What plugins ship with LittleJS?
+
+Plugins are self-contained features that live alongside the engine but aren't part of it — nothing in the core engine source references them, and they only depend on the public engine API. Drop in only what you need:
+
+| Plugin | Purpose |
+|--------|---------|
+| `box2d.js` | Full Box2D physics via WebAssembly (more realistic than the built-in arcade physics) |
+| `postProcess.js` | Shadertoy-style fragment shaders for screen-wide effects |
+| `uiSystem.js` | Lightweight in-engine UI widgets (buttons, text, tabs) |
+| `tweenSystem.js` | Tween any property over time with easing curves |
+| `pathFinder.js` | Grid-based A* pathfinding with optional path smoothing |
+| `medalSystem.js` | Achievement / medal tracking with toast notifications |
+| `newgrounds.js` | Newgrounds.io integration (scoreboards, cloud saves) |
+| `zzfxm.js` | Procedural chiptune music via the `ZzFXMusic` class |
+| `drawUtilities.js` | Higher-level drawing helpers like nine-slice and three-slice |
+
+This self-contained design means the community can also ship plugins independently of the main repo — you can write your own plugin as just a JavaScript file that uses the engine's public API.
+
 ### How do I use Vite with LittleJS?
 
 There is an official [Vite](https://vite.dev) starter template in `examples/vite-starter`. The fastest way to start a new project from it is with [degit](https://github.com/Rich-Harris/degit):
@@ -293,6 +347,17 @@ Then zip up your game folder for itch.io or push to GitHub Pages.
 
 **For size coding competitions** like js13kGames, see the [js13k branch](https://github.com/KilledByAPixel/LittleJS/tree/js13k) which provides a build that fits in 7KB zipped.
 
+### How do I shrink my game for js13kGames?
+
+LittleJS has a dedicated [js13k branch](https://github.com/KilledByAPixel/LittleJS/tree/js13k) that builds to about 7KB zipped, leaving most of the 13KB budget for your game. A few practical tips for hitting tiny sizes:
+
+- **Use Canvas2D instead of WebGL**: call `setGLEnable(false)` before `engineInit`. Stripping the WebGL renderer saves a significant chunk of bytes, and for most pixel-art and low-sprite-count games the visual difference is imperceptible. A nice side effect: once the jam is over, you can flip WebGL back on with a single setting change for a big performance boost when publishing the game elsewhere.
+- **Drop unused plugins**: every plugin is self-contained, so only include what you actually use. Skip `uiSystem.js`, `box2d.js`, `pathFinder.js`, etc. unless you need them.
+- **Lean on built-ins to avoid asset files**: `Sound` with ZzFX parameters generates sound effects from a tiny array, `ZzFXMusic` makes procedural chiptunes, and built-in shape drawing avoids shipping image assets.
+- **Use a packer**: the js13k branch is set up to compress the final bundle with Roadroller or a similar packer. Check the branch's build script for the current toolchain.
+
+For normal production (non-13KB) builds, the engine ships `dist/littlejs.release.js` (asserts stripped) and `dist/littlejs.min.js` (minified) — both well under 100KB.
+
 ---
 
 ## Graphics and Sound
@@ -390,8 +455,8 @@ this.tileInfo = playerSprite.frame(animationFrame);
 ### How do I control the camera in LittleJS?
 
 LittleJS uses a world space rendering system, so objects can move independently of the camera.
-The camera is easy to control using cameraPosition and cameraScale, which indicate the world space position and how many pixels is equivalent to one world unit.
-The default cameraScale is 32 while the default cameraPosition is just the origin.
+The camera is easy to control using cameraPos and cameraScale, which indicate the world space position and how many pixels is equivalent to one world unit.
+The default cameraScale is 32 while the default cameraPos is just the origin.
 It is also possible to draw using screen space pixel coordinates by passing in true as the screenSpace parameter to most drawing functions.
 
 ```javascript
@@ -427,8 +492,8 @@ The constructor has two optional positional arguments after the shader source:
 new PostProcessPlugin(shader, includeMainCanvas, feedbackTexture);
 ```
 
-- `includeMainCanvas=true` composites the Canvas2D layer (where some debug and text rendering goes) onto the WebGL canvas before the shader runs. Pass `true` if your post-process effect should apply to *everything* on screen, not just the WebGL-rendered objects.
-- `feedbackTexture=true` makes the previous frame available as `iChannel0` for effects like motion trails or feedback loops. Mutually exclusive with `includeMainCanvas`.
+- `includeMainCanvas` (default `false`) composites the Canvas2D layer (where some debug and text rendering goes) onto the WebGL canvas before the shader runs. Pass `true` if your post-process effect should apply to *everything* on screen, not just the WebGL-rendered objects.
+- `feedbackTexture` (default `false`) makes the previous frame available as `iChannel0` for effects like motion trails or feedback loops. Mutually exclusive with `includeMainCanvas`.
 
 See [plugins/postProcess.js](plugins/postProcess.js) and the [Breakout example](https://killedbyapixel.github.io/LittleJS/examples/breakout/) for working post-process effects.
 
@@ -444,6 +509,28 @@ const sound_jump = new Sound('jump.mp3'); // load an mp3 sound
 sound_click.play(pos, volume, pitch); // play a sound
 ```
 
+### How do I play music?
+
+For procedural chiptune music, use the `ZzFXMusic` class from the [ZzFXM plugin](plugins/zzfxm.js). It extends `Sound` and accepts a ZzFXM-format song array — the music is generated on the fly so it adds essentially no bytes to your build. For longer scored music, load an mp3 or ogg file with the regular `Sound` class and pass `true` as the loop parameter.
+
+```javascript
+// procedural ZzFXM music (tiny, generated at runtime)
+const music = new ZzFXMusic(zzfxmSongData);
+music.play();
+
+// or load an mp3/ogg and loop it
+const music = new Sound('music.mp3');
+music.play(undefined, 1, 1, 0, true); // pos, volume, rate, pan, loop
+```
+
+Both pause automatically when the tab loses focus (audio context suspends) and resume when it comes back. Use `music.stop()` to halt playback.
+
+### Why doesn't my audio play until the user clicks something?
+
+Browsers require a user interaction (click, key press, touch) before audio is allowed to play — this is a hard rule from the browser's autoplay policy, not something the engine can bypass. LittleJS handles the actual resume for you: the audio context starts in a suspended state and is automatically resumed on the first input event. You don't need to call `audioContext.resume()` yourself.
+
+The practical implication is that sounds you try to play during `gameInit()` or on the very first frame won't be audible. Design opening audio (title-screen music, intro sounds) so it kicks in after the first input — a common pattern is a "Press any key to start" screen that begins playing music the moment the player presses something.
+
 ### If I load several images, how do I control which is used?
 
 Pass multiple image paths to `engineInit` and select between them with the third argument to `tile()` (the `texture` index):
@@ -543,6 +630,55 @@ Common things you'll do on an `EngineObject`:
 - `this.gravityScale = 0` — disable gravity for this object (e.g. UI or floating objects)
 - `this.destroy()` — remove from the world (calls cleanup on children too)
 
+### How do I use parent/child objects?
+
+`EngineObject` supports a parent/child hierarchy with local transforms. Attached children automatically follow their parent's position, angle, and mirror state each frame:
+
+```javascript
+const ship = new EngineObject(vec2(10, 5), vec2(2));
+const turret = new EngineObject(vec2(), vec2(.5));
+ship.addChild(turret, vec2(0, .5));  // turret sits .5 units above the ship in local space
+```
+
+`addChild(child, localPos, localAngle)` attaches the child with a local offset; the child's world-space `pos` and `angle` are recomputed each frame from the parent's transform. To detach, call `parent.removeChild(child)` — or just `child.destroy()`, which also detaches it (and destroying a parent destroys all its children).
+
+A few things to know:
+- **Mirroring a parent flips children** — a mirrored ship has its turret on the correct side automatically (`localPos.x` and `localAngle` are inverted).
+- **Velocity is not inherited** — physics runs on the world transform after parenting, so a child doesn't automatically pick up the parent's velocity. If you need that, set the child's velocity manually before attaching.
+- **For decorative attachments** that shouldn't be affected by physics, set `gravityScale = 0` and skip `setCollision()` on the child.
+
+### How do collisions work?
+
+Opt in to collision on an `EngineObject` by calling `setCollision()` — by default it's off so most objects don't pay the collision cost.
+
+```javascript
+class Player extends EngineObject {
+    constructor(pos) {
+        super(pos, vec2(1), tile(0, 16));
+        this.setCollision(); // collide with solid objects and tile map
+    }
+}
+```
+
+`setCollision(collideSolidObjects, isSolid, collideTiles, collideRaycast)` — all default to `true`. Pass `false` to opt out of any of them (e.g. a ghost that passes through walls: `setCollision(false, false, false)`).
+
+For custom collision logic, override `collideWithObject(other)` and `collideWithTile(tileData, pos)` on your subclass. Return `true` to actually block the collision, `false` to pass through. Both fire during the physics step:
+
+```javascript
+class Bullet extends EngineObject {
+    collideWithObject(other) {
+        if (other instanceof Enemy) {
+            other.damage(1);
+            this.destroy();
+            return false; // don't physically bounce off the enemy
+        }
+        return true; // solid collision with everything else
+    }
+}
+```
+
+For raycasting against the tile collision map (line-of-sight checks, hitscan weapons, etc.), use `tileCollisionRaycast(start, end)` which returns the hit position or `undefined`.
+
 ### How can I load a 2D level map?
 
 There are two parts that work together to make 2D level maps in LittleJS.
@@ -578,6 +714,36 @@ new ParticleEmitter(
 );
 ```
 
+### How do I use timers?
+
+The `Timer` class is a small but very useful utility for anything that needs to happen *after some time has passed* — cooldowns, animation timing, delayed spawns, fades, etc. It tracks elapsed time automatically, so you don't have to add `timeDelta` to a variable every frame.
+
+```javascript
+const cooldown = new Timer(2); // 2-second timer, starts immediately
+
+function gameUpdate() {
+    if (cooldown.elapsed()) {
+        fireWeapon();
+        cooldown.set(2); // restart it
+    }
+}
+```
+
+Useful methods:
+- `set(seconds)` — start or restart the timer
+- `unset()` — disable it (`isSet()` becomes false)
+- `active()` / `elapsed()` — boolean checks
+- `get()` — seconds elapsed (negative while still counting down)
+- `getPercent()` — 0 → 1 progress, handy for easing animations
+
+By default, a timer ticks on **game time** — it pauses when the game is paused and slows down or speeds up with `setTimeScale`. For UI animations, on-screen notifications, or anything that should keep running regardless of game state, use a real-time timer:
+
+```javascript
+const uiFade = new Timer(.5, true); // useRealTime = true
+```
+
+Real-time timers track `timeReal` instead of `time` — unaffected by pause or time scale. You can also flip an existing timer between modes with `timer.setUseRealTime(true)` while it's unset.
+
 ### How do I save and load game state?
 
 LittleJS has built-in helpers for localStorage-backed save data — no need to roll your own JSON serialization:
@@ -618,10 +784,26 @@ The plugin also supports [Newgrounds](https://www.newgrounds.com) integration vi
 
 ### How do I debug my game in LittleJS?
 
-In addition to your browser's built in developer mode, LittleJS has its own debug view.
-Press the Esc key to show the debug menu. From here there are several options that can be accessed via the number keys.
+In addition to your browser's built-in developer tools, LittleJS has its own debug overlay. Press `Esc` to show it — the overlay lists the available toggles and their number-key bindings, so you don't have to memorize them. `+` and `-` adjust the time scale, which is great for slowing tricky moments down or speeding past a slow section.
+
+**Debug draw functions** let you visualize state directly in the world without committing to permanent UI. They're drawn for one frame and only render in debug builds:
+
+```javascript
+debugRect(pos, size, color);           // outline a rectangle
+debugCircle(pos, radius, color);       // outline a circle
+debugLine(posA, posB, color);          // a line between two points
+debugText(string, pos, size, color);   // text at a world position
+debugPoint(pos, color);                // small marker
+```
 
-You can also press + or - to adjust game speed to help with debugging, or just for fun!
+These are perfect for "where exactly is this AI heading?" or "is this hitbox where I think it is?" investigations — drop a call into your update or render code, see the answer, then delete it.
+
+**`ASSERT` and `LOG`** are similar to `console.assert` / `console.log`, but they're *stripped from release builds* (`littlejs.release.js`, `littlejs.min.js`). That means you can leave them in your code with no cost to shipped users. Don't rely on side effects inside the arguments — they won't run in release.
+
+```javascript
+ASSERT(player.health > 0, 'player damaged below zero', player);
+LOG('spawned enemy at', pos);
+```
 
 ---
 

package/README.md

@@ -8,6 +8,7 @@
 [![Build Size][build-size]][build-size-url]
 [![NPM Downloads][npm-downloads]][npmtrends-url]
 [![DeepScan][deepscan]][deepscan-url]
+[![MIT License][license]][license-url]
 [![Discord][discord]][discord-url]
 
 </div>
@@ -24,7 +25,7 @@ The code is very clean and well documented with many examples to get you started
 
 <div align='center' markdown='1'>
 
-## [Demos](https://killedbyapixel.github.io/LittleJS/examples) | [Docs](https://killedbyapixel.github.io/LittleJS/docs) | [Trailer](https://youtu.be/chuBzGjv7Ms) | [Discord](https://discord.gg/zb7hcGkyZe) | [FAQ](https://github.com/KilledByAPixel/LittleJS/blob/main/FAQ.md)
+## [Demos](https://killedbyapixel.github.io/LittleJS/examples) | [Docs](https://killedbyapixel.github.io/LittleJS/docs) | [Reference](https://github.com/KilledByAPixel/LittleJS/blob/main/REFERENCE.md) | [FAQ](https://github.com/KilledByAPixel/LittleJS/blob/main/FAQ.md) | [Trailer](https://youtu.be/chuBzGjv7Ms) | [Discord](https://discord.gg/zb7hcGkyZe)
 
 </div>
 
@@ -89,21 +90,37 @@ npm install
 npm run dev
 ```
 
+Here is a minimal Hello World example game.
+
+```html
+<!DOCTYPE html>
+<script src="../dist/littlejs.js"></script>
+<script>
+function gameInit() {}
+function gameUpdate() {}
+function gameUpdatePost() {}
+function gameRender() {}
+function gameRenderPost() { drawTextScreen('Hello World!', mainCanvasSize.scale(.5), 80); }
+engineInit(gameInit, gameUpdate, gameUpdatePost, gameRender, gameRenderPost);
+</script>
+```
+
 ## Tutorials
 
 - [Making Awesome Games With LittleJS](https://youtu.be/_dXKU0WgAj8?si=ZDXLYAFDWp54hrGT) - A short talk about LittleJS with some tips on how to use it.
 - [Tutorial: Breakout](https://github.com/KilledByAPixel/LittleJS/tree/main/examples/breakoutTutorial) - Learn how to make a simple game from scratch
 - [Tutorial: Make a ski game](https://eoinmcgrath.com/little-ski/tutorial.html) - This tutorial by eoinmcg that shows how to make a pixel art style game.
-- [LittleJS Quick Reference Sheet](https://github.com/KilledByAPixel/LittleJS/blob/main/reference.md) - A reference sheet to help you get started.
+- [LittleJS Quick Reference Sheet](https://github.com/KilledByAPixel/LittleJS/blob/main/REFERENCE.md) - A reference sheet to help you get started.
 - [Little JS FAQ](https://github.com/KilledByAPixel/LittleJS/blob/main/FAQ.md) - Answers to common questions about LittleJS.
 - [JS13k Branch](https://github.com/KilledByAPixel/LittleJS/tree/js13k) - For size coding events like JS13k there is a special branch that builds to a 7KB zip.
 - [LittleJS AI Tools](https://github.com/KilledByAPixel/LittleJS-AI) - Experiments, games, and templates to improve LittleJS + AI workflows.
 
 ## Examples
 
-LittleJS comes with a several demos both for learning and using as starter projects to create new games.
+LittleJS comes with several demos both for learning and using as starter projects to create new games.
 
-- [Example Browser](https://killedbyapixel.github.io/LittleJS/examples/) - Live example browser with all examples
+- [Example Browser](https://killedbyapixel.github.io/LittleJS/examples/) - Live example browser with all examples and editable source
+- [Short Examples](https://github.com/KilledByAPixel/LittleJS/tree/main/examples/shorts) - 60+ single-file demos showing off individual engine features
 - [Breakout](https://killedbyapixel.github.io/LittleJS/examples/breakout/) - Block breaking game with post-processing effects
 - [Puzzle Game](https://killedbyapixel.github.io/LittleJS/examples/puzzle/) - Match 3 puzzle game with HD rendering and high score tracking
 - [Platformer](https://killedbyapixel.github.io/LittleJS/examples/platformer/) - Platformer/shooter demo that loads level data
@@ -141,13 +158,15 @@ Here are a few of the many amazing games created with LittleJS...
 - [Bug&Bee](https://itch.io/jam/littlejs-game-jam-2025/results) - Low fi shoot em up with co-op gameplay. LittleJS Jam 1st place! by [eoinmcg](https://eoinmcg.itch.io/)
 - [Little Platformer](https://psemo.itch.io/little-platformer) - Platformer with many mechanics. LittleJS Jam 2st place! by [PSEMO](https://psemo.itch.io/), [Solita666](https://itch.io/profile/solita666), [GabrielRG](https://gabrielrg.itch.io/), [Nate](https://natesassoon.itch.io/)
 - [Rogue Pong](https://itch.io/jam/littlejs-game-jam-2025/rate/4004165) - Roguelike crossed with classic pong gameplay. LittleJS Jam 3rd place! by [webdevbrian](https://webdevbrian.itch.io/)
-- [Orbitswarm](https://focaccai.itch.io/orbitswarm) - Fast paced space strategy game. by [Focaccai](https://www.focaccai.com/)
+- [Alien Escape Pinball](https://focaccai.itch.io/alien-pinball) - Pinball game with physics and aliens. by [Focaccai](https://www.focaccai.com/)
 - [LittleJS Jam 2024 Results](https://itch.io/jam/littlejs-jam-2024/results) - All the games from the first LittleJS Game Jam.
 - [LittleJS Jam 2025 Results](https://itch.io/jam/littlejs-game-jam-2025/results) - All the games from the second LittleJS Game Jam.
 
-![LittleJS Screenshot](examples/games.jpg)
+![A collage of screenshots from games made with LittleJS](examples/games.jpg)
+
+*A sample of games built with LittleJS.*
 
-![LittleJS Logo](examples/favicon.png)
+![LittleJS pixel-art favicon](examples/favicon.png)
 
 [npm]: https://img.shields.io/npm/v/littlejsengine
 [npm-url]: https://www.npmjs.com/package/littlejsengine
@@ -159,3 +178,5 @@ Here are a few of the many amazing games created with LittleJS...
 [deepscan-url]: https://deepscan.io/dashboard#view=project&tid=22950&pid=26229&bid=831487
 [discord]: https://img.shields.io/discord/939926111469568050
 [discord-url]: https://discord.gg/zb7hcGkyZe
+[license]: https://img.shields.io/github/license/KilledByAPixel/LittleJS
+[license-url]: https://github.com/KilledByAPixel/LittleJS/blob/main/LICENSE