Posts on Birdor Blog

Plumego Advanced Guide: Designing Explicit, Scalable Go Services

Tue, 30 Dec 2025 20:30:00 +0800

Plumego Advanced Guide: Designing Explicit, Scalable Go Services

Introduction: Beyond the Basics

The introductory Plumego documentation explains what Plumego is and why it exists. This guide focuses on a different question:

How do you design serious, long-lived systems with Plumego?

This article assumes that you already understand:

Go fundamentals
HTTP server basics
The core Plumego APIs
The philosophy of explicitness

What follows is an advanced, production-oriented tutorial. We will explore architectural patterns, not just APIs. The emphasis is on design decisions, trade-offs, and operational correctness—the areas where Plumego provides leverage without hiding complexity.

Plumego: A Deliberate Go Framework for Engineers Who Value Explicitness

Tue, 30 Dec 2025 19:00:00 +0800

Introduction: Why Another Go Framework?

The Go ecosystem does not suffer from a lack of web frameworks. From minimalist routers to batteries-included solutions, developers can choose from a wide spectrum of abstractions. Yet, despite this abundance, many experienced teams eventually encounter a recurring problem:

Their framework either does too little to guide large systems, or too much to stay out of the way.

Plumego exists in the narrow but important space between these extremes.

Introducing Birdor Tools — A Calm, Developer-Friendly Toolbox for the Modern Web

Sat, 29 Nov 2025 09:00:00 +0800

Birdor Tools is now live.

A quiet companion for developers, built with the belief that good tools should feel calm, predictable, and pleasant to use.

Welcome to a place where engineering is simple again.

What Is Birdor Tools?

Birdor Tools is a developer-first toolbox and knowledge hub, designed to combine:

High-traffic foundational tools
JSON formatter, UUID/Nanoid generator, Base64/Hash utilities, Regex tester, Cron visualizer, etc.
Enhanced, AI-assisted developer tools
Clear, deterministic output — not hallucinations.
SaaS-ready APIs for production use
Reliable, rate-limited, globally cached.

It is not a “tool dump”.
It is a curated, intentional, long-term product that emphasizes:

Birdor Update — Unified Badges, Prebuild Changelog Pipeline, and New 'What is Birdor' Page (2025-11-29)

Sat, 29 Nov 2025 00:00:00 +0800

This update brings UI improvements, infrastructure enhancements, and a major new documentation feature: the official “What is Birdor?” product overview page.

Unified Updated Badge

Type: tool
Scope: ui-badges
Importance: minor

Summary

Introduced the universal “● Updated” badge for use across Tools, Docs, and the Changelog.

Details

Supports ● Updated and ✨ New variants.
Integrated in the Tools grid, Docs notice bar, and Changelog entries.
Ensures consistent visual language for updates across the product.

MD → JSON Changelog Build Pipeline

Type: infra
Scope: build
Importance: minor

Birdor Tools & Docs Update — JWT HS512, JSON Tree Collapsing, Changelog Launch (2025-11-28)

Fri, 28 Nov 2025 00:00:00 +0800

This update brings enhancements across multiple Birdor tools and introduces the official Changelog system, providing a public and structured way to track product improvements.

JWT Debugger: HS512 Support and Expiry Hints

Type: tool
Scope: jwt-debugger
Importance: minor

Summary

Added HS512 verification and clearer interpretation for JWT time-based claims.

Details

HS512 is now available alongside HS256 and HS384.
exp, iat, and nbf claims now show human-readable timestamps, improving clarity during debugging.

JSON Formatter: Smarter Tree Collapsing

Type: tool
Scope: json-formatter
Importance: minor

Python Beginner Handbook

Thu, 27 Nov 2025 20:27:00 +0800

Python is simple to learn, expressive to write, and powerful enough to build systems of any scale — from automation scripts to backend APIs and machine learning pipelines.

This handbook contains 20 concise, developer-friendly chapters, each focusing on practical understanding and working examples.

Chapter 1 — What Is Python & Why It Matters

Python is a high-level, cross-platform, readable language created in 1991.
Its design goals:

readability
developer productivity
“batteries-included” standard library
large ecosystem of packages

Python powers:

Python vs Go vs Rust — A Calm, Developer-Focused Comparison

Thu, 27 Nov 2025 20:21:00 +0800

A Calm, Developer-Focused Comparison

Python, Go, and Rust are three of the most influential languages in modern software engineering.
They represent three different philosophies:

Python: simplicity & productivity
Go: concurrency, cloud, and production reliability
Rust: memory safety & high performance

This article provides a clear, concise, and practical Birdor-style comparison to help you decide which language fits your next project.

1. Design Philosophy: What Each Language Values

Python — Readable, expressive, productive

Python prioritizes human time over machine time.
The design is optimized for:

Birdor Website Update — SEO Enhancements & GitHub Header Link (2025-11-27)

Thu, 27 Nov 2025 00:00:00 +0800

This update introduces a comprehensive SEO improvement for all Birdor tool pages and a usability enhancement with the addition of a GitHub link in the site header.

SEO Metadata Added for All Tools

Type: website
Scope: seo
Importance: minor

Summary

Standardized per-tool SEO metadata across the Tools section, ensuring consistent and clear presentation for search engines and social previews.

Details

Added SEO configs for JSON, JWT, URL, Base64, and UUID tools.
Introduced global SEO helper templates for consistent rendering.
Improved Open Graph metadata for link previews and sharing across platforms.

Lua for Game Development — Sample Game

Wed, 26 Nov 2025 13:24:00 +0800

A practical, end-to-end handbook on using Lua to build modern games — from core syntax to engine architecture, AI, netcode and shipping.

Lua for Game Development — Complete Book

Wed, 26 Nov 2025 13:20:00 +0800

A complete, practical, production-ready guide to using Lua for modern game development — from syntax basics to engine architecture, AI, networking, tools and full deployment.

Lua for Game Development — Chapter 19: Packaging, Deployment, Localization & Release Pipeline

Wed, 26 Nov 2025 13:14:00 +0800

You’ve built your game.

Now you must ship it.

Shipping a game is an engineering discipline in itself, requiring:

packaging
build automation
deployment to multiple platforms
patching & updates
asset pipelines
localization
DLC & mod support
crash reporting
analytics
CI/CD workflows

Lua games can ship to:

Windows
macOS
Linux
Web (HTML5)
iOS
Android
Steam Deck

This chapter shows how to build a full release pipeline, regardless of engine.

1. Build Artifacts: What Needs to Be Packaged?

You must package:

Lua for Game Development — Chapter 18: Engine Architecture, ECS, Plugins & Optimization

Wed, 26 Nov 2025 13:10:00 +0800

To complete your Lua game development knowledge, you must understand how to design a full engine:

entity management
components
systems
module lifecycle
asset management
scripting pipelines
performance tuning
optimization patterns
debugging & profiling

Lua excels as an engine scripting language due to:

fast VM
low memory footprint
simple integration with C/C++
natural data-driven design
coroutine support
quick iteration
extensibility

This chapter finalizes the architecture needed for professional, scalable Lua game engines.

Lua for Game Development — Chapter 17: Save Systems, Persistence, Serialization & Content Pipelines

Wed, 26 Nov 2025 13:05:00 +0800

A modern game needs:

reliable save/load systems
world state persistence
player progression
inventory & quests
NPCs and simulation state
safe serialization & versioning
replay systems
modding and content pipelines

Lua is ideal for all of this:

tables serialize well
code is data, data is code
tables are readable and versionable
hot reload simplifies pipelines
modding = just load more Lua files

This chapter builds a complete system that scales from small to AAA-style persistence.

Lua for Game Development — Chapter 16: Multiplayer, Netcode, Sync Models & Lag Compensation

Wed, 26 Nov 2025 13:00:00 +0800

Multiplayer is the hardest part of game development.
This chapter covers the exact models used by:

Fortnite
Apex Legends
Overwatch
Rocket League
Factorio
StarCraft II
Roblox
Unity Netcode / Unreal replication

You will learn the following sync models:

Lockstep (deterministic strategy / SLG)
Snapshot interpolation (action games)
Client-side prediction & reconciliation
Entity replication (position/rotation/state)
Combat sync
Bullet/projectile sync
Lag compensation (server rewind, hit-scan)
Anti-cheat considerations

Lua is excellent for netcode:

Lua for Game Development — Chapter 15: UI Systems, HUD, Menus & Data Binding

Wed, 26 Nov 2025 12:50:00 +0800

UI is the backbone of:

inventories
crafting
equipment menus
quests & story
shops
minimaps
HUD overlays
dialogue
pause menu
game settings

Lua is excellent for UI logic because:

UI widgets map naturally to tables
easy event dispatch
hot-reload speeds iteration
data binding = reactive UI
timeline-based animations work perfectly

This chapter builds a modern, scalable UI framework in Lua.

1. UI Widget System

UI widgets are components:

panels
labels
buttons
images/icons
windows
scroll lists
tooltips
HUD overlays

We define a generic widget base class.

Lua for Game Development — Chapter 14: Combat AI, Behavior Trees, Utility AI & Enemy Design

Wed, 26 Nov 2025 12:40:00 +0800

Combat AI determines the challenge, pacing, and tension of any action game.

Modern games use:

State Machines (simple AI)
Behavior Trees (modular, readable)
Utility AI (dynamic decisions)
Blackboards (shared memory)
Squad AI (formations, flanking, roles)
Boss AI (scripted phases + BT nodes)

Lua’s flexibility makes it ideal for building AI layers.

This chapter builds:

Enemy archetypes
Finite State Machine (FSM) combat AI
Behavior Tree engine
Utility-based decision system
Aggro & threat systems
Group tactics (flank, assist, swarm)
Boss scripting (phases, triggers, timelines)

1. Enemy Archetypes

Define enemies in data:

Lua for Game Development — Chapter 13: NPCs, Town Simulation, Factions & AI Routines

Wed, 26 Nov 2025 12:30:00 +0800

NPCs breathe life into any game world:

villagers with schedules
merchants with stock
guards who patrol
hostile factions
relationships
dialogue that reacts to story flags
simulation (hunger, work, needs)
towns that evolve over time

Lua is perfect for simulation layers:

lightweight logic
hot reload
easy-to-edit behavior packages
clean data-driven content
integrates with quests, story, and world triggers

This chapter builds:

NPC definitions
Behavior packages (wander, talk, patrol, work)
Daily schedules (day/night cycles)
Merchant system
Factions & reputation
Town simulation
Social interactions

1. NPC Definitions (Data-Driven)

npcs/
villagers.lua
merchants.lua
guards.lua

1.1 Example NPC Definition

return {
  elder = {
    name = "Village Elder",
    sprite = "npc_elder",
    faction = "village",
    behaviors = {"talk", "idle"},
    dialogue = "elder_intro",
    schedule = {
      {time=0,   state="sleep"},
      {time=6,   state="idle"},
      {time=12,  state="walk_square"},
      {time=18,  state="home"},
      {time=22,  state="sleep"},
    }
  },
}

NPC = data + behaviors + dialogue + schedule.

Lua for Game Development — Chapter 12: Quests, Missions, Dialogue Trees & Story Progression

Wed, 26 Nov 2025 12:20:00 +0800

Modern games rely heavily on structured progression systems:

Main story quests
Side quests
Dynamic missions
Dialogue trees
NPC interactions
World state & flags
Branching narrative
Story checkpoints
Rewards

Lua is ideal for this:

Data-driven quest definitions
Easy branching logic
Hot reload for dialogue systems
Clean JSON-like scripting
Integrates perfectly with triggers, inventory, UI, and levels

This chapter introduces a complete quest system used in RPGs, action games, and open-world titles.

Lua for Game Development — Chapter 11: Inventory, Items, Equipment, Crafting & Data-Driven Content

Wed, 26 Nov 2025 12:10:00 +0800

Inventory and item systems are essential for:

RPGs
Action RPGs
Survival games
Roguelikes
Adventure/Metroidvania
Open-world games
SLG/Strategy games
Loot-based games

Lua is perfect for building these systems:

Data-driven items (Lua tables)
Hot-reloadable item definitions
Easy extensions (rarities, tags, effects)
Modular inventory logic
Crafting formulas as tables
Shops using item IDs
Persistent save/load

This chapter builds a complete, modern item ecosystem.

1. Item Definitions (Data-Driven)

All items are defined as Lua tables.
This is how most professional games implement content pipelines.

Lua for Game Development — Chapter 8: Animation Systems, Cameras, Cutscenes & Timeline Scripting

Wed, 26 Nov 2025 10:24:00 +0800

Animation and cinematic systems transform raw gameplay into a polished, emotional experience.
Lua is ideal for sequencing, orchestration, animation management, and camera scripting because:

Coroutine syntax is perfect for timelines.
Hot reload accelerates iteration.
Data-driven tables make timelines readable.
Engines expose animation/camera APIs easily.

In this chapter we build:

Animation state machines
Sprite animation system
Camera follow/zoom/lerp
Timeline scripting engine
Dialogue system
Cutscenes (with coroutines)
Screen/camera effects (shake, flash, fade)
Sequencers for complex cinematic flows

1. Animation State Machines (ASM)

Most games rely on an animation finite-state-machine:

Lua for Game Development — Chapter 7: UI Systems, HUD, Widgets, Event Binding, and Lua-Driven UI Architecture

Wed, 26 Nov 2025 10:20:00 +0800

User interfaces are a core part of game development:

HUD (health bars, minimaps, ammo counters)
Menus (pause, settings, inventory)
In-game shops
UI alerts and notifications
Pop-up windows and dialogs
Touch UI for mobile

Lua excels here because UI scripting requires:

Flexibility
Fast iteration
Easy updates
Data binding
Coroutine-friendly animations
Modular components

This chapter teaches you how to build a complete UI architecture in Lua.

1. The Goals of a Good UI Architecture

A production UI system must be:

Lua for Game Development — Chapter 10: Audio, Particles, VFX & Feedback Systems

Tue, 25 Nov 2025 23:55:00 +0800

Great gameplay is not only logic, animation, and UI.

It is FEEL.

Games become satisfying through:

impactful audio
juicy hit feedback
particles & sparks
camera shake
screen flashes
slow motion
dynamic music

Lua excels at orchestrating these effects.

This chapter will show how to design a complete feedback system using Lua.

1. Audio Architecture

Audio usually comes in three categories:

Sound Effects (SFX)

Attacks, footsteps, explosions.

Background Music (BGM)

Looping tracks.

Lua for Game Development — Chapter 9: Scenes, Levels, World Systems & Spawning

Tue, 25 Nov 2025 23:20:00 +0800

Modern games have scenes, levels, maps, spawn waves, world streaming, checkpoints, and persistent game states.
Lua’s lightweight and data-driven nature makes it perfect for orchestrating:

Level loading/unloading
Map systems (tile-based or object-based)
Trigger zones and events
Spawn systems (enemies, loot, NPCs)
World progression
Checkpoints/Save systems
Streaming large worlds
Scene transitions & layering

In this chapter, we build a full world architecture that can be extended to RPGs, shooters, platformers, adventure games, and SLG games.

Lua for Game Development — Chapter 6: AI Systems — BT, FSM, Utility AI, GOAP, Navigation, Hybrid AI

Tue, 25 Nov 2025 20:11:00 +0800

Game AI is one of Lua’s strongest domains.
Lua scripts drive NPCs in:

World of Warcraft
Don’t Starve
CryEngine titles
Roblox (Luau)
Cocos2d-x Lua games
Thousands of mobile/indie games

Game studios rely heavily on Lua due to:

Ease of scripting
Data-driven behavior
Fast iteration
Easy debugging and hot reload
Coroutine-based timelines

This chapter covers all major AI paradigms used in modern games:

FSM (Finite State Machines)
Behavior Trees (BT)
Utility AI (Score-based decision AI)
GOAP (Goal-Oriented Action Planning)
Navigation patterns
Blackboard memory systems
Hybrid AI architecture for bosses
Performance tuning for large AI crowds

1. Finite State Machines (FSM)

FSMs are simple, predictable, and great for:

Lua for Game Development — Chapter 5: Combat Systems, Hitboxes, Stats, Buffs, and Abilities

Tue, 25 Nov 2025 20:03:00 +0800

Combat systems are the backbone of many games:
RPGs, action games, shooters, platformers, MOBAs, and roguelikes.

This chapter explains how to implement real combat architecture in Lua:

Entity stats & modifiers
Damage pipeline
Hitboxes & hurtboxes
Buffs, debuffs, DOTs, HOTs
Cooldowns & cast times
Skill/ability system
Combat logs & replay
Network-sync-friendly updates

This is a complete combat architecture, not a toy example.

1. Entity Stats (Base + Modifiers)

Stats usually come from:

Lua for Game Development — Chapter 4: Building a Full Lua Game Architecture

Tue, 25 Nov 2025 20:00:00 +0800

This chapter teaches you how to design a complete Lua game architecture—the same structure used by real production engines.

We will build:

A robust game loop
Scene management (stack-based)
Systems & update flow
Input abstraction
Resource manager
Save/load system
Hot reload support
Debugging overlays & dev tools

A real game must be modular, testable, and reloadable.

Lua excels here.

1. The Game Loop (Core of Any Engine)

All engines—Unity, Unreal, Godot, Defold, Cocos2dx-lua, Corona, LÖVE—follow the same idea:

Lua for Game Development — Chapter 3: Practical Patterns for Real Games

Tue, 25 Nov 2025 19:58:00 +0800

Modern game development relies heavily on Lua’s flexibility.
Studios consistently use a set of Lua architectural patterns to build clean, scalable, and maintainable game logic.

This chapter presents the patterns used in:

2D/3D indie engines
AAA game scripting systems
LiveOps / network games
Modular UI systems
Defold / Love2D / Roblox (Luau) / Cocos2d-x Lua
Custom C++ engines with embedded Lua

We will cover:

Entity & component architecture (ECS-friendly)
Messaging & event buses
Timer systems & schedulers
Finite state machines (FSM)
Behavior trees (BT) in pure Lua
Tweening & animation patterns
Modular game script structure

This is the first “serious engineering” chapter in the book.

Lua for Game Development — Chapter 2: Language Essentials

Tue, 25 Nov 2025 19:52:00 +0800

Lua’s syntax is small, elegant, and optimized for scripting game logic.
This chapter teaches Lua through a game development lens, focusing on features you will actually use when scripting AI, animations, UI, events, gameplay systems, or tools.

This is not a language textbook.
This is Lua for building real games.

1. The Building Blocks of Lua

Lua’s core types:

nil
boolean
number
string
table← the most important type
function ← first-class citizen

There are no classes, arrays, or objects—tables represent all of these.

Lua for Game Development — Chapter 1: Why Lua?

Tue, 25 Nov 2025 19:48:00 +0800

Lua is one of the most influential technologies in game development.
It is lightweight, embeddable, fast, expressive, and battle-tested across decades.

In this chapter, we explore why Lua is still the #1 scripting language for games, how it fits into modern engines, and the core principles that make Lua unique.

1. What Makes Lua Special?

Lua was designed with one mission:

A small, fast scripting language that can glue complex systems together.

Lua Deep Dive: Coroutines, State Machines, DSLs, and Game Scripting Architecture

Tue, 25 Nov 2025 19:21:00 +0800

Lua is not just a lightweight script language.
It is a runtime toolbox capable of building state machines, pipelines, schedulers, entity systems, and even domain-specific languages (DSLs).

This deep dive focuses on production-level techniques heavily used in:

Game engines (Defold, Love2D, custom C/C++ engines)
AI scripting
UI scripting
Simulation and animation
Networking and asynchronous flows
Configuration languages and DSLs

1. Coroutine Pipelines (The Real Power of Lua)

Coroutines allow cooperative multitasking, enabling sequential code that behaves like async flows.

Lua Advanced: Metatables, Coroutines, and Powerful Patterns

Tue, 25 Nov 2025 19:20:00 +0800

Lua is simple on the surface, but extremely powerful underneath.
This article explores metatables, metamethods, coroutines, advanced module design, and a set of practical patterns used in games, tools, and embedded systems.

All examples are fully runnable with standard Lua 5.3/5.4.

1. Metatables: Lua’s Custom Behavior Engine

Metatables let you customize how tables behave—similar to operator overloading, custom indexing, inheritance, and more.

1.1 Basic Example: __index Fallback

local defaults = {hp = 100, mp = 50}

local player = {}
setmetatable(player, {
  __index = defaults
})

print(player.hp)  -- 100
print(player.mp)  -- 50

Explanation:

A Practical Introduction to Lua (Beginner Friendly)

Tue, 25 Nov 2025 19:16:00 +0800

Lua is a lightweight, embeddable scripting language widely used in game engines (Defold, Roblox, Corona), configuration systems, automation tools, and embedded platforms.

This article gives you a clean, beginner-friendly introduction with complete and runnable examples.

1. Setting Up and Running Lua

Install Lua

macOS

brew install lua

Linux (Ubuntu/Debian)

sudo apt-get install lua5.4

Windows
Download binaries or use Lua for Windows.

Run a Script

Write hello.lua:

print("Hello, Lua!")

Run:

Building a Tiny HTTP Server from Scratch with net + bufio

Tue, 25 Nov 2025 16:27:00 +0800

Go’s net/http package is fantastic—but sometimes you want to see what’s really happening under the hood.

In this article, we’ll build a tiny HTTP/1.1 server from scratch, using only:

net — for TCP sockets
bufio — for buffered I/O

No net/http, no handler interface, no magic.

You’ll learn:

How HTTP/1.1 requests look on the wire
How to parse the request line and headers
How to build a minimal response (status line, headers, body)
How to handle multiple connections with goroutines
A tiny router for different paths

This is not production code—it’s a learning tool. But it’s a great way to deeply understand HTTP.

A Deep Dive into Go’s net/http Internals

Tue, 25 Nov 2025 16:23:00 +0800

Go’s net/http package is deceptively simple on the surface—just call http.ListenAndServe() and pass a handler. But beneath its minimal API lies a highly optimized, battle-tested, and beautifully engineered HTTP runtime.

This article explores the internal architecture, concurrency model, lifecycle, request handling flow, connection reuse, transport behaviors, and performance strategies that make net/http one of Go’s most iconic packages.

This is a true deep dive—use it to understand how Go’s HTTP stack really works under the hood.

Designing a High-Performance, Multi-Goroutine Socket Server in Go

Tue, 25 Nov 2025 11:57:00 +0800

High-performance networking is one of Go’s strengths. With lightweight goroutines, a rich net package, and strong concurrency primitives, Go is a great fit for building custom TCP servers, game backends, proxies, and internal protocols.

In this article, we’ll design and implement a high-performance, multi-goroutine socket server in Go, with an architecture you can evolve into a real-world production system.

We’ll cover:

Architecture and design goals
A baseline TCP server
A multi-goroutine concurrency model
Connection limits and backpressure
Request handling with worker pools
Graceful shutdown and observability

1. Goals and Design Principles

We’ll design a server that:

A Deep Dive into Go’s net Package: Networking from First Principles

Tue, 25 Nov 2025 11:46:00 +0800

The net package is the foundation of all network programming in Go.
Everything — from HTTP servers to gRPC, Redis clients, DNS resolvers, and low-level TCP/UDP tools — ultimately relies on Go’s networking stack built around the net package.

This article provides a deep, practical, and complete exploration of net with clear explanations and runnable examples.

1. Why the `net` Package Matters

Go’s networking model is:

Simple – Uses familiar Unix-style sockets and file descriptors.
Cross-platform – Same code works on Linux, macOS, Windows.
Concurrent by design – Each connection can be handled by a goroutine.
Powerful – TCP, UDP, Unix domain sockets, DNS, interfaces, IPs, CIDR tools, etc.

Higher-level packages rely on it:

Birdor Tools & Docs Update — URL Parser Release (2025-11-25)

Tue, 25 Nov 2025 00:00:00 +0800

This update introduces the full release of the URL Parser & Query Editor, one of Birdor’s essential web debugging tools.
The accompanying documentation provides a deep technical reference for URL parsing, normalization, and edge-case behavior.

URL Parser & Query Editor Released

Type: tool
Scope: url-parser
Importance: minor

Summary

Launched the complete URL Parser & Query Editor tool with full URL breakdown and live reconstruction preview.

Details

Added URL breakdown for protocol, hostname, path, query, hash.
Added UI to add / remove / edit query parameters.
Introduced normalized URL reconstruction with proper percent-encoding rules.

URL Parser Documentation Created

Type: docs
Scope: docs-url-parser
Importance: minor

Understanding Go’s context Package: A Deep Dive

Mon, 24 Nov 2025 19:20:00 +0800

Go’s context package is one of the most important tools for building robust, cancellable, timeout-aware, concurrent programs. Whether you are writing HTTP servers, gRPC services, background workers, or database operations, you will almost always use context.Context.

This article provides a deep, practical, and complete analysis of the context package using clear code examples.

1. Why `context` Exists

Modern Go programs are highly concurrent. You might start goroutines for:

database queries
API calls
background tasks
streaming events

But how do you cancel a goroutine?
How do you propagate deadlines across function calls?
How do you attach request-scoped values safely?

Getting Started with Go: A Practical Beginner’s Guide

Mon, 24 Nov 2025 19:00:00 +0800

Go (often called Golang) is a modern programming language designed at Google. It focuses on simplicity, performance, and built-in concurrency. If you want to build fast web services, CLIs, tools, or backend systems, Go is a great choice.

This article will walk you through Go from zero to a small, working example, with plenty of code you can copy, paste, and run.

1. What is Go and Why Use It?

Go is:

Birdor Tools & Docs Update — JWT Debugger UI + Documentation (2025-11-23)

Sun, 23 Nov 2025 00:00:00 +0800

This update focuses on both the JWT Debugger tool UI and its corresponding documentation guide, providing a complete end-to-end experience for developers inspecting and validating JSON Web Tokens on Birdor.

JWT Debugger UI Foundation Created

Type: tool
Scope: jwt-debugger
Importance: minor

Summary

The initial UI foundation for the JWT Debugger is now in place, including decode panels and token validation views.

Details

Added header / payload / signature display sections.
Added visual highlighting for invalid and expired tokens.
Implemented a Base64URL decoder with automatic padding correction.

JWT Debugger Tool Guide Created

Type: docs
Scope: docs-jwt-debugger
Importance: minor

A Calm & Complete Introduction to Python

Thu, 20 Nov 2025 20:15:00 +0800

Python is one of the most widely used programming languages today — simple enough for beginners, powerful enough for companies like Google, Instagram, Spotify, and NASA.

This article provides a calm, friendly, and practical introduction to Python in the Birdor style: concise, structured, and useful.

What Is Python?

Python is a high-level, general-purpose programming language created by Guido van Rossum and released in 1991.
It was designed with a clear goal:

Next.js: Data Fetching in Next.js

Thu, 20 Nov 2025 13:30:00 +0800

A calm, practical guide to loading, caching, and streaming data in modern React applications.

Data fetching is one of the biggest changes in the Next.js App Router era.
Instead of manually orchestrating waterfalls, suspense boundaries, and client-side fetches, Next.js encourages a server-first, cached-by-default model that results in faster and more predictable applications.

But the shift introduces new concepts:

Where does fetch() actually run?
When does Next.js cache responses?
What is “revalidation”?
How do you fetch data per segment?
What’s the right pattern for production apps?

This chapter provides a complete, practical understanding — calm, clear, and grounded.

Next.js: Server Components & Client Components

Thu, 20 Nov 2025 13:00:00 +0800

A calm, practical guide to understanding what runs on the server, what runs in the browser, and why this distinction matters in modern React development.

Server Components are one of the defining features of modern Next.js.
They represent a shift in how we think about rendering, data fetching, and performance.
But they also introduce new questions:

What exactly is a Server Component?
When do I need a Client Component?
How do they interact?
What patterns lead to stable, predictable apps?

In this chapter, we’ll clarify these ideas — simply, calmly, without hype.

Next.js: File-Based Routing Deep Dive

Thu, 20 Nov 2025 12:30:00 +0800

Next.js uses your folder structure as your routing system.
This can feel simple at first (“a folder becomes a URL”), but under the surface, file-based routing is one of the most expressive tools in modern web development.

In this chapter, we’ll take a calm, structured look at how routing works in the App Router, and how to use it to build clear, scalable, real-world applications.

No complicated abstractions — just practical, predictable patterns.

The App Router: A Modern Way to Build React Applications

Thu, 20 Nov 2025 12:00:00 +0800

The App Router is one of the most important ideas in modern Next.js.
It replaces the old Pages Router with a more flexible, more intuitive, and more scalable way to structure your application.

Instead of thinking in terms of “pages with lifecycle functions,” you design your app in terms of composable layouts, nested routes, and Server/Client Components working together.

In this chapter, we’ll explore what the App Router is, why it matters, and how to use it without confusion or unnecessary complexity.

Learn Next.js: A Calm, Practical Series

Thu, 20 Nov 2025 11:30:00 +0800

Next.js is one of the most capable frameworks in the modern React ecosystem.
It can power simple marketing pages, content sites, and fully-fledged SaaS products — all from the same toolkit.

This Birdor-style series is a calm, structured learning path that helps you:

Understand what Next.js actually does (and what it doesn’t).
Build real applications instead of toy examples.
Ship production-grade apps with sane defaults: routing, data fetching, auth, performance, deployment.

No hype, no magic. Just practical, modern web engineering.

Modern Backend Architecture Best Practices (2025 Edition)

Thu, 20 Nov 2025 10:40:00 +0800

Modern backend systems have changed dramatically in recent years.
But the heart of good engineering hasn’t: clarity, reliability, observability, and intentional design.

This guide takes a calm and practical look at what “best practice” means in 2025 — without hype, without noise, just the essentials that help you build better systems.

1. Principles That Still Matter

1.1 Simplicity Before Complexity

Backend architecture succeeds when its domain model remains easy to reason about.
Before thinking about microservices, start with:

Next.js: A Calm, Modern Framework for the React Era

Thu, 20 Nov 2025 10:30:00 +0800

Next.js is a React framework that helps you build fast, production-ready web apps without drowning in configuration.
Instead of stitching together routing, bundling, SSR, API endpoints, and deployment by hand, you get a batteries-included toolkit that still feels close to plain React.

This article is a calm, practical overview of what Next.js is, why it’s useful, and how it fits into a modern Jamstack / full-stack workflow.

What is Next.js?

At its core, Next.js is:

Birdor Docs Update — Tool Guides Section Launched (2025-11-20)

Thu, 20 Nov 2025 00:00:00 +0800

This development log introduces the Tool Guides section in Birdor Docs — the first structured area dedicated to tool-specific documentation.
This launch marks an important step toward a unified, readable, and expandable documentation system.

Docs: Tool Guides Section Launched

Type: docs
Scope: docs:tool-guides
Importance: minor

Summary

Added dedicated documentation pages for:

JSON Formatter
JWT Debugger
URL Parser

These are now the foundational tool docs inside the Birdor documentation system.

Details

Introduced shared documentation components:
- DocsShell
- DocsSection
- DocsCard
- DocsTable
Established the groundwork for future API documentation, architecture deep dives, and developer onboarding guides.

Modern Front-End Trends, Part 8: Modern Jamstack and the Full-Stack Front-End

Wed, 19 Nov 2025 23:55:00 +0800

Introduction

When the term Jamstack was introduced around 2016, it promised a simpler, more performant, more secure way to build websites. The original model was:

JavaScript
APIs
Markup

A static-first architecture powered by:

CDNs
serverless functions
pre-rendered pages

This approach was revolutionary.
But the web has changed dramatically.

Modern applications require:

server-side rendering
dynamic personalization
authenticated dashboards
streaming content
real-time collaboration
AI-powered interactions
distributed databases
edge compute

The original Jamstack was simply not designed for these needs.

Modern Front-End Trends, Part 7: WebAssembly and New Capabilities

Wed, 19 Nov 2025 23:54:00 +0800

Introduction

WebAssembly (Wasm) represents one of the most significant advances in the history of the web platform.
Where JavaScript brought dynamic interactivity to browsers, WebAssembly extends the web with:

high-performance computation
portable binary modules
execution close to native speed
language interoperability (Rust, C/C++, Go, Zig, Swift, etc.)
sandboxed security
stable execution across environments

Originally imagined as a way to bring “native apps to the browser,” Wasm has become much more:

Modern Front-End Trends, Part 6: AI-Augmented Front-End Development

Wed, 19 Nov 2025 23:52:00 +0800

Introduction

For decades, front-end development was shaped by frameworks, browsers, and tooling.
But in the last two years, AI has become the most transformative force in how developers:

build user interfaces
manage state
generate components
scaffold entire apps
write documentation
test code
debug performance issues
delegate repetitive tasks
explore new design ideas

AI has become an always-on co-developer—capable of generating production-grade UI, analyzing architectural patterns, and automating workflows that previously required hours or days of manual effort.

Modern Front-End Trends, Part 5: CSS Evolves — Utility-First and Native-First

Wed, 19 Nov 2025 23:50:00 +0800

Introduction

CSS is undergoing its most significant evolution in over a decade.
Historically, developers relied heavily on:

BEM naming conventions
preprocessors like SASS or LESS
global styles that easily collided
complex CSS-in-JS runtimes
design systems implemented through component libraries

The web has changed.
Modern applications demand scalable styling patterns, low runtime overhead, and predictable, maintainable design systems.

Two major movements define today’s landscape:

1. Utility-First CSS (Tailwind and successors)

2. Native-First CSS (powerful new language features)

These movements coexist—not as rivals, but as complementary forces.

Modern Front-End Trends, Part 4: Performance and the New Speed Standards

Wed, 19 Nov 2025 23:48:00 +0800

Introduction

Web performance is no longer optional.
It directly affects:

search engine ranking
conversion rates
user retention
perceived quality
accessibility
global user experience

In the 2010s, developers often built first, optimized later.
But today’s applications are too complex, and users too impatient, for that approach.

Performance now must be built into the architecture. Not an add-on.

This is why modern frameworks and platforms—from Next.js to Astro to Nuxt to SvelteKit—prioritize:

Modern Front-End Trends, Part 3: TypeScript as the Universal Web Language

Wed, 19 Nov 2025 23:46:00 +0800

Introduction

TypeScript has quietly become the default language of the web.
In startups and enterprises alike, it is now difficult to find a serious front-end codebase that hasn’t adopted TypeScript—or is not actively migrating toward it.

The reasons are straightforward but profound:

safer refactoring
better IDE support
clearer API contracts
more predictable runtime behaviour
fewer production bugs
far better collaboration in teams

What started as a “typed superset of JavaScript” has evolved into the principal foundation for modern front-end development, especially in frameworks like:

Modern Front-End Trends, Part 2: Edge Computing and the Global Web

Wed, 19 Nov 2025 23:44:00 +0800

Introduction

The web is becoming global by default.
Users expect pages to load instantly—regardless of where they are. But traditional server architectures are built around central regions:

A single server (or cluster) in Virginia
A CDN to cache static assets
A backend thousands of kilometers away

This model can’t match the expectations of 2025:

interactive pages must render quickly
authenticated content must not be slow
dashboards must maintain consistent latency
APIs must remain responsive worldwide

Edge computing solves this.

Modern Front-End Trends, Part 1: The Rise of Hybrid Rendering Frameworks

Wed, 19 Nov 2025 23:39:00 +0800

Introduction

For more than a decade, front-end development has been shaped by two primary rendering models:

Single-Page Applications (SPA) powered by client-side JavaScript
Server-Side Rendering (SSR) powered by backend frameworks

These two paradigms guided the web’s evolution through the 2010s. Developers chose one or the other depending on product needs, performance constraints, or organizational preference.

But the modern web has moved on.

Today’s frameworks—Next.js, SvelteKit, SolidStart, Remix, Nuxt 3, Astro—embrace a unified philosophy:

Modern Front-End Web Development Trends (2025)

Wed, 19 Nov 2025 19:41:00 +0800

Front-end development continues to evolve at a remarkable pace. What started as simple document rendering has grown into a sophisticated ecosystem of frameworks, build pipelines, distributed runtimes, and cloud-native deployment models.

This article provides a practical, credible, and comprehensive overview of today’s most important trends—covering frameworks, architectures, performance, tooling, and the emerging direction shaped by AI and edge computing.

Birdor’s goal is to give developers clarity over hype, highlight what truly matters, and help you architect modern, resilient, and scalable applications.

Cloudflare Performance Optimization Playbook — Birdor Cloudflare Tutorial Series (Part 8)

Wed, 19 Nov 2025 17:15:00 +0800

Cloudflare improves performance out of the box, but thoughtful configuration can push your site (especially a Hugo/JAMstack site) to exceptional global performance.
This final chapter gathers Cloudflare’s performance-focused features into a calm, practical playbook. Each recommendation is designed to be simple to understand and safe to apply.

1. The Three Layers of Cloudflare Performance

Cloudflare performance can be thought of as three layers:

1. Global Network & Routing

Anycast routing, edge proximity, Argo Smart Routing.

Cloudflare Zero Trust & Security Essentials — Birdor Cloudflare Tutorial Series (Part 7)

Wed, 19 Nov 2025 16:50:00 +0800

Cloudflare is not only a CDN and global network — it is also a modern security platform. Cloudflare Zero Trust provides access control, identity verification, secure tunnels, traffic filtering, and threat mitigation without relying on traditional VPNs or complex infrastructure.

In this tutorial, we walk through the essential concepts, tools, and practical workflows that help you secure your sites, APIs, dashboards, and internal tools.

1. The Philosophy of Cloudflare Zero Trust

Traditional security models rely on the idea of a “trusted network.”
Cloudflare replaces this with a simpler principle:

Cloudflare KV, R2, and D1 Storage — Birdor Cloudflare Tutorial Series (Part 6)

Wed, 19 Nov 2025 16:30:00 +0800

Cloudflare offers a suite of distributed storage products that extend its serverless platform far beyond simple compute. KV, R2, and D1 each serve a different purpose — from configuration and caching to object storage and relational data.

This guide provides a calm, structured look at Cloudflare’s storage ecosystem and explains how to use each service with Workers and Pages Functions. The goal is clarity, not complexity.

1. The Philosophy of Cloudflare Edge Storage

Cloudflare’s storage model follows a simple idea:

Cloudflare Workers & Pages Functions — Birdor Cloudflare Tutorial Series (Part 5)

Wed, 19 Nov 2025 16:00:00 +0800

Cloudflare Workers allow developers to run JavaScript and TypeScript directly at the edge — close to users and without maintaining servers. Pages Functions provide the same compute model inside Cloudflare Pages projects, giving static sites like Hugo access to dynamic capabilities such as authentication, APIs, routing logic, and integrations.

This tutorial offers a calm, practical introduction to Workers and Functions with examples that fit naturally into Hugo and JAMstack projects. No prior serverless experience is required.

Cloudflare CDN, Caching, and Edge Rules — Birdor Cloudflare Tutorial Series (Part 4)

Wed, 19 Nov 2025 15:40:00 +0800

Cloudflare’s CDN and caching layer is one of the platform’s greatest strengths. For static sites like Hugo, it delivers global performance with almost no configuration. Yet understanding how Cloudflare caches, when it bypasses the cache, and how to fine-tune caching behavior will help you create a site that stays consistently fast for users across the world.

This chapter provides a calm, practical explanation of Cloudflare’s CDN architecture and the tools available for controlling cache behavior: Cache Rules, Page Rules, Transform Rules, and more.

Deploying Hugo on Cloudflare Pages — Birdor Cloudflare Tutorial Series (Part 3)

Wed, 19 Nov 2025 15:20:00 +0800

Hugo remains one of the fastest and most reliable static site generators available. Cloudflare Pages, with its global CDN and integrated serverless features, provides a perfect home for Hugo websites — from blogs and documentation to developer tools and knowledge bases.

This tutorial walks through the complete Hugo + Cloudflare Pages workflow using Birdor’s calm, developer-friendly style. By the end, you’ll have a solid, stable deployment pipeline with previews, HTTPS, and optional serverless logic.

Cloudflare DNS & Domain Management — Birdor Cloudflare Tutorial Series (Part 2)

Wed, 19 Nov 2025 15:00:00 +0800

Cloudflare DNS is one of the fastest and most reliable DNS services in the world. It’s also one of the easiest to use. Whether you’re hosting a Hugo site, an API, or a full web application, Cloudflare DNS gives you a stable foundation with minimal maintenance.

This tutorial provides a calm, practical walkthrough of managing domains on Cloudflare. If you’re new to DNS, don’t worry — our goal is clarity, not complexity.

Cloudflare Fundamentals — Birdor Cloudflare Tutorial Series (Part 1)

Wed, 19 Nov 2025 14:40:00 +0800

Cloudflare has grown into one of the most influential platforms in modern web architecture. What began as a CDN and security provider has expanded into a full edge-compute ecosystem used by small blogs, large SaaS platforms, and high-traffic global services.

This tutorial provides a calm, straightforward overview of Cloudflare — what it does, how its global network operates, and how each product fits into a modern developer workflow.

If you’re new to Cloudflare or simply want a clearer mental model, this is the place to begin.

A Complete Tutorial: Deploying Hugo to Cloudflare Pages

Wed, 19 Nov 2025 14:00:00 +0800

Cloudflare Pages is a fast, reliable, and developer-friendly platform for deploying static sites. It integrates naturally with GitHub, offers global CDN distribution, and supports full JAMstack workflows. Hugo, being one of the fastest static site generators available, pairs perfectly with Cloudflare Pages.

In this guide, we walk through the full workflow—building, connecting, deploying, enabling custom domains, and ensuring your site performs consistently across the Cloudflare network.

1. Why Use Cloudflare Pages for a Hugo Site?

Cloudflare Pages provides several strengths that align well with Hugo:

JAMstack vs SSR vs SPA: A Clear and Developer-Friendly Comparison

Wed, 19 Nov 2025 13:30:00 +0800

Modern web development revolves around three dominant architectural models: JAMstack, Server-Side Rendering (SSR), and Single-Page Applications (SPA). Each approach reflects different assumptions about performance, dynamic behavior, deployment, and developer experience.

At Birdor, we appreciate tools and architectures that are predictable, simple to maintain, and technically sound. This article provides a calm, detailed comparison of these three models to help you choose the right foundation for your project.

1. Overview of the Three Architectures

Before diving into trade-offs, here is a quick definition of each model.

JAMstack in Depth

Wed, 19 Nov 2025 13:00:00 +0800

Modern web development has moved far beyond monolithic backends and template engines. Across the industry, teams are embracing a simpler, more predictable architecture—one that prioritizes speed, security, and a clean separation of responsibilities. We often call this approach JAMstack.

At Birdor, we value tools and architectures that offer clarity and reliability. JAMstack fits that philosophy well. This article provides a calm, in-depth exploration of how JAMstack works and why it has become a strong foundation for modern websites and developer-focused tools.

A Complete and Authoritative Introduction to JAMstack

Wed, 19 Nov 2025 12:00:00 +0800

1. Introduction

JAMstack has rapidly grown from a niche concept into a mainstream architectural approach for building fast, secure, and scalable web experiences. Its core idea is simple: pre-render as much content as possible, deliver assets directly from a CDN, and use APIs to power dynamic functionality. This article provides a complete and credible guide to the JAMstack ecosystem, covering principles, architecture, workflows, and best-use cases.

2. What Is JAMstack?

2.1 Definition

JAMstack stands for:

Birdor Docs UI & JSON Tool Guide Update — 2025-11-19

Wed, 19 Nov 2025 00:00:00 +0800

This development log documents several UI component additions for the Birdor Docs system, along with the first full documentation page for the JSON Formatter & Viewer tool.
These updates improve documentation consistency, readability, and reusable structure.

DocsSection Component Added

Type: docs
Scope: docs-ui
Importance: minor

Summary

Introduced DocsSection to standardize headings and spacing across Birdor documentation.

Details

Supports h2 / h3 / h4 with consistent spacing.
Unified typography scale and hierarchical structure.
Reduced duplicated markup in multiple docs pages.

DocsCard & DocsTable Components

Type: docs
Scope: docs-ui
Importance: minor

Birdor Tools & Docs — Initial Structure Log (2025-11-18)

Tue, 18 Nov 2025 00:00:00 +0800

This document records the initial implementation work for the Birdor Tools page and the first version of the DocsShell layout system.
These foundational structures set the baseline for future expansion across Birdor Tools and Birdor Docs.

Initial Tools Page Structure

Type: tool
Scope: tools-page
Importance: minor

Summary

Set up the first iteration of the /tools layout and grid structure.

Details

Created basic Tools page with grid layout.
Added placeholder cards for JSON, JWT, URL tools.
Unified basic Tailwind spacing, max-width, and container structure.

DocsShell v0.1 Introduced

Type: docs
Scope: docs-ui
Importance: minor

Mon, 01 Jan 0001 00:00:00 +0000

---
title: "Choosing Plumego: A Framework Decision Guide for Serious Go Teams"
author: "Birdor Engineering"
slug: "choosing-plumego-framework-decision-guide"
date: 2025-12-30T22:30:00+08:00
lastmod: 2025-12-30T22:30:00+08:00
description: "A comprehensive, in-depth decision guide for evaluating Plumego as a Go framework. This article examines architectural trade-offs, team maturity, system lifecycle, operational concerns, and long-term maintainability to help serious Go teams decide when Plumego is the right choice."
keywords:
  - plumego
  - go framework decision
  - backend architecture
  - explicit systems
  - golang engineering
  - birdor
tags:
  - Go
  - Architecture
  - Engineering Decisions
  - Frameworks
categories:
  - Engineering
toc: true
draft: false
---

Choosing Plumego: A Framework Decision Guide for Serious Go Teams

Introduction: Framework Choice Is a Long-Term Commitment

Choosing a backend framework is rarely a neutral decision. While it is often treated as a matter of developer preference or short-term productivity, in practice it becomes a long-term architectural commitment.

Mon, 01 Jan 0001 00:00:00 +0000

---
title: "Plumego and Explicit Systems: An Engineering Philosophy"
author: "Birdor Engineering"
slug: "plumego-explicit-systems-philosophy"
date: 2025-12-31T00:30:00+08:00
lastmod: 2025-12-31T00:30:00+08:00
description: "A deep engineering essay on the philosophy behind Plumego. This article explores why explicit systems outperform implicit ones in long-lived software, how hidden abstractions accumulate technical debt, and why Plumego is intentionally designed as a framework that forces clarity, ownership, and architectural responsibility."
keywords:
  - plumego
  - explicit systems
  - software architecture philosophy
  - golang engineering
  - backend systems design
  - birdor
tags:
  - Go
  - Architecture
  - Philosophy
  - Engineering Culture
categories:
  - Engineering
toc: true
draft: false
---

Plumego and Explicit Systems: An Engineering Philosophy

Introduction: This Is Not a Feature List

This article is not about APIs.

Mon, 01 Jan 0001 00:00:00 +0000

---
title: "Building a Real Service with Plumego: From HTTP Entry to Domain Logic"
author: "Birdor Engineering"
slug: "plumego-real-world-service-walkthrough"
date: 2025-12-30T23:30:00+08:00
lastmod: 2025-12-30T23:30:00+08:00
description: "A deep, end-to-end walkthrough of building a real-world backend service with Plumego. This article traces a request from HTTP entry, through routing, middleware, context, use cases, domain logic, and infrastructure, explaining architectural decisions and trade-offs along the way."
keywords:
  - plumego
  - go backend example
  - clean architecture go
  - real world service
  - birdor
tags:
  - Go
  - Backend
  - Architecture
  - Practical Guide
categories:
  - Engineering
toc: true
draft: false
---

Building a Real Service with Plumego: From HTTP Entry to Domain Logic

Introduction: Why “Real” Examples Matter

Many framework tutorials stop at the point where things become interesting.

Posts on Birdor Blog

Plumego Advanced Guide: Designing Explicit, Scalable Go Services

Plumego Advanced Guide: Designing Explicit, Scalable Go Services

Introduction: Beyond the Basics

Plumego: A Deliberate Go Framework for Engineers Who Value Explicitness

Introduction: Why Another Go Framework?

Introducing Birdor Tools — A Calm, Developer-Friendly Toolbox for the Modern Web

What Is Birdor Tools?

Birdor Update — Unified Badges, Prebuild Changelog Pipeline, and New 'What is Birdor' Page (2025-11-29)

Unified Updated Badge

Summary

Details

Links

MD → JSON Changelog Build Pipeline

Birdor Tools & Docs Update — JWT HS512, JSON Tree Collapsing, Changelog Launch (2025-11-28)

JWT Debugger: HS512 Support and Expiry Hints

Summary

Details

Links

JSON Formatter: Smarter Tree Collapsing

Python Beginner Handbook

Chapter 1 — What Is Python & Why It Matters

Python vs Go vs Rust — A Calm, Developer-Focused Comparison

1. Design Philosophy: What Each Language Values

Python — Readable, expressive, productive

Birdor Website Update — SEO Enhancements & GitHub Header Link (2025-11-27)

SEO Metadata Added for All Tools

Summary

Details

Links

GitHub Icon Added to Site Header

Lua for Game Development — Sample Game

Lua for Game Development — Complete Book

Lua for Game Development — Chapter 19: Packaging, Deployment, Localization & Release Pipeline

1. Build Artifacts: What Needs to Be Packaged?

Lua for Game Development — Chapter 18: Engine Architecture, ECS, Plugins & Optimization

Lua for Game Development — Chapter 17: Save Systems, Persistence, Serialization & Content Pipelines

Lua for Game Development — Chapter 16: Multiplayer, Netcode, Sync Models & Lag Compensation

Lua for Game Development — Chapter 15: UI Systems, HUD, Menus & Data Binding

1. UI Widget System

Lua for Game Development — Chapter 14: Combat AI, Behavior Trees, Utility AI & Enemy Design

1. Enemy Archetypes

Lua for Game Development — Chapter 13: NPCs, Town Simulation, Factions & AI Routines

1. NPC Definitions (Data-Driven)

1.1 Example NPC Definition

Lua for Game Development — Chapter 12: Quests, Missions, Dialogue Trees & Story Progression

Lua for Game Development — Chapter 11: Inventory, Items, Equipment, Crafting & Data-Driven Content

1. Item Definitions (Data-Driven)

Lua for Game Development — Chapter 8: Animation Systems, Cameras, Cutscenes & Timeline Scripting

1. Animation State Machines (ASM)

Lua for Game Development — Chapter 7: UI Systems, HUD, Widgets, Event Binding, and Lua-Driven UI Architecture

1. The Goals of a Good UI Architecture

Lua for Game Development — Chapter 10: Audio, Particles, VFX & Feedback Systems

1. Audio Architecture

Sound Effects (SFX)

Background Music (BGM)

Lua for Game Development — Chapter 9: Scenes, Levels, World Systems & Spawning

Lua for Game Development — Chapter 6: AI Systems — BT, FSM, Utility AI, GOAP, Navigation, Hybrid AI

1. Finite State Machines (FSM)

Lua for Game Development — Chapter 5: Combat Systems, Hitboxes, Stats, Buffs, and Abilities

1. Entity Stats (Base + Modifiers)

Lua for Game Development — Chapter 4: Building a Full Lua Game Architecture

1. The Game Loop (Core of Any Engine)

Lua for Game Development — Chapter 3: Practical Patterns for Real Games

Lua for Game Development — Chapter 2: Language Essentials

1. The Building Blocks of Lua

Lua for Game Development — Chapter 1: Why Lua?

1. What Makes Lua Special?

Lua Deep Dive: Coroutines, State Machines, DSLs, and Game Scripting Architecture

1. Coroutine Pipelines (The Real Power of Lua)

Lua Advanced: Metatables, Coroutines, and Powerful Patterns

1. Metatables: Lua’s Custom Behavior Engine

1.1 Basic Example: __index Fallback

A Practical Introduction to Lua (Beginner Friendly)

1. Setting Up and Running Lua

Install Lua

Run a Script

Building a Tiny HTTP Server from Scratch with net + bufio

A Deep Dive into Go’s net/http Internals

Designing a High-Performance, Multi-Goroutine Socket Server in Go

1. Why the `net` Package Matters

1. Why `context` Exists