标签：#gamedev

This is a submission for the June Solstice Game Jam What I Built SOLSTICE — The Longest...

I just launched Kotobato on Google Play after about two and a half years of solo development. It's a word puzzle RPG — you swipe connected letters on a board to form words, and those words become attacks. Longer words deal more damage. Rarer words hit harder. I want to share what I built, why I built it this way, and what surprised me most during development. The core mechanic The board is a grid of letters. You swipe a path through connected letters to form a word. When you submit the word, it becomes an attack against the enemy. The twist: word length isn't the only thing that matters . The game has six elemental types — Animal, Nature, Knowledge, Food, Life, and Fantasy — and each word is categorized into one of these elements. Enemies have elemental weaknesses, so the right word beats a long word if you're hitting a weakness. This created an interesting design problem. In most word games, you're just maximizing point value. In Kotobato, you're making tactical choices: do I use a short word that hits a weakness, or a long word that deals raw damage? Why hiragana and English both work The game runs in both Japanese (hiragana) and English. This wasn't a late addition — it was part of the original design. Japanese hiragana is a syllabic script with 46 base characters. Because each character represents a whole syllable rather than a single phoneme, even short hiragana words feel phonetically "weighty." A 4-character hiragana word might correspond to an 8-letter English word in spoken syllables. This means the game feels different in each language — not just translated, but genuinely different. Japanese mode rewards knowledge of vocabulary that uses phonetically distinctive combinations. English mode rewards knowledge of unusual high-value words (think quixotic , ephemeral ). What I actually built 100-floor tower with escalating bosses, including historical Japanese figures like Oda Nobunaga and Toyotomi Hideyoshi Gacha character system — collectible characters with d

This is a submission for the June Solstice Game Jam What I Built Solstice Cipher: Enigma of the Longest Day is a browser-based puzzle game built around the Caesar cipher — the same substitution cipher technique used in ancient cryptography. On the theme of the June Solstice, I tied the longest day of the year to an Enigma Machine-inspired challenge: decode encrypted messages before time runs out, with the difficulty scaling as the sun climbs higher. The game features a real-time animated sky that shifts through dawn, noon, and dusk to reflect the solstice theme. Players are given a cipher shift key and must decode encrypted phrases by working through the Caesar cipher manually or by reasoning out the pattern — no brute-force tools allowed in-game. This connects to the June Solstice theme because the game is literally set on the longest day: the puzzles grow harder as the day progresses, and the sky animation mirrors real solstice light from sunrise to sunset. Video Demo Play it here: gtxpoffic-developer.github.io Code GTXPOFFIC-developer / Solstice-Chiper-Enigma-of-the-Longest-Day This is a Enigma based June Solstice game feel free to include your own code or tinker this project just mention the orignal developers name pls Solstice Cipher — Enigma of the Longest Day A browser-based Enigma machine puzzle game set on the June solstice. Decode (or encode) encrypted transmissions before the daylight runs out. Built By Sudipto — Original developer Feel free to fork, tinker, and include this in your own projects. Just mention the original developer's name. How to Play Objective Configure the Enigma machine correctly to decode each level's ciphertext (or encode the plaintext) before the sun sets. Each wrong guess costs 45 minutes of daylight; correct guesses pause the timer for 30 seconds. Controls Control What it does Rotor dropdowns Select which 3 rotors (I–V) are used ▲ / ▼ buttons Adjust each rotor's starting position Plugboard Drag from one letter to another to connec

What I Built I'm thrilled to present Chrono Shift: Time Weaver – a time-bending puzzle platformer that challenges players to manipulate time itself to overcome obstacles and solve environmental puzzles. The Concept Imagine being able to see two versions of the same level simultaneously – the past and the present. In Chrono Shift, you don't just play through a level once; you play through it twice, switching between timelines to create pathways that wouldn't exist in either timeline alone. A bridge that collapsed in the present might be intact in the past. A door that's locked now might be open in the past. By strategically shifting between eras, you create a path forward that exists only through your mastery of time. What Makes It Special Dual-Timeline Mechanics : Switch between past and present with the press of a button, watching as the world transforms around you 10 Unique Levels : Each level introduces new mechanics and challenges, gradually building your time-weaving skills Pixel Art Beauty : Vibrant, hand-crafted pixel art with parallax scrolling backgrounds that bring each era to life Collectible Time Crystals : Find hidden crystals in each level to unlock challenges and achievements Responsive Controls : Smooth platforming with jump, dash, and time-shift abilities that feel tight and satisfying Ambient Soundtrack : Era-reactive music that shifts with your timeline changes, immersing you deeper in the experience Mobile-Friendly : Touch controls mean you can weave time on any device The Journey This game was born from a simple question: what if platformers could teach us about perspective? By forcing players to see the same space from two different temporal viewpoints, Chrono Shift becomes more than just a game – it's a meditation on how our choices in the past shape our present, and how understanding both can unlock possibilities we never saw before. Play it here: https://lovable.dev/projects/bcaa0de3-f14c-4bad-9616-405c896d19bc Video Demo While there's no vi

If you have never written a line of game code and you are trying to choose between Unity, Godot, and Unreal, the internet will give you fifty contradictory answers in your first hour of searching. This article is the answer we give to people who ask us in person. We are a Unity-specialist studio. I have spent 12 years building games, including a tenure as Mobile Team on RuneScape Mobile at Jagex. Over that time I have mentored a steady stream of new developers entering the industry. We picked Unity for our commercial work, deliberately, and we will say upfront where that lens does and does not serve you. The advice below is what I would tell a friend's teenager who asked which engine to learn first, not the version where I am trying to win you as a client. Three things drive whether a beginner finishes their first game or quietly abandons it: the engine's first-week friction, the quality of the free learning material, and whether the language and tools punish you or reward you when you make a mistake. Comparison articles obsess over feature lists. Beginners obsess over whether they can get something on screen by Saturday. We are going to talk about Saturday. The 30-Second Answer If you skim nothing else, take this: Pick Godot if you want the gentlest first week. The editor is small, the language reads like Python, and you can ship a 2D game to the web in a single afternoon. Best chance of you actually finishing a project. Pick Unity if you want a future career in the games industry. Largest tutorial library, biggest job market, most transferable skills. C# is harder than GDScript but every hour you spend on it pays back in the long run. Pick Unreal if you have always wanted to make games specifically because of the visuals. Blueprints let you avoid C++ at the start, the rendering looks beautiful from day one, and the long learning curve has the highest payoff if you commit. For the rest of the article, we will explain why each of those is true, where the engines gen

Enlace a post en Español Click If you are developing games in Godot and using AI to help you code, you are probably tired of constantly switching tabs between your editor and the browser. Copying code, pasting it, explaining your scene context over and over again... it is a massive workflow killer. To solve this, I built Golem-AI (named after the Godot Engine logo because let's face it, it looks like a tiny, friendly mechanical golem). It is a "Cursor-style" AI assistant extension integrated directly into a dock right inside your Godot 4.2+ editor. Today, I am opening the repository to the community as a completely open-source project. It is currently in Beta and has some bugs, but it is fully functional, and I want to share it so we can improve it together. / ____/___ / /__ ____ ___ / | / _/ / / __/ __ \/ / _ \/ __ `__ \______/ /| | / / / /_/ / /_/ / / __/ / / / / /_____/ ___ |_/ / \____/\____/_/\___/_/ /_/ /_/ /_/ |_/___/ 🎮 How it Looks Inside the Editor Here is a glimpse of the integrated dock interface, its session history, and the context autocomplete system in action: 🔥 Key Features 🦙 Local & Cloud Providers: Connect it to Ollama or LM Studio for a 100% free, offline local workflow, or hook it up to OpenAI, Anthropic, Gemini, or Cursor proxies. 🧠 Cursor-Style UX & Context (@ Mentions): Type @ in the chat composer to automatically attach open scenes, specific project files, or custom skills directly into the prompt. 🛠️ Editor Tool Calling: It features an optional multi-step verification loop. The AI can actually interact with native Godot editor tools to help you iterate and fix things faster. 📚 Markdown Skills System: Feed the assistant specific workflows, style guides, or documentation using standard markdown files (/skill or @skill :id). 💬 Advanced Chat UI: Built-in "thinking blocks", agent step progress tracking, searchable history sessions, and a native bilingual UI (English / Spanish). 🛠️ The Current State: "It works, but..." (Looking for Beta Testers!) L

As a developer who frequently switches between competitive FPS titles like CS2 and Valorant, re-tuning mouse sensitivity is always a hassle. I wanted a fast, ad-free tool to translate my aim perfectly across titles, so I built a clean Game Sens Converter . The Approach I built this using 100% Vanilla JS. It’s a simple utility, so there was absolutely no need for a backend or heavy frameworks. It loads instantly and calculates right in the browser. Here is a quick look at the core logic handling the sensitivity conversion multipliers: function convertSensitivity ( gameFrom , gameTo , currentSens ) { // Standardized multipliers relative to CS2 / Source engine const multipliers = { ' cs2 ' : 1 , ' valorant ' : 3.181818 , ' overwatch ' : 0.3 , ' apex ' : 1 }; if ( ! multipliers [ gameFrom ] || ! multipliers [ gameTo ]) return null ; // Convert to base (CS2), then to the target game const baseSens = currentSens * multipliers [ gameFrom ]; const convertedSens = baseSens / multipliers [ gameTo ]; return convertedSens . toFixed ( 3 ); } Try it out You can use the live tool for free here: Game Sens Converter Let me know what your main game is or if you'd add any other FPS titles to the list in the comments!

I didn’t expect to care this much about language tools. I started messing around with two different projects, Linguaboard and Parley , mostly out of curiosity. What I got was a surprisingly clear look at two very different ways we interact with language as developers and builders. Linguaboard: translation as exploration, not just output Linguaboard isn’t trying to give you the translation. Instead, it feels more like it’s saying: “Here are several valid ways this could be expressed, pick what fits your intent.” That shift is subtle but important. Most translation tools optimize for a single “correct” answer. Linguaboard leans into ambiguity in a way that actually helps you understand nuance instead of hiding it. I found myself thinking less like: “What does this mean?” and more like: “How should this sound in context?” Parley: learning through interaction, not memorization Parley takes a completely different angle. Instead of treating language as something to decode, it treats it as something to use. You’re not just passively consuming translations, you’re engaging with patterns, context, and recall in a more active loop. What stood out to me is how quickly it shifts you out of “study mode” and into “usage mode.” It feels closer to building intuition than studying rules. The interesting contrast What I didn’t expect is how well these two complement each other: Linguaboard → helps you understand nuance and meaning Parley → helps you internalize and use language One is about interpretation, the other about retention through interaction. Put together, they highlight something a lot of dev tools miss: Language work isn’t one problem. It’s at least two: understanding, and using. Why this matters (especially for devs) If you’re building anything with multilingual UX, AI translation, or global audiences, you’ve probably hit this wall: Translation APIs give you “correct” text But correctness ≠ clarity, tone, or intent These tools made that gap feel very obvious to me. And o

When we started experimenting with AI translations, we assumed the biggest challenge would be accuracy. We were wrong. The harder problem was preference. Give two AI models the same sentence, and both translations can be technically correct. Yet people almost always have a favorite. One sounds more natural. One feels more human. One is the version they'd actually use. That observation eventually led us to build Parley , a simple game where players compare two translations and choose the better one. What happened next surprised us. People became highly engaged with a task that looked almost trivial. They started debating word choices, discussing tone, and noticing subtle differences between translations. Some users spent far longer interacting with translation examples than they ever would reading documentation or language-learning materials. It highlighted something interesting about AI products: evaluation can be more engaging than generation. Most AI interfaces focus on creating content. But humans are often much better at judging quality than producing it from scratch. Asking someone to choose between two outputs requires less effort while still training their intuition. The experiment also changed how I think about language learning. Traditional language apps often rely on memorization and repetition. But comparing alternatives forces you to think about meaning, context, and natural expression. You're not just learning vocabulary, you're developing taste. And in a world where AI can generate endless content, taste might become one of the most valuable skills we can build. Have you seen similar patterns in AI products where evaluation turns out to be more engaging than creation?

Hey. No new feature this time - just a pass through the corners before the next one. We had a list of nine bugs we'd written down and kept walking past. Most were small. One wasn't, and it was hiding behind a button. When you import a file the studio already has - same bytes - we ask whether to share the existing file or make an independent copy you can edit on its own. Pick "independent copy" and you expect exactly that: your own file, safe to change or delete without touching anything else. It mostly worked. But the new copy's internal name was built from how many copies already existed - copy 2, copy 3, and so on. The problem shows up after a delete. Say you had three, removed the middle one, then made another. The new one counted "two exist, so I'm number three" - but number three was already taken. The studio saw the clash, quietly kept the old file, and pointed your new scene at it. You thought you'd made a clean copy; you were sharing the original, and the real copy you just made was orphaned on disk with nothing pointing at it. Edit "your" copy later and you'd be editing the original too. Nothing crashed. Nothing warned you. That's the worst kind. The fix: stop counting, and instead look at which names are actually taken and pick the first free one - so a copy made after a delete always gets its own identity. We also made the studio shout in the logs if two files ever collide again, instead of silently dropping one. Better a loud bug than a quiet one. The rest were smaller. A menu element could jump for a single frame when you grabbed it (the drag started from where the element was saved , not where it was shown ). A countdown number sat blank for one frame before popping in. And the end screen had a leftover timing delay we fixed - which you'll never see, because that screen is solid black either way. Real bug, just invisible. The one we'd marked most important? We went to fix it and found a rebuild from two weeks ago had already solved it. We checked three

As part of my game development journey, I recently created Hidden Collector , a Unity-based game where players explore levels and collect hidden items while progressing through different challenges. This project started as a way for me to improve my Unity and C# skills, but it quickly became an opportunity to learn about game design, UI systems, audio management, scene transitions, and player experience. What I Worked On While building Hidden Collector, I implemented: Player movement and interactions Collectible item systems Multiple game levels UI menus and game screens Audio and sound effects Progress tracking Game flow and scene management Challenges During Development One of the biggest challenges was making different game systems work together smoothly. Something as simple as collecting an item often required updates to UI elements, game state management, and progression systems. Debugging these interactions taught me a lot about organizing Unity projects and writing maintainable code. What I Learned This project helped me gain experience with: Unity Engine C# scripting Game architecture UI implementation Audio management Debugging and testing Most importantly, I learned that building complete projects teaches far more than following tutorials. Play the Game You can try Hidden Collector here: https://sinxcos07.itch.io/hiddencollector Screenshots What's Next? I'm continuing to improve my game development skills by building new projects, experimenting with different mechanics, and learning more about creating engaging player experiences. If you try the game, I'd love to hear your feedback. By Suryansh Sinha (sinxcos07) Connect With Me GitHub: https://github.com/sinxcos07 LinkedIn: https://www.linkedin.com/in/suryansh-sinha/ Play Hidden Collector: https://sinxcos07.itch.io/hiddencollector

Hi! I want to share a project that I work for a while. It started from idea to get rid off manual copying data from game design documents to game engine. Here you can define your game objects, their props, relations and everything will be stored in structural JSON format that can be read by Unity, Godot, Unreal and other engines. What we have now? construct **wiki-like documents **using a block editor and template system (markdown is supported too) design dialogues of your game in special graph editor create maps and prototype levels on canvas store and manage database of game objects use created objects inside engine directly or export data to customizable data formats (arbitrary JSON, CSV) Made it free and open source. Please try (have Windows and Mac builds) and give your feedback Source code: https://github.com/ImStocker/ims-creators Itch.io: https://nordth.itch.io/imsc-desktop

Bugs, crashes, glitches... Game development is full of them, and even experienced teams run into issues. But while no game is perfect, that doesn't mean we should stop chasing better quality. In this live session, we'll look at why even seasoned game development teams make mistakes and how you can reduce the number of issues in your own projects. What's the talk about? The speaker, Gleb Aslamov, developer advocate and static analyzer developer at PVS-Studio, will walk you through common and less obvious reasons behind code errors, share real-world bug examples from actual game projects, discuss development practices that help prevent bugs before release, and demonstrate tools designed to catch those issues early. Gleb will show some amusing bug examples from projects like osu!, GZDoom, and SanAndreas Unity. The discussion will cover how code reviews, testing, and CI/CD, combined with profilers, dynamic analyzers, and static analyzers, can help detect issues long before players ever encounter them. Also, expect to see static analysis in action, including warnings that reveal performance-sensitive issues and other hidden problems in game code. When? Mark your calendar for June 2, 2026, at 1:00 PM UTC+1 . Join the live talk and learn how to make your game code more reliable—one bug at a time. P.S. And don't forget to check your inbox to confirm the registration!