diff --git a/README.md b/README.md
index 02de52a..e185ef6 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,5 @@
 # Ziglings
 
-## ⚠️ Attention! Ziglings has moved to Codeberg!
-
-Check out our handy new URL: https://ziglings.org
-
-Or visit the repo directly at: https://codeberg.org/ziglings/exercises
-
-***
-
 Welcome to Ziglings! This project contains a series of tiny
 broken programs (and one nasty surprise).  By fixing them, you'll
 learn how to read and write [Zig](https://ziglang.org/) code.
@@ -59,8 +51,8 @@ $ zig version
 Clone this repository with Git:
 
 ```
-$ git clone https://ziglings.org
-$ cd ziglings.org
+$ git clone https://github.com/ratfactor/ziglings
+$ cd ziglings
 ```
 
 Then run `zig build` and follow the instructions to begin!
@@ -122,10 +114,12 @@ Version-0.11.0-dev.4246+71dfce31b
 
 ## Advanced Usage
 
-It can be handy to check just a single exercise:
+It can be handy to check just a single exercise or _start_ from a
+single exercise:
 
 ```
 zig build -Dn=19
+zig build -Dn=19 start
 ```
 
 You can also run without checking for correctness:
diff --git a/exercises/059_integers.zig b/exercises/059_integers.zig
index 39e077c..4410079 100644
--- a/exercises/059_integers.zig
+++ b/exercises/059_integers.zig
@@ -6,8 +6,7 @@
 //     const a2: u8 = 0x41;      // hexadecimal
 //     const a3: u8 = 0o101;     // octal
 //     const a4: u8 = 0b1000001; // binary
-//     const a5: u8 = 'A';       // ASCII code point literal
-//     const a6: u16 = 'Ȁ';      // Unicode code points can take up to 21 bits
+//     const a5: u8 = 'A';       // UTF-8 code point literal
 //
 // You can also place underscores in numbers to aid readability:
 //
diff --git a/exercises/066_comptime.zig b/exercises/066_comptime.zig
index 124b472..9b07a2d 100644
--- a/exercises/066_comptime.zig
+++ b/exercises/066_comptime.zig
@@ -62,8 +62,8 @@ pub fn main() void {
     // types with specific sizes. The comptime numbers will be
     // coerced (if they'll fit!) into your chosen runtime types.
     // For this it is necessary to specify a size, e.g. 32 bit.
-    var var_int: u32 = 12345;
-    var var_float: f32 = 987.654;
+    var var_int = 12345;
+    var var_float = 987.654;
 
     // We can change what is stored at the areas set aside for
     // "var_int" and "var_float" in the running compiled program.
diff --git a/exercises/067_comptime2.zig b/exercises/067_comptime2.zig
index 136bca1..7d4bdb0 100644
--- a/exercises/067_comptime2.zig
+++ b/exercises/067_comptime2.zig
@@ -35,7 +35,7 @@ pub fn main() void {
     // In this contrived example, we've decided to allocate some
     // arrays using a variable count! But something's missing...
     //
-    comptime var count = 0;
+    var count = 0;
 
     count += 1;
     var a1: [count]u8 = .{'A'} ** count;
diff --git a/exercises/068_comptime3.zig b/exercises/068_comptime3.zig
index 4d8419a..15b8997 100644
--- a/exercises/068_comptime3.zig
+++ b/exercises/068_comptime3.zig
@@ -43,8 +43,7 @@ const Schooner = struct {
         //
         // Please change this so that it sets a 0 scale to 1
         // instead.
-        // if (my_scale == 0) @compileError("Scale 1:0 is not valid!");
-        if (my_scale == 0) my_scale = 1;
+        if (my_scale == 0) @compileError("Scale 1:0 is not valid!");
 
         self.scale = my_scale;
         self.hull_length /= my_scale;
@@ -70,7 +69,7 @@ pub fn main() void {
     // Hey, we can't just pass this runtime variable as an
     // argument to the scaleMe() method. What would let us do
     // that?
-    comptime var scale: u32 = undefined;
+    var scale: u32 = undefined;
 
     scale = 32; // 1:32 scale
 
diff --git a/exercises/069_comptime4.zig b/exercises/069_comptime4.zig
index 0263de0..e090bb3 100644
--- a/exercises/069_comptime4.zig
+++ b/exercises/069_comptime4.zig
@@ -42,8 +42,8 @@ pub fn main() void {
 //     2) Sets the size of the array of type T (which is the
 //        sequence we're creating and returning).
 //
-fn makeSequence(comptime T: type, comptime size: usize) [size]T {
-    var sequence: [size]T = undefined;
+fn makeSequence(comptime T: type, ??? size: usize) [???]T {
+    var sequence: [???]T = undefined;
     var i: usize = 0;
 
     while (i < size) : (i += 1) {
diff --git a/exercises/070_comptime5.zig b/exercises/070_comptime5.zig
index 69a529b..3b85aae 100644
--- a/exercises/070_comptime5.zig
+++ b/exercises/070_comptime5.zig
@@ -123,8 +123,8 @@ fn isADuck(possible_duck: anytype) bool {
     // Please make sure MyType has both waddle() and quack()
     // methods:
     const MyType = @TypeOf(possible_duck);
-    const walks_like_duck = @hasDecl(MyType, "waddle");
-    const quacks_like_duck = @hasDecl(MyType, "quack");
+    const walks_like_duck = ???;
+    const quacks_like_duck = ???;
 
     const is_duck = walks_like_duck and quacks_like_duck;
 
diff --git a/exercises/071_comptime6.zig b/exercises/071_comptime6.zig
index d467184..7723291 100644
--- a/exercises/071_comptime6.zig
+++ b/exercises/071_comptime6.zig
@@ -40,7 +40,7 @@ pub fn main() void {
 
     const fields = @typeInfo(Narcissus).Struct.fields;
 
-    inline for (fields) |field| {
+    ??? {
         if (field.type != void) {
             print(" {s}", .{field.name});
         }
diff --git a/exercises/072_comptime7.zig b/exercises/072_comptime7.zig
index 48bb39e..9bc30fb 100644
--- a/exercises/072_comptime7.zig
+++ b/exercises/072_comptime7.zig
@@ -35,7 +35,7 @@ pub fn main() void {
     // at compile time.
     //
     // Please fix this to loop once per "instruction":
-    inline while (i < instructions.len) : (i += 3) {
+    ??? (i < instructions.len) : (???) {
 
         // This gets the digit from the "instruction". Can you
         // figure out why we subtract '0' from it?
diff --git a/exercises/073_comptime8.zig b/exercises/073_comptime8.zig
index 2e69566..fe1f8ea 100644
--- a/exercises/073_comptime8.zig
+++ b/exercises/073_comptime8.zig
@@ -32,12 +32,12 @@ const llamas = [llama_count]u32{ 5, 10, 15, 20, 25 };
 pub fn main() void {
     // We meant to fetch the last llama. Please fix this simple
     // mistake so the assertion no longer fails.
-    const my_llama = getLlama(4);
+    const my_llama = getLlama(5);
 
     print("My llama value is {}.\n", .{my_llama});
 }
 
-fn getLlama(comptime i: usize) u32 {
+fn getLlama(i: usize) u32 {
     // We've put a guard assert() at the top of this function to
     // prevent mistakes. The 'comptime' keyword here means that
     // the mistake will be caught when we compile!
diff --git a/exercises/074_comptime9.zig b/exercises/074_comptime9.zig
index d5e6e67..6db8ad2 100644
--- a/exercises/074_comptime9.zig
+++ b/exercises/074_comptime9.zig
@@ -39,7 +39,7 @@ const llamas = makeLlamas(llama_count);
 
 // And here's the function. Note that the return value type
 // depends on one of the input arguments!
-fn makeLlamas(comptime count: usize) [count]u8 {
+fn makeLlamas(count: usize) [count]u8 {
     var temp: [count]u8 = undefined;
     var i = 0;
 
diff --git a/exercises/075_quiz8.zig b/exercises/075_quiz8.zig
index 8eee967..12b460c 100644
--- a/exercises/075_quiz8.zig
+++ b/exercises/075_quiz8.zig
@@ -8,8 +8,6 @@
 // of it.
 //
 const print = @import("std").debug.print;
-const mem = @import("std").mem;
-const fmt = @import("std").fmt;
 
 const TripError = error{ Unreachable, EatenByAGrue };
 
@@ -51,47 +49,12 @@ const Path = struct {
 //
 // Please fill in the body of this function!
 fn makePath(from: *Place, to: *Place, dist: u8) Path {
-    return Path{
-        .from = from,
-        .to = to,
-        .dist = dist,
-    };
-}
 
-fn makePath2(comptime path: []const u8) Path {
-    var it = mem.split(u8, path, "->");
-    var from: []const u8 = it.first();
-    it = mem.split(u8, it.next().?, ":");
-    var to: []const u8 = it.first();
-    var dist: []const u8 = it.next().?;
-    return Path{
-        .from = &@field(@This(), from),
-        .to = &@field(@This(), to),
-        .dist = try fmt.parseInt(u8, dist, 10),
-    };
-}
-
-fn makePath3(comptime path: []const u8) Path {
-    var it = mem.split(u8, path, "->");
-    var from: []const u8 = it.first();
-    var list = it.next().?;
-    var connections_it = mem.split(u8, list[1..(path.len - from.len - 3)], " ");
-
-    while (connections_it.next()) |connect| {
-        var connection_it = mem.split(u8, connect, ":");
-        return Path{
-            .from = &@field(@This(), from),
-            .to = &@field(@This(), connection_it.first()),
-            .dist = try fmt.parseInt(u8, connection_it.next().?, 10),
-        };
-    }
 }
 
 // Using our new function, these path definitions take up considerably less
 // space in our program now!
-// const a_paths = [_]Path{makePath(&a, &b, 2)};
-const a_paths = [_]Path{makePath2("a->b:2")};
-// const a_paths = makePath3("a->(b:2)");
+const a_paths = [_]Path{makePath(&a, &b, 2)};
 const b_paths = [_]Path{ makePath(&b, &a, 2), makePath(&b, &d, 1) };
 const c_paths = [_]Path{ makePath(&c, &d, 3), makePath(&c, &e, 2) };
 const d_paths = [_]Path{ makePath(&d, &b, 1), makePath(&d, &c, 3), makePath(&d, &f, 7) };
@@ -191,10 +154,6 @@ pub fn main() void {
     const start = &a; // Archer's Point
     const destination = &f; // Fox Pond
 
-    // makePath3("a->(b:2 d:3)");
-    var temp: Path = makePath3("a->(b:2)");
-    _ = temp;
-
     // We could either have this:
     //
     //   a.paths = a_paths[0..];
diff --git a/exercises/101_for5.zig b/exercises/101_for5.zig
index 200e71d..234cc4f 100644
--- a/exercises/101_for5.zig
+++ b/exercises/101_for5.zig
@@ -84,7 +84,7 @@ pub fn main() void {
 // use a marble scoop, spoon magnet, and feather tongs to grab
 // each type of object.
 //
-// Now, would you rather use the magic bag:
+// Now, would you rather the magic bag:
 //
 // A. Grouped the items in clusters so you have to pick up one
 //    marble, then one spoon, then one feather?
@@ -95,7 +95,7 @@ pub fn main() void {
 //    marbles at once, then all the spoons, then all of the
 //    feathers?
 //
-// If this metaphor is working, hopefully, it's clear that the 'B'
+// If this metaphor is working, hopefully it's clear that the 'B'
 // option would be much more efficient.
 //
 // Well, it probably comes as little surprise that storing and
@@ -120,7 +120,3 @@ pub fn main() void {
 // three arrays of one data type each, like those in the exercise
 // above (SoA).
 //
-// For a more practical application of "data-oriented design"
-// watch the following talk from Andrew Kelley, the creator of Zig:
-// https://vimeo.com/649009599
-//
diff --git a/patches/patches/047_methods.patch b/patches/patches/047_methods.patch
index c64f657..edd9db1 100644
--- a/patches/patches/047_methods.patch
+++ b/patches/patches/047_methods.patch
@@ -1,4 +1,4 @@
-91c91
+92c92
 <             ???.zap(???);
 ---
 >             heat_ray.zap(alien);
diff --git a/patches/patches/059_integers.patch b/patches/patches/059_integers.patch
index c75cf8a..7075ebe 100644
--- a/patches/patches/059_integers.patch
+++ b/patches/patches/059_integers.patch
@@ -1,4 +1,4 @@
-23,25c23,25
+22,24c22,24
 <         0o131, // octal
 <         0b1101000, // binary
 <         0x66, // hex
diff --git a/patches/patches/060_floats.patch b/patches/patches/060_floats.patch
index 0cfa18e..38ebb41 100644
--- a/patches/patches/060_floats.patch
+++ b/patches/patches/060_floats.patch
@@ -1,4 +1,4 @@
-46c46
+43c43
 <     const shuttle_weight: f16 = 907.18 * 2200;
 ---
 >     const shuttle_weight: f32 = 907.18 * 2200.0;