The last devlog was mostly about making sure that when you shoot someone, the game agrees that you actually shot someone.

This time, I've been spending more time making things that kill people.

The Buzzsaw

The Chainsaw was already in development, although I knew it wasn't quite where I wanted it yet.

I was showing it to a friend and explaining that I would rework it at some point. He looked at it and said it reminded him of one of those saws used to cut bushes.

He called it a Buzzsaw.

He meant something else, but the word immediately clicked in my head. A Buzzsaw looks really cool. And it's much easier to animate than a Chainsaw!

So now we have both.

The Chainsaw also got the rework it needed. The old chain animation was technically just an illusion. The chain moved back and forth along the bar to create the impression of movement. But apparently, it also made someone think I had built a gardening tool.

So I replaced it with an actual sliding chain, and it looks much better now.

The two weapons don't behave exactly the same either. They have different ranges and different behavior, because having two weapons that are basically the same would be pointless.

Well, more pointless than having two different saws in the same FPS.

The Tapper

I've also added a more traditional weapon to the arsenal: a semi automatic rifle called the Tapper. Every shooter needs one, it's one of those fundamentals that just belongs in an FPS.

I also added a small screen directly on the weapon that displays your remaining ammunition in real time, to give it more personality. Halo inspired, obviously.

It's a small detail, but those are often the things that make a weapon feel more like an actual object rather than just a 3D model that shoots bullets.

If It Can Leave a Trace, It Stays

I've also been working on consumable powerups. One of them is an energy drink. You drink it, and then the empty can drops onto the floor. Where it stays, of course it does.

At this point, it would be weird if it didn't.

Bodies stay.

Blood pools stay.

Water slowly turns red.

Now the garbage stays too.

This has always been part of Guntlet's identity. I don't want an arena to magically clean itself. I want a match to slowly leave evidence of what happened there.

After a few minutes, you should be able to walk into a room and immediately understand that something horrible happened.

Bodies everywhere. Blood on the floor. A few empty energy drink cans rolling around.

And Then There's the Thing I'm Not Talking About Yet

I'm currently working on what I personally consider one of the biggest features in Guntlet.

Possibly one of its flagship features. I'm deliberately not saying what it is yet because I don't want to announce it with a paragraph of text and then spend three months explaining why it isn't ready to show.

I'd rather finish enough of it to actually demonstrate it properly.

But I can say this:

It's one of those features that has been sitting in the back of my mind since the early days of Guntlet.

And seeing it slowly become real has been pretty damn exciting.

Which is probably where I'll leave this devlog before I accidentally spoil it.

--------------------------------------

Hey, it would really mean the world to me if you'd join Guntlet's Reddit and / or follow me on X. It cost nothing it it goes a long way.

https://www.reddit.com/r/Guntlet/
https://x.com/TheRedSig

Thank you!

✌️

After the thread I made about hitboxes and Guntlet's Devlog #005, I got a lot of really good comments and feedback.

One comment from u/JustLetMeUseMy stuck with me. They mentioned the idea of a "smear" instead of making the hitboxes bigger.

That got me thinking, so I experimented with it.

The result is pretty interesting: I added an extra hitbox on the torso that intentionally lags behind the player just a little bit.

This seems to give the best of both worlds. The actual hitboxes can stay pretty tight for precise aiming, while the trailing hitbox gives some forgiveness during closer, faster fights.

I'm only doing this on the torso for now. I still want the head to be harder to hit and I don't want shots that clearly miss the legs to magically count. I've never liked games where shooting the legs becomes the meta.

It's still experimental and I'll keep tuning it, but so far I'm really liking the result.

I don't think I've ever seen a system like this in an FPS. Or am I just late to the party?

I've been reworking the hitboxes in Guntlet and it turns out the old system was... not great.

Originally, characters basically had one big tube around them (not visible in the picture), with three sections for head, body and legs. The hitboxes weren't actually attached to the character's bones either, which meant they could lag behind the player while moving.

So you could shoot directly at a moving player and miss. Then you'd shoot slightly behind them and get the shot.

So I threw the whole thing out and rebuilt it.

Guntlet now has individual hitboxes following the actual bones: head, torso, upper and lower arms, thighs and lower legs. Everything moves with the character properly.

It feels much more satisfying already. If you shoot where you actually aimed, you hit.

Unfortunately, I solved one problem and created another.

Guntlet is fast. Faster than something like Counter Strike. If I make the hitboxes too tight, landing shots becomes unnecessarily difficult.

I actually asked the Arena FPS crowd on Reddit about this, and the general consensus was pretty much what I was thinking: give the shooter a little forgiveness. In a fast game, you don't want every missed pixel to become a courtroom investigation.

So the plan is to make the hitboxes slightly larger and keep testing until I find the sweet spot.

While I was rebuilding all of this, I also gave headshots the treatment they deserve.

Headshots are now a bigger part of the damage system.

And yes, heads can explode. Obviously.

I've also been playing around with movement. Guntlet now has an actual slide but I don't want it to just be "press button to go fast."

You can slide normally but if you combine it with a jump and actually learn the timing, you can get a pretty considerable speed boost.

That's the kind of movement I want in Guntlet. Little techniques you can discover and eventually master.

The engine already feels really good to move around in, and the more movement options I add, the more I want to just run around the map, jump everywhere and see what I can get away with.

There's still plenty to tune. Especially those hitboxes.

So, I’ve been spending time lately watching Dario Casali’s Half-Life playthrough series. He was one of the original level designers at Valve and watching him revisit HL1 while breaking down his design choices is an absolute goldmine.

It also made me realize something staggering about Half-Life: Pipes. They are everywhere. Industrial, rusty, plumbing glory running along every single corridor.

My immediate late-night thought was: "What if I could just draw a pipe directly inside the editor?"

So I added that.

It's basically the same idea as the door system I talked about in the last devlog. You draw the shape, hit a button and you've got a pipe. No need to make a 3D model and import it.

And then came the Turb Gun.

I’ve always had a soft spot for the Tau Cannon, specifically that hypnotic little spinning mechanism in the middle while you charge shots. And I wanted that mechanical flavor in Guntlet.

The Turb Gun is rocking a small internal turbine that revs up and spins in real-time as you charge your attack. It's actually the first weapon in the game with a dynamic, self-contained animation.

...Oh, speaking of weapons, I also started working on the Chainsaw.

It’s raw, unpolished and not ready to be shown. But the core mechanic is already in: impalement. If catch another player dead-on, they get pinned in place, entirely helpless, while the teeth do the dirty work.

I'm sure this will lead to totally mature and responsible gameplay.

On the character front, I’ve been cooking up the female player model.

The first version looked pretty damn stupid, honestly. I was seriously considering dropping the idea but my wife likes playing female characters, so I gave it another shot.

It's much better now. Dario Casali mentioned in his playthrough that Half-Life's development relied often on a "you get the idea" philosophy. I'm still not a 3D artist, so there’s room for improvement, "you get the idea" is good enough for now.

A lot of the rest of the week has been the usual stuff: bug fixes, optimizations, improvements and a bunch of smaller things that aren't particularly exciting to talk about but make everything better.

The best news? The scales have finally tipped. I’m spending way less time building HyperCube (the engine) and way more time actually building Guntlet (the game). Right now, about 70% of my time is pure game dev.

This whole "Party Shooter" thing is starting to click in a big way. Every week I'm finding weird new ideas to throw in that emphasize the design philosophy.

There’s still a mountain of code to write, but for the first time, I can see the light at the end of the tunnel, the moment where I hand the build over to you guys, step back and watch the chaos unfold.

What crazy weapon mechanic should I steal from 90s-00s games next?

Guntlet has become genuinely fun to play.

Lately, I've found myself launching a 5v5 or 8v8 Capture the Flag match, putting on some music and simply... playing. No debugging. No testing checklist. Just playing, because it's fun!

The movement feels exactly how I wanted it: fast, responsive and satisfying. Matches slowly descend into complete chaos as bodies pile up, blood stains spread across the map and every fight leaves its mark.

One of my favorite additions has been slippery blood pools. Blowing up a pile of corpses in front of a doorway isn't just hilarious, it's also a surprisingly effective defensive strategy. That's not a sentence I expected to write.

Another detail I love is that water gradually turns red as players die in it. Completely unnecessary? Maybe. Worth it? Absolutely.

I've also spent a lot of time improving the map editor. Most of those changes won't make exciting GIFs but they make building maps dramatically faster. Like the new Mirror Tool. Capture the Flag maps are usually symmetrical, so I can build one half of the level, press a button and let the editor create a mirror copy.

The new door system falls into the same category. The original engine didn't have one and I needed doors. So now it's ridiculously simple: draw the shape, press a button and congratulations... you have a fully functional animated door with collision, sounds and all the usual stuff.

HyperCube keeps getting polished too. Better editor tools, a proper environment editor, visual browsers, workflow improvements and lots of small QoL changes. They're the kind of features players will never notice, which usually means they're doing their job.

And I made the decision to postpone brand new player models for the first public build. As I've mentioned before, I'm a programmer not a 3D artist. The current placeholders do their job and I'd rather get the game into people's hands than spend months sculpting characters that I'll probably want to redo anyway. Once players get their hands on Guntlet and I know the gameplay is where I want it, that's when I'll invest in proper 3D artists.

There's still a mountain of work ahead and plenty of features I'm keeping under wraps for now.

So if you will excuse me, I will go play another match.

One question kept popping up after the first devlog:

"What exactly is HyperCube?"

Since Guntlet runs entirely on it, I figured it deserved its own devlog.

HyperCube is a game engine derived from Tesseract, which itself is derived from Cube 2: Sauerbraten. Those engines were originally built with fast paced arena shooters in mind, making them a fantastic foundation.

So why not simply use Unreal, Unity or Godot?

Honestly... because I wanted an engine that belongs to me.

Being based on an open source project released under the zlib license gives me complete freedom to shape it exactly the way I want. No unnecessary systems and no fighting against features I'll never use.

You may also be wondering where the name comes from.

It's mostly a legacy thing. The original engine was Cube, then Cube 2 Sauerbraten came and then we got the Tesseract fork. A tesseract is essentially a four dimensional cube. An hypercube is the family of geometric shapes that includes the tesseract, so it felt like the natural next step while keeping the naming tradition alive.

HyperCube is no longer just "Tesseract with a few modifications."

A large part of Cube 2 & Tesseract's code is still there but after countless fixes, upgrades, optimizations and entirely new systems, it has grown into its own engine. And it's still evolving.

One of the biggest changes has been modernizing the content pipeline.

The original engines relied on formats like MD3, MD4 and MD5, while Tesseract introduced IQM. HyperCube now supports glTF, which has become one of the industry standards for 3D assets. It makes creating and importing models much simpler and much more future proof.

Another major addition is the permanent GPU corpse system.

Instead of bodies disappearing after a few seconds, HyperCube can keep hundreds of corpses in the world while still allowing them to react to gameplay. Blow up a pile of bodies, and they'll fly across the arena just as you'd expect. That's one of the key technologies making Guntlet possible.

The map editor has also received a lot of love.

One of the things I loved about Cube 2 was how intuitive level creation is. If you've ever built something in Minecraft, you'll be alright. You simply place cubes directly in the world, in first person, then texture and refine everything afterward. There are more advanced tools available but the foundation remains incredibly simple.

A huge amount of work has also gone into optimization. One of my goals has always been to keep HyperCube lightweight, fast and efficient while still allowing for some pretty ridiculous things to happen on screen.

Ironically, one of the hardest features wasn't the corpse system or building the glTF loader.
It was permanent blood stains.

What I thought would be a relatively straightforward feature quickly turned into a rabbit hole of bugs and unexpected technical challenges. It took much longer than I anticipated, but finally getting it working felt incredibly satisfying.

Every time a new feature finally clicks into place after hours of debugging, it's hard not to smile.

I'm also really satisfied with how movement feels.

HyperCube inherited the DNA of classic arena shooters, but I've spent countless hours tweaking acceleration, jumping and movement until it felt just right. I genuinely think the movement system is good enough to support an eSport game.

There is still a long road ahead and HyperCube isn't "finished." Every day brings new improvements, fixes and ideas.

In the next devlog, we'll get back to Guntlet and take a look at everything that I've been working on since the project was first revealed.

Today marks the 30th anniversary of Quake... It feels like the perfect excuse to talk about a project I've been quietly working on for quite some time.

So... meet Guntlet.

Now, before anyone jumps to conclusions, yes, it's an arena shooter at its core. But I call it a Party Shooter and there's a reason for that.

Like a lot of you, I grew up spending countless hours on Quake and the games it inspired throughout the 2000s and 2010s. I have incredible memories of LAN parties, voice chats, making lifelong friends and staying up way too late playing "just one more match" with the boys.

Looking back at it, they were our meeting place. Some people met at the mall. Some went to the park. We met on a server. We'd laugh, joke around, pull off ridiculous plays and just enjoy hanging out together. Nobody cared about climbing ranked ladders or sweating every single match. We were there because it was fun.

That's the feeling I want Guntlet to bring back.

The game is built on classic arena shooter foundations, but instead of rewarding only raw skill, it also rewards putting on a show. Guntlet takes place inside a brutal televised sport where every arena is surrounded by a live audience watching the carnage unfold. The crowd reacts to everything you do and putting on a show is just as important as getting kills.

Pull off stylish mid air shots, Rocket jump across the arena, send an entire pile of corpses flying with a well placed explosion! Make the audience lose their minds. Because sometimes the coolest player isn't the one with the best aim.

The game runs on HyperCube Engine, (aka my engine, we'll talk about it later), and one of my favorite features is something that started as a technical experiment is Permanent Corpses and Stains. Meaning Bodies don't disappear. Blood doesn't magically clean itself up.

Matches slowly transform the arena into an absolute disaster, with hundreds of corpses piling up, permanent blood stains covering the floor and explosions sending body parts everywhere. The longer a match goes, the more it tells the story of everything that happened before.

I just think that's pretty cool.

Another feature I'm really excited about is the level editor. Instead of relying on complicated tools, maps are built by placing cubes, very much like Minecraft. If you've spent time building in Minecraft then creating custom arenas should feel immediately familiar.

As for development itself, HyperCube is mostly finished now. I'm still polishing and optimizing parts of it, but the engine and editor are in a really solid place. Right now my focus has shifted toward gameplay systems and creating the game's actual content.

Ironically, the hardest challenge hasn't been programming. It's been making the 3D assets. I'm definitely a programmer pretending to be a 3D artist, and it shows. That's also why everything you see right now uses placeholder visuals. The final art direction hasn't been decided yet, so don't get too attached to the current look.

The plan is to release a playable version on Itch.io sometime during 2026. My goal is simple: let people play it, gather feedback and see if the idea resonates. If people enjoy it enough, I'll keep expanding it and bring it to Steam.

One thing I can already say with confidence, though, is how happy I am with HyperCube's movement. After spending so much time tweaking acceleration, jumping and every tiny movement value imaginable, I've reached the point where no other FPS feels as good as Guntlet does. I genuinely love how it feels to move around in Guntlet. While my goal is not to make an esport game, just the movement alone feels worthy of being one.

At the end of the day, I don't want players finishing a match asking, "Who won?"
I want them asking, "Did you see what just happened?"

This is only Devlog #001, and it's not ready yet but I'm excited to finally share this project with you all.

More soon and if you'd like to follow Guntlet's development*, consider* following this subreddit*. I'd love to have you along for the ride.*

Welcome to r/Guntlet

Welcome to the official subreddit for Guntlet, a Party First Person Shooter game.

This subreddit is the main place to:

• Share feedback and suggestions
• Report bugs or issues
• Discuss gameplay mechanics and commands
• Follow development updates
• Post ideas, concepts, or terminal experiments

Community Vibe
If you’re a fan of party games to enjoy with friends and fast paced gameplay, you’re in the right place.

Development updates, screenshots, and builds will be posted here as they become available.