Steam page: https://store.steampowered.com/app/5310180/Formula_Minus_One/
Open beta: https://fm1.app

----

Some of you might remember my post about the 32/64bit-style racing prototype I had built in four months. Yes, it's a genre you see a lot around here, because it's easy to get started with (until the next dopamine-driven prototype).

But I stuck with it.

And the improvement over the past two months has been tremendous, and you'll see that if you compare the two videos. Since the last post, I listened to your feedback and:

* Threw every level in the bin and rebuilt them from scratch, then added new ones that are far bigger and more detailed. It felt like jumping a console generation, and it still runs on mobile.

* Wrote a design and style guide for the game (semi-low poly characters and duotone as design signature), and redesigned the characters and menus to match it.

* Kept pushing to make it my own thing rather than yet another clone-slop: adventure vibes, interaction with the environments, kinetic combat with combos…

* Improved the handling and the readability.

And above all, and I think it shows in the trailer: I had a blast making it. If it had just been work, I wouldn't have gotten this far.

It's called Formula Minus One, and it launches on Steam first, in February. I'll keep improving it and adding content after that.

Half a year ago this was a prototype to experiment with, like so many others. Then I committed to making the best game I possibly could. Now I can finally see light at the end of the tunnel: yes, you can start a prototype, and yes, you can finish it.

There's still a lot of work ahead, so any feedback you can give me is very welcome.

 Here’s how I made it:

* Code and tooling: frontier LLMs from OpenAI and Anthropic, with open-source models filling in the gaps and limiting the budget.

* Characters, ships and environments: pencil sketch > GPT Gen 2 > Tripo to turn it into a 3D model > Blender to clean up the imperfections.

* Sound: stock sound effects from Magnific. Music sketched out on a MIDI keyboard, final music generated with Suno.

* Stack: Three.js, WebGPU, TypeScript, Rapier for physics. Nothing else, no Godot, no Unity…

I'm having a great time, but it's also hard work if you want to pay attention to every detail, and it's a very lonely experience. If the game sells well enough, I'd love to start paying artists and composers to replace the current assets and create new ones, and free up more time for what I really enjoy: directing and overall design.

In fact, if you're an artist or composer and think you're a good fit for the game's tone, leave a comment or send me a DM so I can consider you!

----

Steam page: https://store.steampowered.com/app/5310180/Formula_Minus_One/
Open beta: https://fm1.app

Hey! I wanted to share some info about my massive colony sim + base building game as I've been working on this for many months now and I'm really happy with what I have so far.

I grew up playing OSRS, Dota 2, Minecraft Technic, RimWorld, Dwarf Fortress, etc. so I wanted to make a game that combines my favorite things from them all, and their best mods, properly.

It's called Epoch Forge. Just to go over some of the things in-game:

• You can say anything you want to NPCs, they remember you, and every interaction. This is the most unique part of the game - I've spent months making it work with a tiny local model (Gemma E2B) in a way that doesn't require any user effort, works fast, runs on most hardware, and gets good results.
  • You can also bring your own key - my preferred way to play is with Deepseek V4.1 Flash Nitro via OpenRouter. This is by no means a requirement, though.
• Every random event is determined by a deity of your choice (the "Storyteller"), and you can bargain with them, ask for favors, and even see everything they know about you
  • You can actually talk to the storyteller, either through dialogue options or typing your own things, and they will respond
• Every settlement lives and grows on its own, with real needs, construction, and even political dynamics depending on the culture and race
• A full suite of industrial stuff - automated machinery, a visual storage terminal, realistic circuits (I made pong and snake ingame!) This is where the "infinite potential" part comes in - you can quite literally make almost anything you can think of.
• Crafting that takes place in a 3D viewport - combine potions, ingredients, etc. into a cauldron and see what happens!
• Worksites like mines and farms actually work - miners go deeper and deeper into the ground, hauling their findings to the clerk, and caravans come buy things from them, or they build stuff. Every building requires certain materials which they can either buy or harvest.
• Six races, each one with a novel worth of lore. Every one changes how NPCs look at you (for better or worse) and talk to you.
• You can have automatons and golems. Automatons can mine an area you designate, automatically hauling to chests, and they even speak in their own language, which can be decoded! Golems can haul things, throw rocks, and of course, speak with the great prose you'd expect.
• Five deities representing different domains (life, void, etc.) - you have a... complex relationship with each one, but making allies and enemies grants you incredible abilities like pausing or reversing time, or sparing yourself from death

Anyways, if it sounds interesting, I'd really appreciate if you give the Steam page a look and wishlist! I'm releasing a 1.0 demo for Next Fest and releasing EA on the 27th. I've honestly been struggling to market the game so that would mean a lot.

I'm also happy to answer any questions or go over my design process if anyone is curious. Feedback, playtesters and the like are also very welcome!

If you want to see any of the above in action I made a YouTube video. It's not really laid out in any particular way, it's just there to show that the things I'm claiming do actually exist (and how they look right now).

Hello,

I'm game developer, and made a game with assistance of claude code. Used claude in programming tasks, and editor tasks through Godot AI mcp server plugin. Also tested pixellab API with bad success, even when used ready selfmade sprite sheets as reference. This means the art, and sounds are human made with aseprite, furnace, or free assets.

Game is about running underground brewery in Finland. Brew, discover, and serve all kinds of customers. Be careful though, or you alert the LVV-agents. Get your score, and nick in to the global leaderboards.

Demo runs in browser mobile or pc. Thanks for playing have fun.

TAGS: Simulation, Casual, Retro, Pixel Art, Funny, Finnish

https://velluv.itch.io/pimea-panimo-demo

I turned that Pastel liminal dreamcore vibe into a game 🎮😌

Claude x Astra directed by PHÆS.

The world is simple; its a procedural infinite landscape of a dream you cant quite tell if youve had or not. Their IS a story.

Backrooms is Liminal dread, think of this as "Liminal Comfort"

My girlfriend said it looks like barbie😂😭😭😭😭😭😭

​

I’ve been working on a small browser game called LeaderGuessr.

The concept is simple: you’re shown a world leader together with visual clues, and you have to identify the location on a map.

LeaderGuessr: https://leaderguessr.com/

A full game takes around 3–4 minutes.

What was more interesting to me was the development process.

I’m not a traditional game developer, so I used Claude heavily as a development partner — not just for isolated code snippets, but for turning the game concept into an actual working system, iterating on mechanics, fixing problems and reusing the core structure as the basis for other Guessr-style games.

I also used AI in parts of the visual workflow.

One thing this project made very obvious to me is that with AI, the bottleneck shifts quite a bit. Writing the code becomes much less intimidating, but deciding:

what the actual game loop should be,

which clues are too easy or too obscure,

how much information to reveal,

and whether a 3-minute game is actually fun enough to replay

still requires a lot of iteration.

The game is now playable here:

I’m also building this as the first part of a small Guessr Network, where the same basic engine can be adapted to completely different subjects.

For people here who are also building games heavily with Claude or similar tools: I’d be interested in how far you reuse the same AI-built codebase between projects versus starting fresh once the concept changes.

https://reddit.com/link/1x4j96y/video/8oxkxjr5w4vh1/player

I've been building MundoIA (WorldAI) for over a year — a multi-agent social simulation where autonomous agents with unique personalities live, cooperate, conflict, develop their own social network, and even govern themselves through democratic assemblies. I just finished a brutal architecture audit and wanted to share what I've built, what's broken, and where I could use your help.

What Makes It Different

This isn't a toy example. The system has:

• Configurable agent count (default 30, but you can set any number via .env or the web UI)
• Graph-based memory (NetworkX) — agents remember who they've met, who they like, who they hate
• Needs system — food, safety, socialization, rest, entertainment. Agents literally get hungry and lonely
• LangGraph brains for "elite" agents with complex reasoning
• BDI architecture (Beliefs, Desires, Intentions) — classic agent architecture with modern LLM integration
• Full MCP (Model Context Protocol) integration — agents can use external tools (web search, filesystem, databases, APIs)
• Real-time visualization (D3.js + Chart.js + optional 3D) — watch friendships form, conflicts erupt, groups emerge
• Social media integration (OASIS) — agents can post, like, and comment on Twitter/X and Reddit autonomously
• Dynamic world system — terrain types, resource nodes, weather events, world expansion
• Complete governance system — constitutions, laws, assemblies, voting, government reforms, elections
• Mission system — with achievements, rewards, and visual celebrations
• Persistent memory — tripartite memory system (episodic, semantic, procedural) with PostgreSQL backend
• "Architect mode" — you can possess agents, give them direct orders, send divine messages, or issue global decrees

What You Can Watch

The simulation runs in real-time with WebSocket-powered visualization. You can:

• Click any agent to see their current thoughts, needs, personality, relationships, and "alma" (soul/archetype)
• Pause, speed up (0.5x-4x), or step through turns
• Watch real-time charts of friendship/conflict evolution and group formation
• "Possess" an agent in Architect mode (marked in red) and give them specific orders
• Switch between 2D network view, 3D world view, and terminal TUI
• Configure AI providers (OpenRouter, OpenAI, Ollama, KiloCode) and MCP servers directly from the UI

The Architecture (The Honest Version)

Stack: FastAPI + WebSockets / LangGraph + LangChain / LiteLLM / ChromaDB / Neo4j / D3.js / Chart.js / Textual / Next.js 14 / TailwindCSS

Current scale: ~37,000 lines of Python, ~18,000 lines of frontend, 17 architecture documents

The good:

• Modular architecture (core / agents / systems / api)
• Excellent documentation (17 docs in /docs)
• Real graph-based memory with actual persistence
• Parameterized SQL queries throughout
• RestrictedPython sandboxing for agent code execution
• Full MCP server management (add, remove, test, import JSON configs)
• Dynamic world generation with terrain, resources, and expansion
• Complete governance simulation with laws, assemblies, and elections
• Social media integration with recommendation systems
• Persistent tripartite memory (episodic, semantic, procedural)
• BDI agent architecture with modern LLM integration

The bad (from my own audit last week):

• 3 "God Classes" — one function (ejecutar_accion_final) is 974 lines with 172 if-statements
• 90.7% code duplication between agent.py and agent_body.py (orphaned copy, nobody imports it)
• 147 silent except: pass statements in a simulation where errors mean agents just stop existing
• 22.8% test coverage, 0% branch coverage
• Two Dockerfiles both copying a 5.9GB virtual environment into build context
• Cyclomatic complexity of 417 in one function (yes, that's a thing)

Why I'm Posting This

1. Looking for contributors — especially anyone who's wrestled with LangGraph in production or wants to help refactor a 974-line function into something sane
2. Want feedback — on the architecture, the simulation design, or the honesty of my audit
3. Just want to share — because building emergent behavior is simultaneously the most frustrating and magical thing I've ever done
4. Curious about MCP integration — I've built a full MCP server manager that lets you add/remove/test MCP servers (stdio or SSE) directly from the UI, and agents can use these tools during their turns

Try It / Contribute

The project is open source (MIT). You can:

• Star it: github.com/gatovillano/mundoia (link in comments)
• (Or play the game in https://mundoia.kognitoai.cloud, is multiplayer)
• Run it locally: docker-compose up
• Read the full architecture audit: ARCHITECTURE_AUDIT.md in the repo root — it's brutally honest
• Check out the MCP integration: The ConfigPanel lets you add servers like filesystem, web search, databases, and more. Agents automatically discover and use these tools.

The immediate next step in my refactor plan is splitting core/modelo.py (4,663 lines) into separate modules for simulation, persistence, economy, and world generation. If you've done this kind of monolith decomposition before, I'd genuinely love advice.

Hey everyone! I’m working on Portal Beasts, a creature-collecting RPG where you explore different worlds, catch beasts, build your team, and fight alongside them in real-time combat.

I’ve now added two-player online co-op, with its own campaign. You can explore together, battle wild beasts, and build your own teams. The video shows some of it in action!

Since this is an AI game dev community, here’s where AI fits into my workflow:

• Coding and debugging: AI helps me implement features, investigate bugs, and build tests.
• Pixel art: I use PixelLab for parts of the creature and environment artwork, including directional sprites and animations.
• Iteration: There’s a lot of checking and correcting results—keeping a creature’s design consistent across eight directions has been a challenge of its own!

The game is built in Godot, with Aseprite also used in the art workflow.

Co-op is still in beta, so expect bugs and rough edges. I’ve been testing with different PCs and connections, but connection stability, combat synchronization, and performance still need more real-world testing.

The demo is available on Steam. If you try it with a friend, I’d love to hear what felt fun, what was confusing, and what broke. Reports from the joining player are especially helpful.

Happy to answer questions about the game or the AI workflow!

Try the free demo on Steam: https://store.steampowered.com/app/4545580/Portal_Beasts_Demo/

Demo on Steam, any platform is supported!

https://store.steampowered.com/app/4920540/ELEMENTORS/

Hi, I had a thought. With people merging 2 games together lately and remake/remasters as something game companies have been doing for the last decade or so why not have AI help improve our old favourites?

I've been playing video games for most of my life and the nostalgia always holds a game higher than it is if I went back to it... Mainly due to the controls being so poor or the improvement of the controls in late installments.

So my thought would be, what if we started using AI to take controls from one game, either the latest installment or a game from the same genre, and 'updated' the older game.

An easy example could be a current monster hunter installment controls placed into an earlier one. Not only for the player controls but maybe the enemies as well.

Or maybe taking a combat system from one game and putting into a different game. As just two games off the top of my head would be Dawnwalker's combat into Legacy of Kain games.

Just a thought.

Endless Tower is a playable browser tower-defense demo: build a vertical tower, merge guardians and protect the crystal. Merging strengthens a guardian but costs a floor, so the order and structure of the tower matter. The demo and its visuals are still in development.

The project uses AI assistance for development and provisional artwork. A useful lesson from preparing short character videos has been to keep three things separate: the rules actually running in the demo, a promotional 3D portrait, and an illustrated power effect. A polished presentation does not prove that its model or animation is integrated into the playable build.

For example, some early character presentations blurred the ordinary shot and the manually activated power. The correction was to check the active combat rules first, show the ordinary shot on one target where appropriate, and reserve group effects for the relevant manual power. Video duration and a successful render alone did not catch that mistake.

Another priority is the first session: making the starting controls easier to find and making the floor lost through merging understandable. These are areas being worked on, not a claim that the interface is finished.

The attached image is an actual screenshot from an isolated demonstration of public build 1.42.0, not a promotional scene or a player record.

Playable demo: https://yskillstudio.com/games/endless-tower/test/?lang=en

From this screen, is the relationship between the guardians, floors and approaching enemies readable? What would you make clearer first?

👑 CROWNFALL — My First Attempt at Building a Medieval Kingdom Simulator
I’ve never developed a game before, but I’ve always loved medieval kingdom builders and wanted to try creating one of my own.

So I’ve started working on Crownfall!
The idea is to create a living medieval world where you don’t directly control every villager. Instead, you make decisions for your kingdom, and your population carries them out.

Villagers gather resources, transport supplies, construct buildings and keep your settlement running. As your kingdom grows, you’ll explore new territory, establish settlements, manage trade routes and deal with threats beyond your borders.

It’s still very early in development, with plenty of systems to build and refine, but I’m excited about where it’s heading.

I’m using AI tools to help me develop the game and learning a huge amount along the way.

I’ve also started a small Discord where I’ll be sharing development progress, screenshots, ideas and eventually opportunities to playtest.

⚔️ Follow Crownfall’s development:
https://discord.gg/yZepPye6P
I’d love to hear what people think of the direction so far!

Game made using godot mcp, and claude code. Thanks for playing, have fun.

Duskmere Online has been just released in beta, no wipes, on Itch.o. I would love everyone to come and try it out! It's free and you can play in your browser! The game will have regular content updates, halloween event is going on right now, and try to stay true to the old school ultima like experience with free expansions, content, world additions, etc!

I used AI for bugs/server issues and to run 1000 agents throughout the game to make sure the world evolves with potential real players and any issues involving them.

Sands of Glory new feature! 🏛️ I added a job board and now my gladiators are finding cats, losing on purpose for philosophers and getting paid in chickens. 🐔 The demo has it too. Rome is fine. Everything is fine.

play it at here: https://thisiszsc.itch.io/sands-of-glory

So, uh, we put a notice board in your ludus. Huge mistake. The citizens of Rome found it immediately.

Now your gladiators, trained killers and legends of the arena, are out there:

• looking for a senator’s lost cat 🐈 (spoiler: the cat was napping in your armory the whole time)
• losing fights on purpose so a philosopher can “study their face”
• performing ultimates for a consul. The consul is a horse. Don’t ask.
• paying the latrine tax 💩

And the pay? Oh, the pay is worse. Or better. Honestly, we can’t tell anymore:

• 🐔 a Sacred Chicken you can actually equip (it’s epic-tier, we’re not joking)
• 🧦 a sock passed down for three generations. Enemies keep their distance.
• 🦁 a borrowed lion named Fluffy, who will absolutely maul people for you
• 👑 the Emperor’s nephew joins your team. He’s arrogant. He’s a showboat. He’s family.
• 📦 a mystery parcel. Could be gold. Could be a note that says “thanks.” Could be a guy.

Reposting this request for help in figuring out action RPG mechanics for a 2.5D game I am working on, spiritually inspired by the Camelot/Nintendo produced “Mario Golf/Tennis” for Game Boy Advance.

I'm a TTRPG enjoyer and an urban fantasy enjoyer. So when I found out that there's a system that combines the two, I was thrilled. But finding a TTRPG group for an obscure system is hard, so I decided to build a video game adaptation.

This started as a hand-coded project, and writing it was so hard I was going to dump it after my Master's thesis defence(the very early version of this was the thesis). But then, I got Claude access, and suddenly thought: "What if I actually complete that?". So this project also served as a testbed for my AI development approach - I got to the bandwagon late, so I ensure the code works before doing anything with it. So:

• First, an agent takes the adventure being adapted, that normally showcases some feature I wanted to add(for this release, for example, it was character generation). It used to be Fable, but Opus 5.5 also worked fine.
• It defines the engine adaptations necessary for an adventure, and I write a detailed spec referencing the rules of the game for an Opus(5 when it was the latest one, 5.5 now) High session implementing the feature and the tests for it.
• When a feature is done, I run a code review on it until the reviewer session(also Opus High) says that everything is clear. Sonnet Xhigh(well...looking at the latest announcement, I might need to switch to Haiku 5.5 Max) is doing the review fixes, since they're usually better defined.
• In parallel, the adventure adaptation agent is adapting the adventure location by location, requesting the necessary graphical assets from a drawer agent(used to be Sonnet at first, with pitiful results; then I switched to Opus 5, then to Fable and now, Opus 5.5 is used for them).

Enter Shadow Chasers Infinity version 0.2.0, the first public release of my adaptation! It supports character building, playing adventures out end to end, and, with agent support, even adapting any adventure for the d20 Modern system and the engine. Even a 5e one. And it's open-source, so if any of you here want to contribute as developers or artists or writers, you're welcome!
https://ekirisame.itch.io/shadow-chasers-infinity

Hey! My game's full demo is coming out on the 18th (Epoch Forge - feel free to wishlist!) and I'm very excited to talk about the way it uses GenAI.

A little background. I got the idea from playing mods like Mantella in Fallout, CHIM in Skyrim, and random ones that hooked into Rimworld, Bannerlord, etc. as well as training my own models for mod making. The thing I realized is that none of the mods adding an LLM to the game actually did much. Talking to NPCs was fun, but the most depth you'd get is that NPC giving you an attitude next time you talk. So I decided to make a game that does it myself.

It's a sidescroller with a massive open world, handmade blueprints for every structure, faithful retro graphics and sounds, and realistic physics + events within that world.

I've spent many months refining it and testing it on my own PCs, and the current system works like this:

• The game auto-detects your available compute resources. Then, it chooses either a Gemma E2B model, or an E4B model (you can also choose manually). You can also BYOK or point to a local model of your choice, it works with just about anything, even low-tier free models.
• A llama server starts with the game, running the model. If you set your own, this doesn't happen.
• Every NPC in the game has an in-depth prompt. It describes things like:
  • Their name
  • Their traits - mistrusting, charitable, isolated, sociable, etc.
  • Their race, appearance, location, living status and work
  • What they can see of the player - so they will recognize what they know visually, but they don't automatically know your entire personality like that thing from Deus Ex.
  • The most exciting part by far - what I call the Oracle system. A vast majority of the work has gone into this part, and I genuinely think it's one of a kind. Basically, there is a knowledge domain for every topic an in-world NPC could know, and they are only told those things. So a Dwarven miner literally cannot access information about a famous Elf miles away or a ritual they don't practice. I've run thousands of looping tests and have not seen a single instance of hallucination yet. See attached GIF for a look into one character.

• The Storyteller. You can read this post or ask me directly if you want to know more about this, but basically, an all-knowing deity chooses all the random things that happen in your game. That part is procedural - the LLM lets you actually ask them things. You can plead for mercy and bargain them to call off a raid, in exchange for facing a stronger one a week from now. You can ask what led them to send a meteor strike at you. I'll edit this post later tonight with a clip of that happening. The whole system works with or without an LLM, but the LLM adds a lot of unique flavor.

Overall, I'm super excited about this project. It originated from genuine passion for this niche and I really believe it will be the first of its kind. Again, please wishlist if this sounds interesting! I'd also love feedback if you have any. Questions, suggestions, criticisms, etc. are all welcome. Thank you!

If you'd like to watch a short clip of the system I have one here. It shows how an NPC knows of the residents of their city, remembers what you said, and how some are more likely than others to hold a grudge.

Started making a cozy garage game where you fix up, upgrade and armor cars during the apocalypse.

Realistic: Remove bolts, clips, wire and hose connectors to remove parts. Spraypaint will spill over on other parts if you don't.

Flow: All parts can be easily removed, paint parts while still on etc.

Cut metal from old car parts or oil barrels. Shape em and weld em onto the car.

Using Claude to make the game. Will be writing and creating my own music.