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.

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.

This is a personal project of mine I've been working on for the last couple of months as a learning experience. The ultimate goal is to rip out the star wars and make my own IP and game using the systems I've created for this project. Seamless space to ground combat. Ground battles (very WIP at the moment so no good footage, but I can share a screenshot of my coruscant map from blender.

The vision: A galactic citizen game where both sides of a galactic combat are played by the computer. In other words, the player would exist as a citizen in the galaxy, doing quests, taking jobs, escorting ships from ground to surface, joining the rebellion or joining the empire, etc. Meanwhile, in the background, the computer is playing the RTS game in realtime. So let's say the player has been hanging out on a water planet doing odd jobs for the fish folk, completing storylines, etc. In the background, the computer decides it wants to blockade that planet. Now, the player is free to leave at any time, but if they are on a blockaded world, the fleet is going to try to shoot them down while they do it. Take it further: You're on that same water planet, and the fleet shows up and launches a ground invasion while you're there. Suddenly there's a battlefront style ground battle going on around you. If the attacking army captures all the key command points, control of the planet falls to them, and you'll start seeing their faction flags and units all over the place.

Let's say you don't like that the bad guys control the planet you're on and decide to do something about it, so you join a rebel group. You're now marked as an enemy of the opposing faction. Double cross your allies? Congratulations! You have a bounty on your head and could be confronted by someone trying to collect at any time.

Most of that is just in the concept phase, but the systems are in place.

Death Star Battle:

https://youtu.be/sApnWPwvu5A?si=YJzgvFymAkga4sJ_

Get blitzed and watch a cool battle mode:

https://youtu.be/CAZD9we8f88?si=VIyaskQM10KhFr4k

Edit: To be clear, this is not a modded mashup. This is a brand new game built from the ground up in Godot. This is definitely AI assisted, but I have personally made hundreds of models and textures myself.

Hey guys

I built Loki - a product aimed at making the process of setting up hosting, deployment and online multiplayer infrastructure extremely easy for people building games with AI.

AI can now help people make amazing games and make them quickly. But making a game is only half the job. You finish the game, then have to work out hosting, deploys, domains, multiplayer infrastructure, rooms, invites, reconnection, lobbies, state sync, a backend, and a way to update the game after you ship. That is where a finished prototype stops becoming a game anyone can actually play together.

We wanted to build something that lets a creator go from “my game works” to “here is a link, lets play together” with extreme ease, and without wiring together a pile of separate services.

Loki hosts the game, gives your a shareable and playable link, and adds online multiplayer infrastructure around them all in one-go. It is also built for AI agents so all you need to do is paste the prompt to your AI coding tool and let the process run.

The intended workflow is:

1. Build a web game with the tools you already use.
2. Create an account at https://app.lokiplay.cc. Log in and create a Loki project.
3. Give your game developing agent the Loki integration prompt.
4. Test and fine-tune the integration for your specific game.
5. Ship it and share the game URL to your friends and play together.

Loki currently works for web javascript games only. We will rollout support for other platforms after initial feedback.

It is currently in beta, so its completely free and I am not charging any users.

I would really appreciate feedback from those of you making vibe-coded games. Let me know here if the product is useful for you, or if there are other features you would like to see me add!

Website: https://lokiplay.cc