MyNeedEcho
Home β€Ί Planning on making a browser based autobattler with Node.js and SSEs. How would...
Updated 2026-11-11

Planning on making a browser based autobattler with Node.js and SSEs. How would...

The opportunity: A Node.js library that turns one game event into many isolated 1v1 simulations running on separate workers, streams each skirmish over a single SSE channel, and accepts periodic ability inputs via HTTP without blocking the simulation. The evidence shows a developer asking exactly how to avoid running the entire simulation at once and how to let other players view different skirmishes.

New to web development. I want there to be 16 players with their own boards. When they match up against each other, I'm...

πŸ”₯ Heat 73.0 1 evidence posts 3 pain points 2026-11-11
Mention 1.5 Β· 1 sources

Product brief: how to build it

Who it is for

Solo developers and indie hackers building browser-based autobattlers or similar multiplayer games with Node.js and SSE, who are new to web development and need a clear pattern for splitting simulation work across processes while keeping one event channel.

What it does

Start here: the MVP

A Node.js package that exposes three functions: createMatch(eventId), spawnSkirmish(matchId, playerA, playerB), and streamSkirmishes(matchId). The first spawns a worker per 1v1, the second returns an SSE endpoint that multiplexes all skirmishes for that match, and the third provides an HTTP route for ability casts that forwards to the right worker. Ship with a runnable example of 16 players and one shared event channel.

How it beats what already exists

No existing project in the evidence addresses this exact gap. The Reddit thread shows the developer has to design worker isolation, SSE multiplexing, and input handling from scratch. General-purpose worker pools and SSE libraries exist, but they do not combine per-match simulation isolation with a single multiplexed event channel and an ability-input bridge. This library fills that gap by packaging the three concerns together for autobattler-style games.

Technical path

Platform: Node.js with Server-Sent Events (SSE) and worker processes. Hardest problem: keeping multiple isolated 1v1 simulations in sync while multiplexing them into one SSE stream and applying periodic HTTP ability inputs to the correct worker without blocking. Reusable open-source pieces: Node.js built-in worker_threads or child_process for isolation, and any standard SSE library for streaming; the evidence does not name specific packages beyond Node.js and SSE.

How it makes money

One-time purchase for the library source with example project, or subscription for updates and support. No prices or revenue estimates are given.

Biggest risk

The main risk is that the pattern is simple enough that experienced developers build it themselves, limiting adoption. Another risk is that SSE multiplexing and worker isolation behave differently under load, and the library must stay small enough to audit. The evidence does not show competing projects, so the market is unproven beyond this single thread.

Evidence (1 posts)

Pain points (3)

β€œI'm wondering would I have to make the entire simulation play out at once?”
β†’ A framework or library that lets a single game event fan out into multiple isolated 1v1 simulations running on separate workers while streaming to one shared event channel.
β€œOr is there a way to split the simulation up so that 1v1s happen on a dedicated process while still belonging to the same event (So other players can view different skirmishes)?”
β†’ A tool that multiplexes multiple concurrent sub-simulations into one SSE stream so spectators can subscribe to different skirmishes.
β€œI plan to let users use abilities every so often (Maybe every 15 seconds) during the fight and I'd handle that with a post request.”
β†’ A ready-made pattern or library for handling periodic in-match player inputs (cooldowns, ability casts) that sync cleanly with a running server-side simulation.

Sub-directions

Real-time multiplayer game state synchronization over SSE/WebSocketsPer-match simulation isolation across processes/workersIn-match player ability input handling via HTTP requests

Related needs

FAQ β€” Planning on making a browser based autobattler with Node.js and SSEs. How would...

Who already builds this?

No project in the evidence builds this exact combination. The Reddit thread shows the developer planning to build it manually with Node.js and SSE. General worker pools and SSE libraries exist but do not address per-match simulation isolation with a shared event channel and ability inputs.

What is the smallest shippable version?

A Node.js package with three functions: spawn a worker per 1v1 skirmish, expose one SSE endpoint that multiplexes all skirmishes for a match, and provide an HTTP route that forwards ability casts to the correct worker. Include a runnable 16-player example.

What is the hardest part?

Keeping multiple isolated simulations in sync while streaming them over one SSE channel and applying periodic HTTP ability inputs to the right worker without blocking the simulation. The evidence shows the developer is unsure whether the entire simulation must play out at once.

Why is it still unsolved?

The need appears in a single Reddit thread from a developer new to web development. The problem is specific to autobattler-style games with many concurrent 1v1s, so general-purpose tools overlook it. No existing project in the evidence targets this combination.

How is this data collected and verified?

Every quote on this page was matched against its original post on Hacker News, GitHub, DEV.to or Product Hunt, and each claim links to that thread. Unverifiable items are discarded before publication.

See all 20 evidence-backed needs this week β€” updated daily, every trend traced to original posts and exact quotes.

Subscribe $19.99/mo β†’

Not sure what to build first? See the ten worth a look →