Neil Mahajan
Personal Project
July 2025

🐍 Terminal Snake Game in Go

A high-performance, terminal-based Snake game implementation written in Go, showcasing advanced concurrency patterns, data structures, and clean architecture principles.

Go
Goroutines
Channels
Concurrency
Terminal UI
ANSI Escape Sequences
Linked Lists
CLI
GitHub
Terminal
🐍 SNAKE GAME 🐍
Score: 6

████████████████████████████████████████
█ █
█ █
█ █
█ █
█ ●●●●●●● █
█ █
█ █
█ █
█ █
█ ♦ █
█ █
█ █
█ █
█ █
█ █
█ █
█ █
█ █
████████████████████████████████████████
Controls: W/K↑ S/J↓ A/H← D/L→ Q/ESC=Quit

Project Overview

This Terminal Snake Game is a sophisticated implementation written in Go that demonstrates mastery of concurrent programming, efficient data structures, and clean architecture principles. The game features real-time terminal manipulation, non-blocking input handling, and smooth gameplay mechanics.

Built with performance and maintainability in mind, the project showcases advanced Go concepts including goroutines for concurrent input processing, channels for safe communication, and efficient data structures like linked lists for optimal snake body management.

The game supports multiple difficulty levels with configurable board sizes and speeds, responsive controls, and cross-platform compatibility across macOS, Linux, and Windows terminals.

Key Features

Performance & Concurrency

  • Goroutines & Channels: Non-blocking input handling with safe concurrent communication
  • Efficient Data Structures: Linked list implementation for O(1) head/tail operations
  • Real-time Processing: Game loop with precise timing and input processing
  • Memory Optimization: ~2MB baseline memory footprint with minimal allocations

Gameplay & UI

  • Multiple Difficulty Levels: Three board sizes (Small, Medium, Large) and configurable speeds
  • Responsive Controls: Vim-style (hjkl) and WASD movement with direction locking
  • Terminal Programming: Raw terminal manipulation and ANSI escape sequences
  • Cross-platform: Works seamlessly on macOS, Linux, and Windows

Technical Implementation

Architecture & Design Patterns

1. Concurrent Input Processing

// Non-blocking input handling with goroutines
inputChannel := make(chan types.UserInput)
stopChannel := make(chan struct)
go func() {
  defer wg.Done()
  input.ListenForInput(inputChannel, s, stopChannel)
}()

2. Efficient Snake Body Management

// Using container/list for O(1) head/tail operations
type Snake struct {
  Body        *list.List                 // Doubly-linked list
  ShouldGrow  bool
}

3. Channel-based Communication

// Type-safe communication between goroutines
type UserInput struct {
  Direction   string
  Error       error
}

Project Structure

snake/
├── cmd/
│   └── main.go
├── internal/
│   ├── board/
│   │   └── draw_board.go
│   ├── fruit/
│   │   └── create_fruit.go
│   ├── input/
│   │   ├── get_difficulty_input.go
│   │   └── listen_for_input.go
│   ├── snake/
│   │   ├── move_snake.go
│   │   └── new_snake.go
│   └── types/
│       └── types.go
├── go.mod
└── README.md

Performance Metrics

~2MB
Memory Footprint
<1%
CPU Usage
<16ms
Input Latency
80x40
Max Board Size

Gameplay Mechanics

Controls

W / KMove Up
S / JMove Down
A / HMove Left
D / LMove Right
Q / ESCQuit Game

Game Rules

  • Snake grows when consuming fruit (F)
  • Game ends on wall or self-collision
  • Score increases with each fruit consumed
  • Fruit spawns randomly in unoccupied positions
  • Direction locking prevents reverse movement
  • Configurable board sizes and speeds

Installation & Usage

Quick Start

# Clone the repository
git clone https://github.com/Neilsmahajan/snake.git
cd snake
# Install dependencies
go mod tidy
# Run the game
go run cmd/main.go

Build & Deploy

# Build for current platform
go build -o snake cmd/main.go
./snake
# Cross-compile for different platforms
GOOS=linux GOARCH=amd64 go build -o snake-linux cmd/main.go
GOOS=windows GOARCH=amd64 go build -o snake-windows.exe cmd/main.go

Learning Outcomes

This project demonstrates mastery of several advanced Go concepts and software engineering principles:

Go Fundamentals

  • Goroutines & concurrency patterns
  • Channel communication
  • Error handling patterns
  • Memory management
  • Interface design

Software Engineering

  • Clean architecture principles
  • Modular design patterns
  • Resource management
  • Cross-platform compatibility
  • Performance optimization

Game Screenshots

Gameplay
🐍 SNAKE GAME 🐍
Score: 6

████████████████████████████████████████
█ █
█ █
█ █
█ █
█ ●●●●●●● █
█ █
█ █
█ █
█ █
█ ♦ █
█ █
█ █
█ █
█ █
█ █
█ █
█ █
█ █
████████████████████████████████████████
Controls: W/K↑ S/J↓ A/H← D/L→ Q/ESC=Quit
Game Setup
╔══════════════════════════════════════╗
║ 🐍 SNAKE GAME 🐍 ║
║ Written in Go Language ║
╚══════════════════════════════════════╝
Board Size Selection:
[s] - Small (20x10) 📱
[m] - Medium (40x20) 💻
[l] - Large (80x40) 🖥️
Enter your choice: m
✓ Medium board selected!
Speed Selection:
[s] - Slow (200ms) 🐌
[m] - Medium (100ms) 🚶
[l] - Fast (50ms) 🏃
Enter your choice: m
✓ Medium speed selected!
Press Enter to start...
Game Over
╔══════════════════════════════════════╗
║ Game Over ║
╚══════════════════════════════════════╝

🏆 Final Score: 6

🎮 Keep trying! You'll get better! 🎮

Thanks for playing Snake! 🐍
Press ENTER to exit...
Game Controls:
↑ Move Up: W or K
↓ Move Down: S or J
← Move Left: A or H
→ Move Right: D or L
🚪 Quit Game: Q or ESC