Preface: Why Build Yet Another Go Framework

In today’s highly mature Go ecosystem, “building yet another Go web framework” may seem redundant—or even boring.

We already have:

• Feature-rich, full-stack frameworks with massive communities
• Performance-oriented, low-level HTTP / RPC frameworks
• Cloud-native application runtimes deeply integrated with Kubernetes
• Complete engineering systems tailored for microservices

Plumego is not meant to compete with them.

The motivation behind Plumego comes from a different, often overlooked, set of real-world engineering needs:

Introduction: Comparing Frameworks Is Ultimately About Values

In technical communities, discussions of “Framework A vs Framework B” never seem to end.

But experienced engineers usually understand one thing clearly:

Framework debates are rarely about right or wrong technology—they are about value trade-offs.

Plumego was not created in a “blank market.”
On the contrary, it deliberately chose a seemingly “unattractive” path in an already thriving Go ecosystem.

Therefore, this article does not attempt to prove that:

Introduction: A Responsible Framework Must Define Its “Non-Use Cases”

Any framework that takes engineering quality seriously must be willing to answer one question:

“In what situations should you not use me?”

If a framework claims that it:

• fits every team,
• fits every stage,
• fits every business,

then it is almost certainly not credible.

Plumego was never designed to be a universal answer.
It is a choice explicitly created for a specific class of engineering problems.

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.

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.

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

We will build:

1. A robust game loop
2. Scene management (stack-based)
3. Systems & update flow
4. Input abstraction
5. Resource manager
6. Save/load system
7. Hot reload support
8. 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 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.

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 modern online game backend is not a single monolithic server.
It is a collection of specialized services working together to deliver real-time gameplay, persistent worlds, and social systems.

This chapter introduces the core architectural building blocks:

• Gateway / Connection Layer
• Room / Match Server
• World Server
• Matchmaking Service
• Persistence Layer (DB, Cache)
• Supporting Services (Chat, Social, Inventory, etc.)

By the end, you’ll understand how these pieces fit together into a working online game.

Online multiplayer games—from small casual titles to massive MMOs—are powered by one critical element:
the game server.

This chapter gives a clear, friendly, and complete introduction to what game servers are, why they exist, how they work, and what technologies surround them.
It is written for total beginners, but structured with the accuracy expected of modern production systems.

1. What Is an Online Game Server?

A game server is a backend program running on a remote machine.
It manages all shared rules, simulation, and persistence in a multiplayer game.

Series Index

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:

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.

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.

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: