Trapline

main menu

TLDR:-My teammate and I have always had the same problem with small online games: we would find something fun, play it for a night, send it to each other, and then completely forget about it the next day because nothing had changed and there was no real reason to return. When we started this hackathon, that old problem came back to us, and we kept asking one question: what if the game remembered that we were there? That question eventually became Trapline, a daily physics gauntlet where players swing between anchors, build momentum, dodge hazards, and try to survive a course that the community itself helps shape. After playing, you can leave behind one trap that may become part of a future course, carrying your name, collecting kills, and becoming part of someone else's run. We built it together using Devvit Web and Phaser, and the process was much messier than we expected. The physics looked simple on paper, but at one point even we couldn't finish the course we had created. We spent hours playing together, failing at our own game, adjusting momentum and level difficulty, fixing controls, fighting mobile UI overlaps, and realizing that a level being technically possible does not mean a human being will enjoy playing it. That became one of the biggest things we learned while building Trapline: working code is not the same as a working game. What we are most proud of is the loop that came out of all that testing. You survive what yesterday's players helped create, leave something behind for the next players, and return to discover what happened because you were there. Next, we want to expand that idea with more traps, smarter evolving courses, deeper community rivalries, and more ways to see the impact your contribution had while you were gone. We started by trying to solve the simple problem of why we never returned to the little games we played together, and ended up building a game where leaving is actually part of the reason to come back.

Inspiration

Okay, the completely real answer is that Trapline started from a very simple question: why do most small games on the internet give you absolutely no reason to care once you've played them?

You finish a level. Maybe you get a score. Maybe you appear on a leaderboard. Then you leave.

When we saw the Games with a Hook challenge, the interesting part wasn't just building something addictive. It was this idea that Reddit games can live inside communities. The people playing today are the same people coming back tomorrow.

So we started thinking: what if playing the game wasn't the end of your interaction with it?

What if surviving today's level gave you the ability to change tomorrow's?

That's where Trapline came from.

Every day, the community faces one shared physics gauntlet. You swing between anchors, build momentum, release at the right moment, avoid traps, and try to reach the end.

But once your run is over, you become part of the level design.

You place a trap.

Tomorrow, that contribution becomes part of the course everyone else has to survive.

And suddenly the game remembers you.

Your username is attached to your trap. You can see how many players it killed. Players can react when your trap takes them out. The deadliest creation can become Trap of the Day.

The interesting part is that nobody designs the entire level.

Thousands of small decisions accumulate into one evolving course.

That became the core idea behind Trapline:

Survive today. Shape tomorrow. Come back to face what everyone created.

What it does

Trapline is a daily community-built physics game running directly inside a Reddit Interactive Post.

The core movement is deliberately simple:

Hold to tether.

Swing to build momentum.

Release to fly.

Catch the next anchor.

Survive.

The challenge comes from chaining those actions together while navigating platforms, collapsing structures, bumpers, Pendulum Hammers, gaps, and traps contributed by other players.

But completing the course is only half of the game.

After your run, you enter Contribution Mode and place a trap that can influence a future course.

That creates the full Trapline cycle:

SURVIVE → SHAPE → RETURN

Community traps carry their creator's identity into the game. When someone dies to your trap, your kill count grows. Players can react to the trap that killed them, and the day's deadliest trap earns the Trap of the Day crown.

The course therefore becomes more than procedural content.

It becomes a record of the community that played before you.

For first-time players, Trapline includes a guided onboarding experience that teaches the movement through actual interaction instead of dropping players into a wall of instructions. The game progressively introduces tethering, swinging, releasing, chaining anchors, hazards, and the larger daily community loop.

Returning players skip directly into the current challenge.

The result is a game where today's session creates a reason to return tomorrow, because tomorrow contains consequences from what happened today.

How we built it

Trapline is built on Devvit Web and runs as an interactive experience directly inside Reddit.

Phaser powers the core game experience: physics-based swinging, tether interactions, collision systems, hazards, responsive input, camera behavior, visual effects, and the course itself.

The movement system is built around momentum.

The player attaches to valid anchors, moves under a constrained swinging system, and preserves velocity when released. That makes movement easy to understand but difficult to fully master.

The game supports touch controls for mobile and desktop input, with the interaction model designed around the same fundamental action rather than creating completely different games for different devices.

On the backend, the server remains authoritative for persistent gameplay state and community statistics.

Trap contributions, deaths, kill counts, reactions, daily state, and player progression are not treated as disposable client-side values.

One of the more important systems is course validation.

A generated course cannot simply look playable. Trapline validates structural reachability before accepting layouts, while the actual opening course is designed separately around the real production physics so first-time players are not expected to perform near-perfect swings just to understand the game.

We also built the experience around a complete daily lifecycle rather than an isolated gameplay session:

play the current course,

record what happened,

contribute to what comes next,

return to a changed world.

That loop is the actual architecture of the game.

Challenges we ran into

The hardest problem wasn't building swinging physics.

It was making swinging physics feel fair.

A level can be technically solvable and still be miserable to play.

Early versions of Trapline had exactly that problem. The course passed structural validation, but the first real sequence demanded far more momentum and precision than the tutorial had prepared players for.

At one point, even after repeatedly testing the game ourselves, reaching the early sections consistently was too difficult.

That forced us to separate two completely different questions:

Can this level theoretically be completed?

and

Can an actual human reasonably complete it?

We audited velocity through tether attachment, swinging, release, and reattachment, then redesigned the early course around generous release windows, visible next targets, recovery opportunities, and gradual difficulty progression.

The second major challenge was onboarding.

Trapline's controls are simple once you understand them, but watching a circle swing from a line does not automatically tell a first-time player what they control, what can be grabbed, when they should release, or why they should return tomorrow.

So the tutorial became part of the game itself.

Instead of a static instruction page, the experience teaches one action at a time and lets the player perform it before introducing the next.

The third challenge was making a community-built course remain readable.

A trap is not just an obstacle. It has an author, a history, a kill count, reactions, and potentially a crown. All of that information has to exist without turning a fast physics game into a dashboard.

That required treating social information as part of the world rather than piling conventional UI panels on top of it.

Accomplishments that we're proud of

The part we're most proud of is that player contribution isn't a separate feature attached to the game.

It is the reason the game continues to exist.

You don't open a complicated level editor and spend twenty minutes designing something.

You make one small decision.

Place one trap.

Then leave.

That decision waits for tomorrow.

Someone else encounters it.

Maybe they survive it.

Maybe your trap destroys their run.

Maybe they react to it.

Maybe it becomes the deadliest trap of the day.

That creates a social interaction between players who may never be online at the same time.

We're also proud of how much of the game's identity comes directly from Phaser rather than treating it as a rendering layer. The swinging, momentum, dynamic hazards, responsive visual feedback, particles, environmental interactions, camera behavior, and moment-to-moment feel are fundamental to the experience.

And we're proud of the daily loop because it gives every system a reason to exist.

The physics makes surviving satisfying.

Surviving unlocks contribution.

Contribution changes the future course.

The changed course creates curiosity.

Curiosity brings players back.

What we learned

The biggest thing we learned is that retention isn't something you add with a streak counter.

A player needs an unfinished relationship with the game.

Trapline's strongest reason to return isn't:

"Your daily reward is ready."

It's:

"What happened to the thing I left behind?"

Did my trap make it into the course?

Did anyone die to it?

Did someone react to it?

What did everyone else add?

What does today's course look like now?

That kind of anticipation is much stronger than simply resetting a challenge every 24 hours.

We also learned that community-generated content doesn't need to mean giving every player a giant creation tool.

Constraints can make contribution more meaningful.

One player placing one trap sounds small.

But when every player gets one meaningful decision, the combined result can become something none of them individually designed.

And finally, we learned that polish in a physics game is mostly communication.

The player needs to instantly understand:

what they can grab,

what they're currently targeting,

where momentum is taking them,

what will kill them,

and where they need to go next.

When those signals are unclear, difficult gameplay feels broken.

When they're clear, the same difficulty becomes something players want to master.

What's next for Trapline

The next step is making the evolving course feel even more like a living history of its community.

We want longer-term trap creator progression, where players develop recognizable styles and reputations based on the traps they contribute.

We want richer daily and weekly course evolution, with exceptional community-created traps surviving longer and influencing future layouts.

We also want deeper asynchronous social competition: rivalries between trap creators and runners, community milestones, historical course replays, and ways to revisit legendary traps that became infamous inside a community.

Longer term, the idea is for every Trapline community to develop its own personality.

One community might build brutal momentum-heavy courses.

Another might create chaotic bumper playgrounds.

Another might become obsessed with Pendulum Hammers.

The game provides the physics and the constraints.

The community creates the culture.

Because ultimately, Trapline isn't supposed to be a level that resets every day.

It's supposed to be a level that remembers who played it.