diff --git a/Entity.hpp b/Entity.hpp
index 8fb4f492a4368cdff5aec887ec90c1046693a74a..83a17685dbe27510e94901ad0f0eef3a248488a3 100644
--- a/Entity.hpp
+++ b/Entity.hpp
@@ -18,7 +18,9 @@ protected:
 	float hittime = 0.0f;
 	Color hitcolor;
 
-	// Entity-specific step method.
+	// Entity-specific step method. This one was already implemented in all
+	// derived classes, which is why [PlayerX] and [PlayerY] are passed like
+	// that.
 	virtual void doStep(
 		float PlayerX, float PlayerY, FloatSeconds const & Frametime, Level &level
 	);
diff --git a/PixelBuffer.cpp b/PixelBuffer.cpp
index 050f0bafab7c98985d8aa315076f391a15b0f520..d1696e678b6e11197d1872bcca3aa1a898ebe28e 100644
--- a/PixelBuffer.cpp
+++ b/PixelBuffer.cpp
@@ -40,6 +40,9 @@ Color DynamicPixelBuffer::peekUnchecked(PixelPoint const &pos) const
 Color& DynamicPixelBuffer::at(PixelPoint const& pos)
 {
 	if(pos.x < 0 || pos.x >= w() || pos.y < 0 || pos.y >= h()) {
+		// Might have been inspired by Daniel J. Bernstein's "boringcc"
+		// proposal:
+		// https://groups.google.com/g/boring-crypto/c/48qa1kWignU/m/dY0R7SjnDAAJ
 		trap = _t;
 		return trap;
 	}
diff --git a/PixelBuffer.hpp b/PixelBuffer.hpp
index 44c6333af5e8c69df86b58107b6a0d85165df9d4..55d73d3bba814b7851baa0e3ea23b7638da204bd 100644
--- a/PixelBuffer.hpp
+++ b/PixelBuffer.hpp
@@ -54,11 +54,15 @@ static constexpr Color _t = { ColorValue::_t };
 // turn needed by PixelIterator...
 class PixelIterator;
 
+// Actually more of a pixel shader interface rather than a buffer... Might
+// have been inspired by Go's Image interface:
+// https://golang.org/pkg/image/#Image
 class PixelBuffer {
 	friend class PixelIterator;
 
 private:
-	// Why does C++ not have destructive moves?! :(
+	// Why does C++ not have destructive moves?! :( These could be `const` and
+	// `public` otherwise.
 	int width;
 	int height;
 
@@ -75,7 +79,7 @@ public:
 	int const w() const { return width; }
 	int const h() const { return height; }
 
-	// Bounds-checked, read-only accessor.
+	// Bounds-checked accessor.
 	Color peek(PixelPoint const &pos) const;
 
 	constexpr PixelBuffer(int w, int h)
@@ -86,6 +90,9 @@ public:
 	PixelIterator end() const;
 };
 
+// May not have been worth the over-engineering effort, given that it "just"
+// flattens two nested `for` loop into a single one… but look, we can also get
+// rid of the bounds checks this way! Then again, it's read-only… oh well.
 class PixelIterator {
 protected:
 	PixelBuffer const *const buffer;
@@ -116,12 +123,17 @@ public:
 	}
 };
 
+// A PixelBuffer with a std::array<W, H> as its buffer. Can be used if the
+// size is known at compile time. Has a constexpr constructor, making it
+// especially useful for sprite definitions.
 template <size_t W, size_t H> class StaticPixelBuffer : public PixelBuffer {
 public:
+	// Since we take string literals with an implicit \0 at the end, the input
+	// type has to have 1 more column.
 	using BufferType      = std::array<std::array<Color, (W    )>, H>;
 	using BufferInputType = std::array<std::array<char,  (W + 1)>, H>;
 
-	const BufferType buffer;
+	BufferType const buffer;
 
 	constexpr StaticPixelBuffer(BufferInputType const &chars)
 		: PixelBuffer(W, H), buffer(filter_null_terminators(chars)) {
@@ -166,11 +178,15 @@ protected:
 	}
 };
 
+// A PixelBuffer with a std::vector<Color> as its buffer. Also has unique
+// blitting methods for copying the contents of other PixelBuffers to certain
+// positions within this buffer.
 class DynamicPixelBuffer : public PixelBuffer {
 public:
 	DynamicPixelBuffer(int w, int h);
 
 	Color peekUnchecked(PixelPoint const &pos) const;
+	// Returns [trap] if [pos] is outside the buffer boundaries.
 	Color& at(PixelPoint const &pos);
 	void clear(Color ch = {});
 
@@ -181,9 +197,11 @@ protected:
 	std::vector<Color> buffer;
 };
 
-// Pixel shaders
-// -------------
-
+// Base class for any pixel shader that takes an existing PixelBuffer as its
+// input.
+// …yeah, it does nothing other than enforce that structure. Why did we end up
+// with this class? Eh, maybe it's nice for semantic reasons. Maybe.
+// (Prof. Teßmann would disagree)
 class ShadedPixelBuffer : public PixelBuffer {
 protected:
 	PixelBuffer const& input;
@@ -193,6 +211,5 @@ public:
 		: PixelBuffer(input.w(), input.h()), input(input) {
 	}
 };
-// -------------
 
 #endif // PIXELBUFFER_HPP
diff --git a/Platform_Win32Console.cpp b/Platform_Win32Console.cpp
index 70f6599c4e82fb369dd58650d8d982d004322a5d..881cdba4cc3e54817c5ab79e62df99ebd2e781b6 100644
--- a/Platform_Win32Console.cpp
+++ b/Platform_Win32Console.cpp
@@ -22,6 +22,7 @@ void fatal(std::wstring_view message)
 	ExitProcess(1);
 }
 
+// You know, I'm too old to not handle errors the right way.
 void fatal_from_lasterror(
 	std::wstring_view file, unsigned int line, DWORD lasterror
 )
diff --git a/Projectile.hpp b/Projectile.hpp
index 1408ca3e1dba763a0c20b55d82c5284ff991d800..e61c1f03c30a3f2ad36b4c598b503f033d319fad 100644
--- a/Projectile.hpp
+++ b/Projectile.hpp
@@ -6,6 +6,9 @@
 //Hauerch71498 ----------------------------------------------------------------------------------------------
 class Level;
 
+// Did not manage to derive this from Entity during crunch time, since we
+// didn't need its functionality. That's why it still has its own [x] and [y]
+// members.
 class Projectile
 {
 public: