This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built:

FRAGLINE is a fast, neon 2D arena shooter that runs in a browser tab, with bots and LAN multiplayer built in. It's a modern tribute to the Newgrounds classic Unreal Flash, built from scratch in Godot 4.7.

The "touch grass" part is the multiplayer. There are no accounts, no matchmaking servers and no lobbies on someone else's cloud. One person runs a tiny local server and shares a 6-character room code. Everyone else on the same Wi-Fi opens the address in their browser and joins. Up to 8 players fight in the same room, with the host's bots filling any empty slots.

It's for friends, classmates and teammates who want a quick game in the same room, on whatever devices people already have. The whole game is about 4 MB of data, so nobody has to download or install anything.

• 9 weapons with alt-fire modes (Shock Rifle combos, rocket jumps, sticky grenades, wall-piercing sniper shots)
• 6 mirrored PvP arenas with hazards, plus a Training Room
• Bots at 5 skill levels that navigate ladders, jump pads and drop-through floors
• 12 recolourable fighters, a CC0 synthwave and drum-and-bass soundtrack, and no sprite sheets (everything is drawn in code)

Demo:

Screenshots (from the repo):

Code:

Run it yourself:

./tools/build_web.sh        # export to build/web/
python3 tools/serve.py      # serves on http://localhost:8000 and on your LAN

• Quick Start : https://github.com/ipsamurai/fragline#quick-start

How I Built It:

Engine and rendering. Godot 4.7 with the no-threads web export, so it works on any static host without special headers. Characters, weapons, levels and effects are all drawn procedurally in code, which keeps the download tiny.

Levels are ASCII art. Each arena is a block of text in src/data/maps.gd. The game builds collision, decoration, item spawns and the bot navigation graph from it, and every map is mirrored for fairness.

Events at the core. The World node announces every game event: shots, hits, pickups, kills. Single-player handles them locally. In multiplayer the host sends the same events to every client, so both modes run the same rules code.

LAN multiplayer over WebRTC. tools/serve.py serves the game and swaps WebRTC connection details using the room code. After that, game traffic goes browser to browser and never touches the server. Your own movement runs locally so it never feels laggy, and other players are updated 30 times a second and smoothed. The host makes the final call on damage, pickups and scores, and checks each client's fire rate, ammo, weapon ownership and muzzle position.

Bots. They plan routes over a navigation graph (walking, jumping, double jumps, drop-throughs, ladders, jump pads). They pick what to do (heal, armour up, grab a weapon, hunt, roam) by scoring each option. In a fight they choose a weapon for the range, lead moving targets, arc grenades, aim rockets at your feet and set up shock combos.

Tests. Four headless suites cover combat rules, menus, bot navigation on every arena, and full bot matches.

Why Does Open Innovation Matter?

Every layer of FRAGLINE is open: the engine (Godot, MIT), the music (CC0, The Cynic Project), the sound effects (CC0, Kenney) and the font (OFL, Chakra Petch). That is what made a small, self-hostable, no-account game possible. There's no hosted API to depend on, no per-player cost and no service that can disappear, so the game works on a Wi-Fi network with no internet connection once it's served. A closed platform would have meant accounts, servers and fees between friends sitting in the same room.

My Agent Session:

I used github copilot to plan, and start the initial building of this shooting multiplayer game project. and then completed this project using Claude Code.

Prize Categories:

1. Gemma Open Wright Local LLM through llama.cpp
2. Github Copilot (for making this project possible)

Team:

• Saikat Das : me :P