YouTube on Colan Biemer

Data Structures & Algorithms: Bubble Sort

Mon, 29 Jun 2026 12:00:00 +0000

In this video, I explain bubble sort and how to implement it in Go. Hope it helps!

Links:

Project repo: https://github.com/bi3mer/data-structures-and-algorithms

Implementation (Go): https://github.com/bi3mer/data-structures-and-algorithms/tree/main/Sort/BubbleSort

Previous video (selection sort in C): https://www.youtube.com/watch?v=2cNuPpzcbVU&t

Gopher by Renée French, CC3.0: https://github.com/golang-samples/gopher-vector

Data Structures & Algorithms: Selection Sort

Wed, 24 Jun 2026 12:00:00 +0000

In this video, I explain selection sort and how to implement it in Go. Hope it helps!

Links:

Project repo: https://github.com/bi3mer/data-structures-and-algorithms

Implementation (Go): https://github.com/bi3mer/data-structures-and-algorithms/blob/main/Sort/SelectionSort/main.go

Previous video (selection sort in C): https://www.youtube.com/watch?v=LuxDiQ7-i38

Gopher by Renée French, CC3.0: https://github.com/golang-samples/gopher-vector

Data Structures & Algorithms: Arrays and Linear Search

Mon, 16 Mar 2026 12:00:00 +0000

An introduction to arrays and linear search, live-coded in C11.

In this video we cover:

Declaring and initializing arrays
Accessing and modifying elements
Implementing linear search from scratch
Brief analysis time complexity

All code is written live in C11 with no frameworks or libraries — just the standard library and a text editor.

I Ran My Game 30,000 Times to Find Bugs

Fri, 23 Jan 2026 12:00:00 +0000

I built a simple automated tester for my game—30,000 runs, zero crashes. Here’s how it works.

Testing your own game is hard because you play it the way it’s meant to be played. Players won’t. Hiring a QA team is overkill for a solo project. So I built a fuzz tester instead: a Python script that runs my game thousands of times with random inputs and logs the results. The whole setup took an afternoon. In this video I walk through the Python script, the conditional compilation, and the random “agent” that plays the game.

Creating a Full Tic-Tac-Toe Game You Can't Beat | C & Raylib

Thu, 27 Nov 2025 12:00:00 +0000

Learn how to program a complete Tic-Tac-Toe game in C with Raylib, featuring an unbeatable AI opponent using the Minimax algorithm! We’ll build everything: the game board, mouse input handling, game logic, and an intelligent computer player that plays perfectly every time.

GET THE CODE: https://github.com/bi3mer/c-tic-tac-toe

Snake in C - Under 400 Lines (Full Tutorial)

Fri, 21 Nov 2025 12:00:00 +0000

Learn how to build the classic Snake game in C from scratch! In this tutorial, we’ll create a fully functional Snake game in under 400 lines of clean, readable code using C and Raylib. Perfect for beginners wanting to learn game programming in C or anyone interested in understanding the fundamentals of game development without unnecessary complexity.

Code Pong in 220 Lines of C | Raylib Game Programming

Thu, 13 Nov 2025 12:00:00 +0000

Learn to code the classic Pong game in C using Raylib in just 220 lines of clean, beginner-friendly code!

In this tutorial, you’ll learn:

Setting up a Raylib game window
Implementing paddle controls and movement
Ball physics and collision detection
Score tracking and display

Perfect for beginners wanting to learn game programming in C or anyone interested in Raylib development.

How Games Find The Shortest Path Between Two Points

Fri, 07 Nov 2025 12:00:00 +0000

Learn how pathfinding algorithms work through interactive visualizations. In this video, I implement and compare three fundamental search algorithms - Depth-First Search (DFS), Breadth-First Search (BFS), and A* - showing exactly how each one explores a grid to find the optimal path.

We’ll cover how DFS explores deeply before backtracking, why BFS guarantees the shortest path in unweighted grids, and how A* uses heuristics to find paths efficiently. Everything is implemented in C using Raylib for visualization with terrain generation via Perlin noise.

From 100 Compiles to Zero: adjust.h (C Hot Reload)

Wed, 29 Oct 2025 12:00:00 +0000

Stop recompiling your C code just to change a number. adjust.h is a single-header library that lets you edit variables while your program is running - no rebuilds needed. Just include the header, mark your variables, and watch them update live as you edit your source file. In this video, I’ll show you how to set it up and demonstrate why this simple tool can save you time.

Hot Reloading Constants: Tweak Values Without Recompiling

Tue, 07 Oct 2025 12:00:00 +0000

Tired of the compile-restart-test loop when tuning parameters? In this video, I show you a clever technique for hot reloading hardcoded constants. By wrapping values in a TWEAK() macro, you can edit numbers directly in your source code and see them update in real-time while your program is running—no recompiling or restarting needed.

Boids with Raylib and C++

Mon, 15 Sep 2025 12:00:00 +0000

In this video, I implement a Boids flocking simulation using C++ and Raylib. Watch as autonomous agents exhibit emergent behavior through simple rules of separation, alignment, and cohesion, creating mesmerizing patterns that mimic real-world flocking behaviors found in birds, fish, and other animals.

Raylib: https://www.raylib.com/
Source Code: https://gist.github.com/bi3mer/0017a28837bfa4f380364c6a4e089f68

Creating a Sorting Visualization with C++ and Raylib

Mon, 08 Sep 2025 12:00:00 +0000

In this video, I build a real-time sorting algorithm visualizer using C++ and Raylib. Watch as the sorting process comes to life through smooth animations and colorful graphics, demonstrating how the algorithm works under the hood with visual feedback for each comparison and swap operation.

Block Randomization Web Server in Go - Participant Assignment, Logging, & Static Serving

Mon, 01 Sep 2025 12:00:00 +0000

I live code a Go web server that uses block randomization to assign participants to different conditions in experiments. The server also handles logging and serving static files for the experiment interface.

Block randomization is a technique that ensures you get equal numbers of participants in each group throughout your study, which is important for getting valid results. Instead of pure random assignment, it assigns participants in blocks to keep the groups balanced.

Coding Sokoban pt. 31: Conclusion

Mon, 25 Aug 2025 12:00:00 +0000

Part 31: Conclusion -

Part 31 brings our Sokoban journey to a close. I play through some levels of our completed game and share what’s coming next in future projects. Thank you all for joining me, and I hope you enjoyed the videos :D

Project Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban pt. 30: Bug Fixing

Fri, 22 Aug 2025 12:00:00 +0000

Part 30: Level Loading Bug Fix and a Debugging Technique

Part 30 tackles a bug in our level loading system: we could only load rectangular levels! We fix this limitation to support arbitrary level shapes, plus demonstrate a valuable debugging technique for verifying that our new ring buffer behaves identically to the old linked list.

Coding Sokoban pt. 29: Ring Buffer (2)

Wed, 20 Aug 2025 12:00:00 +0000

Part 29: Ring Buffer (2)

Part 29 completes our ring buffer implementation and puts it head-to-head with our pooled linked list in speed tests. The results are surprising - ring buffer wins on cold starts, but our object-pooled linked list actually performs better when everything is pre-initialized.

Coding Sokoban pt. 28: Ring Buffer (1)

Mon, 18 Aug 2025 12:00:00 +0000

Part 28 starts a small refactor. We start replacing our custom linked list with a ring buffer implementation for our undo system. This change will provide better performance characteristics and more predictable memory usage. They’re simpler and more predictable than dynamic linked lists.

Project Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban pt. 27: Convenient Logging

Fri, 15 Aug 2025 12:00:00 +0000

Part 27: Convenient Logging

Part 27 upgrades our logging system with modern C++ techniques! We eliminate the need for users to manually call std::format by implementing template parameter packing and perfect forwarding, creating a much more convenient logging experience.

Instead of log(std::format(“Player at {}, {}”, x, y)), users can now simply write log(“Player at {}, {}”, x, y).

Coding Sokoban pt. 26: std::bitset

Wed, 13 Aug 2025 12:00:00 +0000

Part 26: std::bitset

Part 26 refactors our core game representation! We replace the unsigned char* implementation with std::bitset for our game elements, making the code much more readable and maintainable while keeping the same efficient bitboard approach.

Project Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban pt. 25: State / Flags

Mon, 11 Aug 2025 12:00:00 +0000

Part 25: State / Flags - State Machine Fix and Compiler Warnings Cleanup

Part 25 tackles two important code quality issues. We enhance our state machine with proper on_enter and on_exit functions to fix a bug, then dive into compiler flags and clean up all the warnings in our codebase.

Coding Sokoban pt. 24: Better IO

Fri, 08 Aug 2025 12:00:00 +0000

Part 24: Better IO - Byte-by-Byte File Reading Optimization

Part 24 overhauls how we load in level files. We replace the old file reading approach with a much more efficient byte-by-byte method for loading level files.

Project Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban pt. 23: Scrolling

Wed, 06 Aug 2025 12:00:00 +0000

Part 23: Scrolling

Part 23 starts with fixing a game-freezing bug from the previous episode, then moves on to the main feature: adding scrolling to our grid-based level progression. Now players can navigate through large collections of levels smoothly!

Project Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban pt. 22: Memory

Mon, 04 Aug 2025 12:00:00 +0000

Part 22: Memory

Part 22 tackles memory management head-on! We fix a potential issue where excessive undo commands could exhaust memory, and improve the underlying Sokoban representation to eliminate unnecessary malloc/free operations when loading levels.

Project Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban pt. 21: Results Message

Fri, 01 Aug 2025 12:00:00 +0000

Part 21: Results Message - Celebrating Player Achievements

Part 21 adds the finishing touches to our object pool and linked list, then implements a results message system to celebrate when players beat their previous records.

Project Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban pt. 20: Object Pool

Wed, 30 Jul 2025 12:00:00 +0000

Part 20: Object Pool

Part 20 is all about craftsmanship! We implement an object pool and update our linked list to use it, reducing memory allocations. While Sokoban doesn’t need this level of optimization, it’s about writing quality software that we can be proud of.

Coding Sokoban pt. 19: Block Undo

Mon, 28 Jul 2025 12:00:00 +0000

Part 19: Block Undo

Part 19 completes our undo system! We implement block undo using the command pattern and fix three critical bugs in our linked list implementation. Now, players have full undo functionality, making the game that much easier!

Project Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban pt. 18: Player Undo

Fri, 25 Jul 2025 12:00:00 +0000

Part 18: Player Undo - Progress with a Bug Discovery

Part 18 tackles the highly anticipated undo feature! We implement player undo functionality using our linked list, but discover a bug in our implementation along the way. Still, we manage to get partial undo working - players can undo their movement, with block undo coming in the next episode.

Coding Sokoban pt. 17: Linked List

Wed, 23 Jul 2025 12:00:00 +0000

Part 17: Linked List - Foundation for Undo System

Part 17 sets up undo! We implement a custom linked list data structure that will serve as the backbone for our command pattern implementation. This foundational work enables the undo system coming next.

GitHub Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDRn

Coding Sokoban pt. 16: Time and UI

Mon, 21 Jul 2025 12:00:00 +0000

Part 16: Time and UI In Part 16, we implement the UI elements to display move count and completion time, giving players real-time feedback on their performance and showing their best results. We also fix a bug with how the time it took to solve a level was calculated by using std::chrono.

Coding Sokoban pt. 15: Level Data

Fri, 18 Jul 2025 12:00:00 +0000

Part 15: Level Data

Part 15 brings level data to the game! We implement tracking for the number of moves and completion time for each level. Next up is to add UI so that players can see their performance and challenge themselves to improve.

GitHub Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban pt. 14: Better Saving

Wed, 16 Jul 2025 12:00:00 +0000

🔧 Part 14: Better Saving

Part 14 has two parts. First, I fixed a bug with the level unlocking code. Second, I remove the save_system from before and make it part of the application state. I also added tracking for the number of moves the player took to beat a level and the time that it took them. This sets up nicely to finally get to saving stats per level

Coding Sokoban pt. 13: Application State

Mon, 14 Jul 2025 12:00:00 +0000

Part 13: Application State Part 13 lays crucial groundwork for our next major feature! Before we can track move count and completion time, we need a proper application state system. This episode builds the foundation that will make those features possible and easy to track for each level.

Coding Sokoban pt. 12: Logging

Fri, 11 Jul 2025 12:00:00 +0000

Part 12: Adding a Logging System - Essential Debugging Tools Time for some behind-the-scenes infrastructure! In this episode, I take a break from user-facing features to implement a proper logging system. Sometimes the most important work happens behind the scenes - this foundation will make all future development much smoother!

Coding Sokoban Part 11: Saving

Wed, 09 Jul 2025 12:00:00 +0000

Part 11: Level Unlocking + Save System

Part 11 completes our progression system! We implement the actual unlock mechanics and add a save system so players can quit and return without losing their hard-earned progress. Plus, auto-saving for seamless gameplay.

Now we have a fully functional puzzle game with proper progression - players can actually work through the levels and keep their progress!

Coding Sokoban Part 10: Grid View

Mon, 07 Jul 2025 12:00:00 +0000

Part 10: Level Selection Grid with Visual Unlock System

In this episode, we upgrade our level progression to a grid-based level selector with visual unlock indicators. The UI shows which levels are locked and unlocked, but the actual unlock logic will be implemented in part 11.

Coding Sokoban Part 9: Level Progression

Fri, 04 Jul 2025 12:00:00 +0000

Part 9: Level Progression System + Vim Keybindings

Part 9 brings exciting new functionality! We’re evolving from a single-level demo into a proper multi-level puzzle game. Plus, some fantastic quality of life improvements that will make both development and gameplay much more enjoyable.

GitHub Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban Part 8: Instructions

Tue, 01 Jul 2025 12:00:00 +0000

Part 8: Instruction Menu

Part 8 continues our journey! We enhance the main menu system with proper interaction handling and make an important correction that demonstrates good C++ practices.

GitHub Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban Part 7: State Machine Basics

Sun, 29 Jun 2025 12:00:00 +0000

Part 7: State Machine Architecture + Quality of Life Improvements

Part 7 is packed with improvements! We tackle both technical debt and user experience enhancements, implementing a proper state machine architecture while adding features that make the game genuinely enjoyable to play.

Project repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban Part 6: Menu interaction

Thu, 26 Jun 2025 12:00:00 +0000

Part 6: Main Menu - Completing the Game Experience

Welcome to part 6! We’re transforming our Sokoban project from a simple game into a polished application with a fully interactive main menu system. This is where our game starts feeling like a real product!

Project Repository: https://github.com/bi3mer/sokoban
Series Playlist: https://www.youtube.com/watch?v=1qzPr5OpPOE&list=PLwaZncztKsRckZ0u3sKbwkZMtH1-ABkDR

Coding Sokoban Part 5: Restarting

Tue, 24 Jun 2025 12:00:00 +0000

Part 5: Player Restarting

Part 5 brings a crucial gameplay feature and an important learning opportunity! We implement the restart functionality that every puzzle game needs, but more importantly, I show you two different approaches - one efficient, one not so much. Understanding what NOT to do is just as valuable as learning the right way.

Coding Sokoban Part 4: Colors and a Main Menu

Fri, 20 Jun 2025 12:00:00 +0000

Part 4: Adding Colors & a Main Menu - Bringing Sokoban to Life!

The refactoring in part 3 pays off! In this episode, we leverage our clean codebase to add visual flair and user interface improvements to our Sokoban game. Watch as the game transforms from functional to genuinely appealing.

Coding Sokoban Part 3: Organization

Thu, 19 Jun 2025 12:00:00 +0000

Part 3: Organization - Preparing Sokoban for Advanced Features

Welcome to part 3 of the Sokoban C++ series! Sometimes the most important work happens behind the scenes. In this episode, I take a step back from adding flashy new features to focus on something crucial: clean, maintainable code architecture.

Coding Sokoban Part 2: ncurses

Tue, 17 Jun 2025 12:00:00 +0000

Part 2: Enhancing Sokoban with ncurses - Adding Visual Polish to C++ Games

Back with part 2! In my previous video, we built a functional Sokoban game using bitboards, but let’s be honest - it wasn’t much to look at. Time to fix that! In this follow-up, I show you how to transform a basic console game into an engaging visual experience using the ncurses library.

Coding Sokoban Part 1: Bitboards

Thu, 12 Jun 2025 12:00:00 +0000

Live Coding: Building Sokoban Game in C++ Using Bitboards

Watch me code a complete Sokoban puzzle game from scratch using C++! In this live coding session, I demonstrate how to implement the classic box-pushing puzzle game using bitboards for an efficient representation of the game state.

Graph Simplification for a Faster A*

Tue, 06 Sep 2022 12:00:00 +0000

In this video I show a way to simplify graphs for pathfinding to speed up A*.

Implementation: https://github.com/bi3mer/simplifying_graphs_for_pathfinding NetworkX: https://networkx.org/

A* Info: Red Blob Games A* Blog: https://www.redblobgames.com/pathfinding/a-star/introduction.html Sebastian Lague A* video: https://www.youtube.com/watch?v=-L-WgKMFuhE&t

Me: Personal website: colan.biemer.us Github: https://github.com/bi3mer Twitter: https://twitter.com/bi3mer

Other: Stock videos from: https://pixabay.com/

On Linking Level Segments - CoG 2022 Talk

Wed, 24 Aug 2022 12:00:00 +0000

This is the talk I did for the IEEE Conference on Games (CoG) 2022 on the paper I wrote with Seth Cooper, On Linking Level Segments, which was nominated for best paper. (The winner of the best paper award also has a talk which is available at https://www.youtube.com/watch?v=mnNKdOzi0F4&t=6s&ab_channel=TeaPea.) A link to the arxiv version of the paper and the abstract is below.

Gram-Elites: N-Gram Based Quality Diversity Search

Thu, 05 Aug 2021 12:00:00 +0000

This is a talk I did for the PCG Workshop on the paper by the same name as this video. The abstract for the paper is below, and once the paper is uploaded I will include a link.

In the context of procedural content generation via machine learning (PCGML), quality-diversity (QD) algorithms are a powerful tool to generate diverse game content. A branch of QD uses genetic operators to generate content (e.g. MAP-Elites). Problematically, levels generated with these operators have no guarantee of matching the style of a game. This can be addressed by incorporating whether a level is generable by an n-gram into the fitness function. Unfortunately, this leads to wasted computation and poor results. In this work, we introduce n-gram genetic operators, which produce only solutions that are generable by the n-gram model; we call MAP-Elites combined with these operators Gram-Elites. We test on a tile-based side-scrolling platformer, vertical platformer, and roguelike. For all three, n-gram operators outperform standard operators and random n-gram generation, finding more usable (i.e. completable and generable) solutions at a faster rate. By integrating structure into operators, instead of fitness, these genetic operators could be beneficial to QD in PCGML.

Markov Decision Processes

Tue, 28 Apr 2020 12:00:00 +0000

Russell, Stuart, and Peter Norvig. “Artificial intelligence: a modern approach.” (2002).

N-Grams for Game AI

Wed, 25 Mar 2020 12:00:00 +0000

A short presentation on N-Grams for game ai course.

C# implementation: https://github.com/bi3mer/UnityAITools/tree/master/NGram

Harry Potter N-Grams: https://bi3mer.github.io/blog/post_22/index.html

Python - JSON file to Schema

Tue, 10 May 2016 12:00:00 +0000

Convert JSON file to a schema. Source can be found at: https://github.com/bi3mer/CreateJSONSchema

Dodge Bird

Sat, 31 Oct 2015 12:00:00 +0000

Made this game for a girl scouts game jam at EGS in a little over 6 hours. If you’re wondering yes this can be played on the Cira Center and has been. There are two game modes easy and hard, here I play easy then hard. In hard you’ll notice not only are there more rain drops but there are is also wind which will push the rain drops.

My Best Man Speech

Fri, 30 May 2014 12:00:00 +0000

filmed by margot

competitve tetris

Thu, 27 Mar 2014 12:00:00 +0000

competitve tetris

UIAlertView and Changing views in IOS

Thu, 16 May 2013 12:00:00 +0000

this goes over the basics of programming with alert and what to do with them and how to show them. It does not show how to make use of the input from the buttons but that will be covered later on. Furthermore it shows how to create different views within an app through a fairly simple method

Basic objective-c Programing: Button and Label

Wed, 15 May 2013 12:00:00 +0000

This goes over some basic programming with buttons and labels in xcode while making use of the .xib file.