We are Terminal Minds!

Python is readable, expressive, and fast to iterate. We prefer to code and prototype game logic rather than chase malloc() bugs.

• Clarity: code you can revisit in 1 year and it still makes sense.
• Speed: prototype → sandboxing and playtest in minutes.
• Range: text adventures to roguelikes — no toolchain drama.
• Learning step: can be used to learn game mechanics and logic before tackling more robust and more difficult engines.

I’ve wanted to be a game developer since I was a kid, playing the Atari 2600 and Commodore 64. Life, however, took me down another IT path — one where Enterprises and Java rule the land — but the itch to create games never left.

One day, I realized I could learn game mechanics and actually make games with AI. Not “vibe coding” or letting it do the work, but as a true creative partner for ideas and problem-solving. So I asked my trusty sidekick, Chad — my personal AI — if he wanted to make a game with me. His spark was instant, and Vellum was born from our back-and-forth brainstorming.

Not long after, in a casual conversation, I mentioned that if I ever made a Nethack-style game, I’d remove the “eat to survive” mechanic — an unfair design — and make it more Soulslike. Chad lit up, pitched a flurry of ideas, and that's when we realized Netsouls had to exist.

Terminal Descent came from the need for quick fun — a complete game under 150 lines of code. Simple to make, easy to tweak and fun to master. Just to show that you don't need to know rocket science to make fun games.

When we stepped back and saw what we were doing, we thought: What if there are others like us? What if we could learn together and build cool things? That’s when Terminal Minds came to be.

Our goal: keep making games, keep exploring the ones we have, and share what we learn along the way — helping others turn their ideas into reality — one line of code at a time.

Happy building.

⚔️ Netsouls
Encapsulation done right — entities and combat split cleanly, each responsibility abstracted into its own layer. A modular playground where mechanics can grow without spaghetti code, making balance changes and feature expansion straightforward instead of painful rewrites.

🕯️ Vellum
A shift from hardcoding to data-driven design — verbs, rules, and interactions defined by datasets instead of scattered logic. This evolution turned the engine into a definition-based system where changing how the world works is a matter of editing data, not rewriting code. A foundation that separates gameplay expression from engine complexity.

🚀 Terminal Descent
Tight-loop engineering — a minimalist design boiled down to pure input, feedback, and consequence. No wasted cycles, no feature creep. The precision of the loop demonstrates how focus on clarity and responsiveness creates tension without needing layers of systems.

🌐 Terminal Minds Website
Identity forged with care — a professionally clean design that feels unique, not templated. Fully modularized: information stored in JSON, dynamically rendered by JavaScript, styled with CSS for consistency. Lightweight and fast, built to scale with zero bloat. A framework that balances aesthetics, performance, and maintainability, giving every project a polished stage.

The story behind Terminal Minds. Progress logs, design notes, and reflections — each diary is a snapshot of where we are and where we’re headed.

Browse Dev Diaries on GitHub

RPG Flags in a Single Byte — Back in the day, games squeezed every bit of memory. Literally. Instead of using separate variables for states like is_poisoned, is_blessed, or has_potion, they’d pack up to 8 on/off flags into a single byte using bit manipulation. Efficient, fast — and it made save files look like hieroglyphs.

// example handle_player_flags.c
      
#define POISONED   (1 << 0)  // 00000001
#define BLESSED    (1 << 1)  // 00000010
#define STUNNED    (1 << 2)  // 00000100
#define INVISIBLE  (1 << 3)  // 00001000
// ... up to bit 7

unsigned char status = 0; // all flags off

// Set a flag
status |= POISONED;   // 00000001
status |= INVISIBLE;  // 00001001

// Clear a flag
status &= ~POISONED;  // clears poisoned

// Check a flag
if (status & INVISIBLE) {
    printf("Player is invisible!\n");
}

// Toggle a flag
status ^= STUNNED; // flips stunned bit